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

neuro_simulator/agent/tools/manager.py

@@ -2,119 +2,142 @@
 """The central tool manager for the agent, responsible for loading, managing, and executing tools."""
 
 import os
+import json
 import importlib
 import inspect
 import logging
+import shutil
 from pathlib import Path
-from typing import Dict, Any, List
+from typing import Any, Dict, List
 
 from .base import BaseTool
 from ..memory.manager import MemoryManager
+from ...core.path_manager import path_manager
 
 logger = logging.getLogger(__name__.replace("neuro_simulator", "agent", 1))
 
 class ToolManager:
     """
     Acts as a central registry and executor for all available tools.
-    This manager dynamically loads tools from the 'tools' directory, making the system extensible.
+    This manager dynamically loads tools from the user's working directory.
     """
 
     def __init__(self, memory_manager: MemoryManager):
-        """
-        Initializes the ToolManager.
-        Args:
-            memory_manager: An instance of MemoryManager, passed to tools that need it.
-        """
+        if not path_manager:
+            raise RuntimeError("PathManager not initialized before ToolManager.")
         self.memory_manager = memory_manager
         self.tools: Dict[str, BaseTool] = {}
-        self._load_and_register_tools()
+        self.agent_tool_allocations: Dict[str, List[str]] = {}
 
-        # Hardcoded initial allocation of tool tags to agent types
-        self.agent_tool_allocations = {
-            "neuro_agent": ["communication", "memory_read"],
-            "memory_agent": ["memory_write", "memory_read"]
-        }
-        logger.info(f"Initial tool allocations set: {self.agent_tool_allocations}")
+        self._copy_builtin_tools()
+        self.reload_tools()  # Initial load
+        self._load_allocations()
+
+    def _copy_builtin_tools(self):
+        """Copies the packaged built-in tools to the working directory, overwriting existing ones."""
+        try:
+            import pkg_resources
+            source_dir_str = pkg_resources.resource_filename('neuro_simulator', 'agent/tools')
+            source_dir = Path(source_dir_str)
+        except (ModuleNotFoundError, KeyError):
+            source_dir = Path(__file__).parent
+
+        dest_dir = path_manager.builtin_tools_dir
+        if not dest_dir.exists():
+            os.makedirs(dest_dir)
+
+        for item in os.listdir(source_dir):
+            source_item = source_dir / item
+            if source_item.is_file() and source_item.name.endswith('.py') and not source_item.name.startswith(('__', 'manager')):
+                shutil.copy(source_item, dest_dir / item)
+        logger.info(f"Built-in tools copied to {dest_dir}")
 
     def _load_and_register_tools(self):
-        """Dynamically scans the 'tools' directory, imports modules, and registers tool instances."""
+        """Dynamically scans the user tools directory, imports modules, and registers tool instances."""
         self.tools = {}
-        tools_dir = Path(__file__).parent
-        package_name = self.__module__.rsplit('.', 1)[0]
-
-        for filename in os.listdir(tools_dir):
-            if filename.endswith('.py') and not filename.startswith(('__', 'base', 'manager')):
-                module_name = f".{filename[:-3]}"
-                try:
-                    module = importlib.import_module(module_name, package=package_name)
-                    for _, cls in inspect.getmembers(module, inspect.isclass):
-                        if issubclass(cls, BaseTool) and cls is not BaseTool:
-                            tool_instance = cls(memory_manager=self.memory_manager)
-                            if tool_instance.name in self.tools:
-                                logger.warning(f"Duplicate tool name '{tool_instance.name}' found. Overwriting.")
-                            self.tools[tool_instance.name] = tool_instance
-                            logger.info(f"Successfully loaded and registered tool: {tool_instance.name}")
-                except Exception as e:
-                    logger.error(f"Failed to load tool from {filename}: {e}", exc_info=True)
+        tools_dir = path_manager.user_tools_dir
+        
+        for root, _, files in os.walk(tools_dir):
+            for filename in files:
+                if filename.endswith('.py') and not filename.startswith('__'):
+                    module_path = Path(root) / filename
+                    # Create a module spec from the file path
+                    spec = importlib.util.spec_from_file_location(module_path.stem, module_path)
+                    if spec:
+                        try:
+                            module = importlib.util.module_from_spec(spec)
+                            spec.loader.exec_module(module)
+                            for _, cls in inspect.getmembers(module, inspect.isclass):
+                                if issubclass(cls, BaseTool) and cls is not BaseTool:
+                                    tool_instance = cls(memory_manager=self.memory_manager)
+                                    if tool_instance.name in self.tools:
+                                        logger.warning(f"Duplicate tool name '{tool_instance.name}' found. Overwriting.")
+                                    self.tools[tool_instance.name] = tool_instance
+                                    logger.info(f"Successfully loaded and registered tool: {tool_instance.name}")
+                        except Exception as e:
+                            logger.error(f"Failed to load tool from {module_path}: {e}", exc_info=True)
+
+    def _load_allocations(self):
+        """Loads tool allocations from JSON files, creating defaults if they don't exist."""
+        default_allocations = {
+            "neuro_agent": ["speak", "get_core_memory_blocks", "get_core_memory_block"],
+            "memory_agent": ["add_temp_memory", "create_core_memory_block", "update_core_memory_block", "delete_core_memory_block", "add_to_core_memory_block", "remove_from_core_memory_block", "get_core_memory_blocks", "get_core_memory_block"]
+        }
+
+        # Load neuro agent allocations
+        if path_manager.neuro_tools_path.exists():
+            with open(path_manager.neuro_tools_path, 'r', encoding='utf-8') as f:
+                self.agent_tool_allocations['neuro_agent'] = json.load(f)
+        else:
+            self.agent_tool_allocations['neuro_agent'] = default_allocations['neuro_agent']
+            with open(path_manager.neuro_tools_path, 'w', encoding='utf-8') as f:
+                json.dump(default_allocations['neuro_agent'], f, indent=2)
+
+        # Load memory agent allocations
+        if path_manager.memory_agent_tools_path.exists():
+            with open(path_manager.memory_agent_tools_path, 'r', encoding='utf-8') as f:
+                self.agent_tool_allocations['memory_agent'] = json.load(f)
+        else:
+            self.agent_tool_allocations['memory_agent'] = default_allocations['memory_agent']
+            with open(path_manager.memory_agent_tools_path, 'w', encoding='utf-8') as f:
+                json.dump(default_allocations['memory_agent'], f, indent=2)
+        
+        logger.info(f"Tool allocations loaded: {self.agent_tool_allocations}")
 
     def get_all_tool_schemas(self) -> List[Dict[str, Any]]:
-        """
-        Returns a list of serializable schemas for all registered tools.
-        This is the 'API documentation' for the agent.
-        """
         return [tool.get_schema() for tool in self.tools.values()]
 
     def get_tool_schemas_for_agent(self, agent_name: str) -> List[Dict[str, Any]]:
-        """
-        Returns a list of tool schemas available to a specific agent
-        based on the configured name allocations.
-        """
         allowed_names = set(self.agent_tool_allocations.get(agent_name, []))
         if not allowed_names:
             return []
-
         return [tool.get_schema() for tool in self.tools.values() if tool.name in allowed_names]
 
     def reload_tools(self):
-        """Forces a re-scan and registration of tools from the tools directory."""
         logger.info("Reloading tools...")
         self._load_and_register_tools()
         logger.info(f"Tools reloaded. {len(self.tools)} tools available.")
 
     def get_allocations(self) -> Dict[str, List[str]]:
-        """Returns the current agent-to-tool-tag allocation mapping."""
         return self.agent_tool_allocations
 
     def set_allocations(self, allocations: Dict[str, List[str]]):
-        """
-        Sets a new agent-to-tool allocation mapping.
-
-        Args:
-            allocations: A dictionary mapping agent names to lists of tool names.
-        """
-        # Basic validation can be added here if needed
         self.agent_tool_allocations = allocations
-        logger.info(f"Tool allocations updated: {self.agent_tool_allocations}")
+        # Persist the changes to the JSON files
+        with open(path_manager.neuro_tools_path, 'w', encoding='utf-8') as f:
+            json.dump(allocations.get('neuro_agent', []), f, indent=2)
+        with open(path_manager.memory_agent_tools_path, 'w', encoding='utf-8') as f:
+            json.dump(allocations.get('memory_agent', []), f, indent=2)
+        logger.info(f"Tool allocations updated and saved: {self.agent_tool_allocations}")
 
     async def execute_tool(self, tool_name: str, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Executes a tool by its name with the given parameters.
-
-        Args:
-            tool_name: The name of the tool to execute.
-            **kwargs: The parameters to pass to the tool's execute method.
-
-        Returns:
-            A JSON-serializable dictionary with the execution result.
-        """
         if tool_name not in self.tools:
             logger.error(f"Attempted to execute non-existent tool: {tool_name}")
             return {"error": f"Tool '{tool_name}' not found."}
-
         tool = self.tools[tool_name]
         try:
             result = await tool.execute(**kwargs)
             return result
         except Exception as e:
             logger.error(f"Error executing tool '{tool_name}' with params {kwargs}: {e}", exc_info=True)
-            return {"error": f"An unexpected error occurred while executing the tool: {str(e)}"}
+            return {"error": f"An unexpected error occurred while executing the tool: {str(e)}"}

neuro_simulator/agent/tools/remove_from_core_memory_block.py

@@ -3,8 +3,8 @@
 
 from typing import Dict, Any, List
 
-from .base import BaseTool
-from ..memory.manager import MemoryManager
+from neuro_simulator.agent.tools.base import BaseTool
+from neuro_simulator.agent.memory.manager import MemoryManager
 
 class RemoveFromCoreMemoryBlockTool(BaseTool):
     """Tool to remove an item from an existing core memory block's content list by its index."""

neuro_simulator/agent/tools/speak.py

@@ -4,8 +4,8 @@
 import logging
 from typing import Dict, Any, List
 
-from .base import BaseTool
-from ..memory.manager import MemoryManager
+from neuro_simulator.agent.tools.base import BaseTool
+from neuro_simulator.agent.memory.manager import MemoryManager
 
 logger = logging.getLogger(__name__.replace("neuro_simulator", "agent", 1))
 

neuro_simulator/agent/tools/update_core_memory_block.py

@@ -3,8 +3,8 @@
 
 from typing import Dict, Any, List, Optional
 
-from .base import BaseTool
-from ..memory.manager import MemoryManager
+from neuro_simulator.agent.tools.base import BaseTool
+from neuro_simulator.agent.memory.manager import MemoryManager
 
 class UpdateCoreMemoryBlockTool(BaseTool):
     """Tool to update an existing core memory block."""

neuro_simulator/api/system.py

@@ -1,10 +1,13 @@
 # neuro_simulator/api/system.py
 """API endpoints for system, config, and utility functions."""
 
-from fastapi import APIRouter, Depends, HTTPException, status, Request
 import time
+from typing import Any, Dict
+
+from fastapi import APIRouter, Depends, HTTPException, status, Request
 
-from ..core.config import config_manager
+from ..core.config import AppSettings, config_manager
+from ..utils.process import process_manager
 
 
 router = APIRouter(tags=["System & Utilities"])

neuro_simulator/cli.py

@@ -8,29 +8,7 @@ import shutil
 import sys
 from pathlib import Path
 
-def copy_resource(package_name: str, resource_path: str, destination_path: Path, is_dir: bool = False):
-    """A helper function to copy a resource from the package to the working directory."""
-    if destination_path.exists():
-        return
 
-    try:
-        import pkg_resources
-        source_path_str = pkg_resources.resource_filename(package_name, resource_path)
-        source_path = Path(source_path_str)
-    except (ModuleNotFoundError, KeyError):
-        source_path = Path(__file__).parent / resource_path
-
-    if source_path.exists():
-        try:
-            if is_dir:
-                shutil.copytree(source_path, destination_path)
-            else:
-                shutil.copy(source_path, destination_path)
-            logging.info(f"Created '{destination_path}' from package resource.")
-        except Exception as e:
-            logging.warning(f"Could not copy resource '{resource_path}'. Error: {e}")
-    else:
-        logging.warning(f"Resource '{resource_path}' not found in package or development folder.")
 
 def main():
     """Main entry point for the CLI."""
@@ -54,39 +32,91 @@ def main():
     os.chdir(work_dir)
     logging.info(f"Using working directory: {work_dir}")
 
-    # 2. Ensure required assets and configs exist
-    copy_resource('neuro_simulator', 'core/config.yaml.example', work_dir / 'config.yaml.example')
-    copy_resource('neuro_simulator', 'assets', work_dir / 'assets', is_dir=True)
-    # Ensure agent directory and its contents exist
-    agent_dir = work_dir / "agent"
-    agent_dir.mkdir(parents=True, exist_ok=True)
-    copy_resource('neuro_simulator', 'agent/neuro_prompt.txt', agent_dir / 'neuro_prompt.txt')
-    copy_resource('neuro_simulator', 'agent/memory_prompt.txt', agent_dir / 'memory_prompt.txt')
-
-    # Ensure agent memory directory and its contents exist
-    agent_memory_dir = agent_dir / "memory"
-    agent_memory_dir.mkdir(parents=True, exist_ok=True)
-    for filename in ["chat_history.json", "core_memory.json", "init_memory.json"]:
-        copy_resource('neuro_simulator', f'agent/memory/{filename}', agent_memory_dir / filename)
-
-    # 3. Validate essential files
-    errors = []
-    if not (work_dir / "config.yaml").exists():
-        errors.append(f"'config.yaml' not found in '{work_dir}'. Please copy 'config.yaml.example' to 'config.yaml' and configure it.")
-    if not (work_dir / "assets" / "neuro_start.mp4").exists():
-        errors.append(f"Required file 'neuro_start.mp4' not found in '{work_dir / 'assets'}'.")
-
-    if errors:
-        for error in errors:
-            logging.error(error)
-        sys.exit(1)
+    # 2. Initialize paths and load configuration
+    from neuro_simulator.core import path_manager
+    from neuro_simulator.core.config import config_manager
+    import uvicorn
+
+    path_manager.initialize_path_manager(os.getcwd())
+
+    # Define example_path early for config loading
+    example_path = Path(__file__).parent / "core" / "config.yaml.example"
+
+    # 2.2. Copy default config.yaml.example if it doesn't exist
+    try:
+        source_config_example = example_path
+        destination_config_example = path_manager.path_manager.working_dir / "config.yaml.example"
+        if not destination_config_example.exists():
+            shutil.copy(source_config_example, destination_config_example)
+            logging.info(f"Copied default config.yaml.example to {destination_config_example}")
+    except Exception as e:
+        logging.warning(f"Could not copy default config.yaml.example: {e}")
+
+    main_config_path = path_manager.path_manager.working_dir / "config.yaml"
+    config_manager.load_and_validate(str(main_config_path), str(example_path))
+
+    # 2.5. Copy default prompt templates if they don't exist
+    try:
+        # Use Path(__file__).parent for robust path resolution
+        base_path = Path(__file__).parent
+        neuro_prompt_example = base_path / "agent" / "neuro_prompt.txt"
+        memory_prompt_example = base_path / "agent" / "memory_prompt.txt"
+
+        if not path_manager.path_manager.neuro_prompt_path.exists():
+            shutil.copy(neuro_prompt_example, path_manager.path_manager.neuro_prompt_path)
+            logging.info(f"Copied default neuro prompt to {path_manager.path_manager.neuro_prompt_path}")
+        if not path_manager.path_manager.memory_agent_prompt_path.exists():
+            shutil.copy(memory_prompt_example, path_manager.path_manager.memory_agent_prompt_path)
+            logging.info(f"Copied default memory prompt to {path_manager.path_manager.memory_agent_prompt_path}")
+
+        # Copy default memory JSON files if they don't exist
+        memory_files = {
+            "core_memory.json": path_manager.path_manager.core_memory_path,
+            "init_memory.json": path_manager.path_manager.init_memory_path,
+            "temp_memory.json": path_manager.path_manager.temp_memory_path,
+        }
+        for filename, dest_path in memory_files.items():
+            src_path = base_path / "agent" / "memory" / filename
+            if not dest_path.exists():
+                shutil.copy(src_path, dest_path)
+                logging.info(f"Copied default {filename} to {dest_path}")
+
+        # Copy default assets directory if it doesn't exist
+        source_assets_dir = base_path / "assets"
+        destination_assets_dir = path_manager.path_manager.assets_dir
+        
+        # Ensure the destination assets directory exists
+        destination_assets_dir.mkdir(parents=True, exist_ok=True)
+
+        # Copy individual files from source assets to destination assets
+        for item in source_assets_dir.iterdir():
+            if item.is_file():
+                dest_file = destination_assets_dir / item.name
+                if not dest_file.exists():
+                    shutil.copy(item, dest_file)
+                    logging.info(f"Copied asset {item.name} to {dest_file}")
+            elif item.is_dir():
+                # Recursively copy subdirectories if they don't exist
+                dest_subdir = destination_assets_dir / item.name
+                if not dest_subdir.exists():
+                    shutil.copytree(item, dest_subdir)
+                    logging.info(f"Copied asset directory {item.name} to {dest_subdir}")
+    except Exception as e:
+        logging.warning(f"Could not copy default prompt templates, memory files, or assets: {e}")
+
+    # 3. Determine server host and port
+    server_host = args.host or config_manager.settings.server.host
+    server_port = args.port or config_manager.settings.server.port
 
-    # 4. Import and run the server
+    # 4. Run the server
+    logging.info(f"Starting Neuro-Simulator server on {server_host}:{server_port}...")
     try:
-        from neuro_simulator.core.application import run_server
-        logging.info("Starting Neuro-Simulator server...")
-        # The full application logger will take over from here
-        run_server(args.host, args.port)
+        uvicorn.run(
+            "neuro_simulator.core.application:app",
+            host=server_host,
+            port=server_port,
+            reload=False
+        )
     except ImportError as e:
         logging.error(f"Could not import the application. Make sure the package is installed correctly. Details: {e}", exc_info=True)
         sys.exit(1)

neuro_simulator/core/agent_factory.py

@@ -1,6 +1,5 @@
 # neuro_simulator/core/agent_factory.py
 import logging
-from pathlib import Path
 
 from .agent_interface import BaseAgent
 from .config import config_manager, AppSettings

neuro_simulator/core/application.py

@@ -7,7 +7,7 @@ import logging
 import random
 import re
 import time
-from pathlib import Path
+import os
 from typing import List
 
 from fastapi import FastAPI, WebSocket, WebSocketDisconnect
@@ -17,6 +17,7 @@ from starlette.websockets import WebSocketState
 # --- Core Imports ---
 from .config import config_manager, AppSettings
 from ..core.agent_factory import create_agent
+from ..agent.core import Agent as LocalAgent
 from ..services.letta import LettaAgent
 from ..services.builtin import BuiltinAgentWrapper
 
@@ -34,7 +35,8 @@ from ..utils.queue import (
     add_to_neuro_input_queue,
     get_recent_audience_chats,
     is_neuro_input_queue_empty,
-    get_all_neuro_input_chats
+    get_all_neuro_input_chats,
+    initialize_queues,
 )
 from ..utils.state import app_state
 from ..utils.websocket import connection_manager
@@ -169,6 +171,10 @@ async def neuro_response_cycle():
             if not response_text:
                 continue
 
+            # Push updated agent context to admin clients immediately after processing
+            updated_context = await agent.get_message_history()
+            await connection_manager.broadcast_to_admins({"type": "agent_context", "action": "update", "messages": updated_context})
+
             async with app_state.neuro_last_speech_lock:
                 app_state.neuro_last_speech = response_text
 
@@ -192,6 +198,7 @@ async def neuro_response_cycle():
             
             await connection_manager.broadcast({"type": "neuro_speech_segment", "is_end": True})
             live_stream_manager.set_neuro_speaking_status(False)
+            
             await asyncio.sleep(config_manager.settings.neuro_behavior.post_speech_cooldown_sec)
 
         except asyncio.TimeoutError:
@@ -210,17 +217,24 @@ async def neuro_response_cycle():
 @app.on_event("startup")
 async def startup_event():
     """Actions to perform on application startup."""
-    global chatbot_manager
+    # 1. Configure logging first
     configure_server_logging()
-    
+
+    # 2. Initialize queues now that config is loaded
+    initialize_queues()
+
+    # 4. Initialize other managers/services that depend on config
+    global chatbot_manager
     chatbot_manager = AudienceChatbotManager()
 
+    # 5. Register callbacks
     async def metadata_callback(settings: AppSettings):
         await live_stream_manager.broadcast_stream_metadata()
     
     config_manager.register_update_callback(metadata_callback)
     config_manager.register_update_callback(chatbot_manager.handle_config_update)
     
+    # 6. Initialize agent (which will load its own configs)
     try:
         await create_agent()
         logger.info(f"Successfully initialized agent type: {config_manager.settings.agent_type}")
@@ -410,6 +424,8 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
 
         # Stream Control Actions
         elif action == "start_stream":
+            logger.info("Start stream action received. Resetting agent memory before starting processes...")
+            await agent.reset_memory()
             if not process_manager.is_running:
                 process_manager.start_live_processes()
             response["payload"] = {"status": "success", "message": "Stream started"}
@@ -464,22 +480,33 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
             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."}
+            # This is specific to the builtin agent, as Letta doesn't expose its prompt.
+            agent_instance = getattr(agent, 'agent_instance', agent)
+            if not isinstance(agent_instance, LocalAgent):
+                 response["payload"] = {"prompt": "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}
+                try:
+                    # 1. Get the recent history from the agent itself
+                    history = await agent_instance.get_neuro_history(limit=10)
+                    
+                    # 2. Reconstruct the 'messages' list that _build_neuro_prompt expects
+                    messages_for_prompt = []
+                    for entry in history:
+                        if entry.get('role') == 'user':
+                            # Content is in the format "username: text"
+                            content = entry.get('content', '')
+                            parts = content.split(':', 1)
+                            if len(parts) == 2:
+                                messages_for_prompt.append({'username': parts[0].strip(), 'text': parts[1].strip()})
+                            elif content: # Handle cases where there's no colon
+                                messages_for_prompt.append({'username': 'user', 'text': content})
+
+                    # 3. Build the prompt using the agent's own internal logic
+                    prompt = await agent_instance._build_neuro_prompt(messages_for_prompt)
+                    response["payload"] = {"prompt": prompt}
+                except Exception as e:
+                    logger.error(f"Error generating last prompt: {e}", exc_info=True)
+                    response["payload"] = {"prompt": f"Failed to generate prompt: {e}"}
 
         elif action == "reset_agent_memory":
             await agent.reset_memory()
@@ -504,17 +531,4 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
             await websocket.send_json(response)
 
 
-# --- Server Entrypoint ---
 
-def run_server(host: str = None, port: int = None):
-    """Runs the FastAPI server with Uvicorn."""
-    import uvicorn
-    server_host = host or config_manager.settings.server.host
-    server_port = port or config_manager.settings.server.port
-    
-    uvicorn.run(
-        "neuro_simulator.core.application:app",
-        host=server_host,
-        port=server_port,
-        reload=False
-    )