neuro-simulator 0.3.3__tar.gz → 0.4.0__tar.gz

{neuro_simulator-0.3.3 → neuro_simulator-0.4.0}/PKG-INFO

@@ -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/neuro_simulator/agent/core.py

@@ -0,0 +1,201 @@
+# neuro_simulator/agent/core.py
+"""
+Core module for the Neuro Simulator's built-in agent.
+Implements a dual-LLM "Actor/Thinker" architecture for responsive interaction
+and asynchronous memory consolidation.
+"""
+
+import asyncio
+import json
+import logging
+import re
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List
+
+from ..core.path_manager import path_manager
+from .llm import LLMClient
+from .memory.manager import MemoryManager
+from .tools.manager import ToolManager
+
+logger = logging.getLogger("neuro_agent")
+
+class Agent:
+    """
+    Main Agent class implementing the Actor/Thinker model.
+    - The "Neuro" part (Actor) handles real-time interaction.
+    - The "Memory" part (Thinker) handles background memory consolidation.
+    """
+    
+    def __init__(self):
+        if not path_manager:
+            raise RuntimeError("PathManager must be initialized before the Agent.")
+        
+        self.memory_manager = MemoryManager()
+        self.tool_manager = ToolManager(self.memory_manager)
+        
+        self.neuro_llm = LLMClient()
+        self.memory_llm = LLMClient()
+        
+        self._initialized = False
+        self.turn_counter = 0
+        self.reflection_threshold = 3
+        
+        logger.info("Agent instance created with dual-LLM architecture.")
+
+    async def initialize(self):
+        """Initialize the agent, loading any persistent memory."""
+        if not self._initialized:
+            logger.info("Initializing agent memory manager...")
+            await self.memory_manager.initialize()
+            self._initialized = True
+            logger.info("Agent initialized successfully.")
+        
+    async def reset_all_memory(self):
+        """Reset all agent memory types and clear history logs."""
+        await self.memory_manager.reset_temp_memory()
+        # Clear history files by overwriting them
+        open(path_manager.neuro_history_path, 'w').close()
+        open(path_manager.memory_agent_history_path, 'w').close()
+        logger.info("All agent memory and history logs have been reset.")
+
+    async def get_neuro_history(self, limit: int = 20) -> List[Dict[str, Any]]:
+        """Reads the last N lines from the Neuro agent's history log."""
+        return await self._read_history_log(path_manager.neuro_history_path, limit)
+
+    async def _append_to_history_log(self, file_path: Path, data: Dict[str, Any]):
+        """Appends a new entry to a JSON Lines history file."""
+        data['timestamp'] = datetime.now().isoformat()
+        with open(file_path, 'a', encoding='utf-8') as f:
+            f.write(json.dumps(data, ensure_ascii=False) + '\n')
+
+    async def _read_history_log(self, file_path: Path, limit: int) -> List[Dict[str, Any]]:
+        """Reads the last N lines from a JSON Lines history file."""
+        if not file_path.exists():
+            return []
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                lines = f.readlines()
+            # Get the last N lines and parse them
+            return [json.loads(line) for line in lines[-limit:]]
+        except (json.JSONDecodeError, IndexError) as e:
+            logger.error(f"Could not read or parse history from {file_path}: {e}")
+            return []
+
+    def _format_tool_schemas_for_prompt(self, schemas: List[Dict[str, Any]]) -> str:
+        """Formats a list of tool schemas into a string for the LLM prompt."""
+        if not schemas:
+            return "No tools available."
+        lines = ["Available tools:"]
+        for i, schema in enumerate(schemas):
+            params_str_parts = []
+            for param in schema.get("parameters", []):
+                p_name = param.get('name')
+                p_type = param.get('type')
+                p_req = 'required' if param.get('required') else 'optional'
+                params_str_parts.append(f"{p_name}: {p_type} ({p_req})")
+            params_str = ", ".join(params_str_parts)
+            lines.append(f"{i+1}. {schema.get('name')}({params_str}) - {schema.get('description')}")
+        return "\n".join(lines)
+
+    async def _build_neuro_prompt(self, messages: List[Dict[str, str]]) -> str:
+        """Builds the prompt for the Neuro (Actor) LLM."""
+        prompt_template = "" # Define a default empty prompt
+        if path_manager.neuro_prompt_path.exists():
+            with open(path_manager.neuro_prompt_path, 'r', encoding='utf-8') as f:
+                prompt_template = f.read()
+        else:
+            logger.warning(f"Neuro prompt template not found at {path_manager.neuro_prompt_path}")
+
+        tool_schemas = self.tool_manager.get_tool_schemas_for_agent('neuro_agent')
+        tool_descriptions = self._format_tool_schemas_for_prompt(tool_schemas)
+        
+        init_memory_text = "\n".join(f"{key}: {value}" for key, value in self.memory_manager.init_memory.items())
+        
+        core_memory_blocks = await self.memory_manager.get_core_memory_blocks()
+        core_memory_parts = [f"\nBlock: {b.get('title', '')} ({b_id})\nDescription: {b.get('description', '')}\nContent:\n" + "\n".join([f"  - {item}" for item in b.get("content", [])]) for b_id, b in core_memory_blocks.items()]
+        core_memory_text = "\n".join(core_memory_parts) if core_memory_parts else "Not set."
+
+        temp_memory_text = "\n".join([f"[{item.get('role', 'system')}] {item.get('content', '')}" for item in self.memory_manager.temp_memory]) if self.memory_manager.temp_memory else "Empty."
+
+        recent_history = await self._read_history_log(path_manager.neuro_history_path, limit=10)
+        recent_history_text = "\n".join([f"{msg.get('role', 'unknown')}: {msg.get('content', '')}" for msg in recent_history])
+        user_messages_text = "\n".join([f"{msg['username']}: {msg['text']}" for msg in messages])
+
+        return prompt_template.format(
+            tool_descriptions=tool_descriptions,
+            init_memory=init_memory_text,
+            core_memory=core_memory_text,
+            temp_memory=temp_memory_text,
+            recent_history=recent_history_text,
+            user_messages=user_messages_text
+        )
+
+    async def _build_memory_prompt(self, conversation_history: List[Dict[str, str]]) -> str:
+        """Builds the prompt for the Memory (Thinker) LLM."""
+        prompt_template = "" # Define a default empty prompt
+        if path_manager.memory_agent_prompt_path.exists():
+            with open(path_manager.memory_agent_prompt_path, 'r', encoding='utf-8') as f:
+                prompt_template = f.read()
+        else:
+            logger.warning(f"Memory prompt template not found at {path_manager.memory_agent_prompt_path}")
+
+        tool_schemas = self.tool_manager.get_tool_schemas_for_agent('memory_agent')
+        tool_descriptions = self._format_tool_schemas_for_prompt(tool_schemas)
+        history_text = "\n".join([f"{msg.get('role', 'unknown')}: {msg.get('content', '')}" for msg in conversation_history])
+        
+        return prompt_template.format(
+            tool_descriptions=tool_descriptions,
+            conversation_history=history_text
+        )
+
+    def _parse_tool_calls(self, response_text: str) -> List[Dict[str, Any]]:
+        try:
+            match = re.search(r'''```json\s*([\s\S]*?)\s*```|(\[[\s\S]*\])''', response_text)
+            if not match:
+                logger.warning(f"No valid JSON tool call block found in response: {response_text}")
+                return []
+            json_str = match.group(1) or match.group(2)
+            return json.loads(json_str)
+        except Exception as e:
+            logger.error(f"Failed to parse tool calls from LLM response: {e}")
+            return []
+
+    async def _execute_tool_calls(self, tool_calls: List[Dict[str, Any]]) -> Dict[str, Any]:
+        execution_results = []
+        final_response = ""
+        for tool_call in tool_calls:
+            tool_name = tool_call.get("name")
+            params = tool_call.get("params", {})
+            if not tool_name:
+                continue
+            logger.info(f"Executing tool: {tool_name} with params: {params}")
+            try:
+                result = await self.tool_manager.execute_tool(tool_name, **params)
+                execution_results.append({"name": tool_name, "params": params, "result": result})
+                if tool_name == "speak" and result.get("status") == "success":
+                    final_response = result.get("spoken_text", "")
+            except Exception as e:
+                logger.error(f"Error executing tool {tool_name}: {e}")
+                execution_results.append({"name": tool_name, "params": params, "error": str(e)})
+        return {"tool_executions": execution_results, "final_response": final_response}
+
+    async def process_and_respond(self, messages: List[Dict[str, str]]) -> Dict[str, Any]:
+        await self.initialize()
+        logger.info(f"Processing {len(messages)} messages in Actor flow.")
+
+        for msg in messages:
+            await self._append_to_history_log(path_manager.neuro_history_path, {'role': 'user', 'content': f"{msg['username']}: {msg['text']}"})
+
+        prompt = await self._build_neuro_prompt(messages)
+        response_text = await self.neuro_llm.generate(prompt)
+        
+        tool_calls = self._parse_tool_calls(response_text)
+        processing_result = await self._execute_tool_calls(tool_calls)
+
+        if final_response := processing_result.get("final_response", ""):
+            await self._append_to_history_log(path_manager.neuro_history_path, {'role': 'assistant', 'content': final_response})
+
+        return processing_result
+
+    

{neuro_simulator-0.3.3 → neuro_simulator-0.4.0}/neuro_simulator/agent/llm.py

@@ -6,7 +6,7 @@ LLM client for the Neuro Simulator's built-in agent.
 import asyncio
 import logging
 from pathlib import Path
-from typing import Optional
+from typing import Any, Dict
 
 from google import genai
 from google.genai import types

neuro_simulator-0.4.0/neuro_simulator/agent/memory/manager.py

@@ -0,0 +1,125 @@
+# neuro_simulator/agent/memory/manager.py
+"""
+Manages the agent's shared memory state (init, core, temp).
+"""
+
+import json
+import logging
+import random
+import string
+from typing import Any, Dict, List, Optional
+from datetime import datetime
+
+from ...core.path_manager import path_manager
+
+logger = logging.getLogger(__name__.replace("neuro_simulator", "agent", 1))
+
+def generate_id(length=6) -> str:
+    """Generate a random ID string."""
+    return ''.join(random.choices(string.ascii_letters + string.digits, k=length))
+
+class MemoryManager:
+    """Manages the three types of shared memory for the agent."""
+    
+    def __init__(self):
+        """Initializes the MemoryManager using paths from the global path_manager."""
+        if not path_manager:
+            raise RuntimeError("PathManager not initialized before MemoryManager.")
+
+        self.init_memory_file = path_manager.init_memory_path
+        self.core_memory_file = path_manager.core_memory_path
+        self.temp_memory_file = path_manager.temp_memory_path
+        
+        self.init_memory: Dict[str, Any] = {}
+        self.core_memory: Dict[str, Any] = {}
+        self.temp_memory: List[Dict[str, Any]] = []
+        
+    async def initialize(self):
+        """Load all memory types from files, creating defaults if they don't exist."""
+        # Load or create init memory
+        if self.init_memory_file.exists():
+            with open(self.init_memory_file, 'r', encoding='utf-8') as f:
+                self.init_memory = json.load(f)
+        else:
+            self.init_memory = {
+                "name": "Neuro-Sama", "role": "AI VTuber",
+                "personality": "Friendly, curious, and entertaining",
+                "capabilities": ["Chat with viewers", "Answer questions"]
+            }
+            await self._save_init_memory()
+            
+        # Load or create core memory
+        if self.core_memory_file.exists():
+            with open(self.core_memory_file, 'r', encoding='utf-8') as f:
+                self.core_memory = json.load(f)
+        else:
+            self.core_memory = {"blocks": {}}
+            await self._save_core_memory()
+            
+        # Load or create temp memory
+        if self.temp_memory_file.exists():
+            with open(self.temp_memory_file, 'r', encoding='utf-8') as f:
+                self.temp_memory = json.load(f)
+        else:
+            self.temp_memory = []
+            await self._save_temp_memory()
+                
+        logger.info("MemoryManager initialized and memory files loaded/created.")
+        
+    async def _save_init_memory(self):
+        with open(self.init_memory_file, 'w', encoding='utf-8') as f:
+            json.dump(self.init_memory, f, ensure_ascii=False, indent=2)
+            
+    async def update_init_memory(self, new_memory: Dict[str, Any]):
+        self.init_memory.update(new_memory)
+        await self._save_init_memory()
+            
+    async def _save_core_memory(self):
+        with open(self.core_memory_file, 'w', encoding='utf-8') as f:
+            json.dump(self.core_memory, f, ensure_ascii=False, indent=2)
+            
+    async def _save_temp_memory(self):
+        with open(self.temp_memory_file, 'w', encoding='utf-8') as f:
+            json.dump(self.temp_memory, f, ensure_ascii=False, indent=2)
+            
+    async def reset_temp_memory(self):
+        """Reset temp memory to a default empty state."""
+        self.temp_memory = []
+        await self._save_temp_memory()
+        logger.info("Agent temp memory has been reset.")
+        
+    async def add_temp_memory(self, content: str, role: str = "system"):
+        self.temp_memory.append({"id": generate_id(), "content": content, "role": role, "timestamp": datetime.now().isoformat()})
+        if len(self.temp_memory) > 20:
+            self.temp_memory = self.temp_memory[-20:]
+        await self._save_temp_memory()
+        
+    async def get_core_memory_blocks(self) -> Dict[str, Any]:
+        return self.core_memory.get("blocks", {})
+        
+    async def get_core_memory_block(self, block_id: str) -> Optional[Dict[str, Any]]:
+        return self.core_memory.get("blocks", {}).get(block_id)
+        
+    async def create_core_memory_block(self, title: str, description: str, content: List[str]) -> str:
+        block_id = generate_id()
+        if "blocks" not in self.core_memory:
+            self.core_memory["blocks"] = {}
+        self.core_memory["blocks"][block_id] = {
+            "id": block_id, "title": title, "description": description, "content": content or []
+        }
+        await self._save_core_memory()
+        return block_id
+        
+    async def update_core_memory_block(self, block_id: str, title: Optional[str] = None, description: Optional[str] = None, content: Optional[List[str]] = None):
+        block = self.core_memory.get("blocks", {}).get(block_id)
+        if not block:
+            raise ValueError(f"Block '{block_id}' not found")
+        if title is not None: block["title"] = title
+        if description is not None: block["description"] = description
+        if content is not None: block["content"] = content
+        await self._save_core_memory()
+        
+    async def delete_core_memory_block(self, block_id: str):
+        if "blocks" in self.core_memory and block_id in self.core_memory["blocks"]:
+            del self.core_memory["blocks"][block_id]
+            await self._save_core_memory()

{neuro_simulator-0.3.3 → neuro_simulator-0.4.0}/neuro_simulator/agent/tools/add_temp_memory.py

@@ -1,10 +1,10 @@
 # neuro_simulator/agent/tools/add_temp_memory.py
 """The Add Temp Memory tool for the agent."""
 
-from typing import Dict, Any, List
+from typing import Any, Dict, 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 AddTempMemoryTool(BaseTool):
     """Tool to add an entry to the agent's temporary memory."""

{neuro_simulator-0.3.3 → neuro_simulator-0.4.0}/neuro_simulator/agent/tools/add_to_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 AddToCoreMemoryBlockTool(BaseTool):
     """Tool to add an item to an existing core memory block's content list."""

{neuro_simulator-0.3.3 → neuro_simulator-0.4.0}/neuro_simulator/agent/tools/create_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 CreateCoreMemoryBlockTool(BaseTool):
     """Tool to create a new core memory block."""

{neuro_simulator-0.3.3 → neuro_simulator-0.4.0}/neuro_simulator/agent/tools/delete_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 DeleteCoreMemoryBlockTool(BaseTool):
     """Tool to delete an existing core memory block."""

{neuro_simulator-0.3.3 → neuro_simulator-0.4.0}/neuro_simulator/agent/tools/get_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 GetCoreMemoryBlockTool(BaseTool):
     """Tool to retrieve a single core memory block by its ID."""

{neuro_simulator-0.3.3 → neuro_simulator-0.4.0}/neuro_simulator/agent/tools/get_core_memory_blocks.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 GetCoreMemoryBlocksTool(BaseTool):
     """Tool to retrieve all core memory blocks."""

neuro_simulator-0.4.0/neuro_simulator/agent/tools/manager.py

@@ -0,0 +1,143 @@
+# neuro_simulator/agent/tools/manager.py
+"""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 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 user's working directory.
+    """
+
+    def __init__(self, memory_manager: MemoryManager):
+        if not path_manager:
+            raise RuntimeError("PathManager not initialized before ToolManager.")
+        self.memory_manager = memory_manager
+        self.tools: Dict[str, BaseTool] = {}
+        self.agent_tool_allocations: Dict[str, List[str]] = {}
+
+        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 user tools directory, imports modules, and registers tool instances."""
+        self.tools = {}
+        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]]:
+        return [tool.get_schema() for tool in self.tools.values()]
+
+    def get_tool_schemas_for_agent(self, agent_name: str) -> List[Dict[str, Any]]:
+        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):
+        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]]:
+        return self.agent_tool_allocations
+
+    def set_allocations(self, allocations: Dict[str, List[str]]):
+        self.agent_tool_allocations = 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]:
+        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)}"}

{neuro_simulator-0.3.3 → neuro_simulator-0.4.0}/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-0.3.3 → neuro_simulator-0.4.0}/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-0.3.3 → neuro_simulator-0.4.0}/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-0.3.3 → neuro_simulator-0.4.0}/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"])