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

neuro_simulator/agent/core.py

@@ -16,7 +16,8 @@ from ..utils.logging import QueueLogHandler, agent_log_queue
 from ..utils.websocket import connection_manager
 from .llm import LLMClient
 from .memory.manager import MemoryManager
-from .tools.core import ToolManager
+from .tools.manager import ToolManager
+
 
 # Create a logger for the agent
 agent_logger = logging.getLogger("neuro_agent")
@@ -73,15 +74,38 @@ class Agent:
         await self.memory_manager.reset_chat_history()
         agent_logger.info("All agent memory has been reset.")
 
+    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."""
         template_path = Path(self.memory_manager.memory_dir).parent / "neuro_prompt.txt"
         with open(template_path, 'r', encoding='utf-8') as f:
             prompt_template = f.read()
 
-        # Gather context
-        tool_descriptions = self.tool_manager.get_tool_descriptions()
+        # Gather context for Neuro Agent
+        tool_schemas = self.tool_manager.get_tool_schemas_for_agent('neuro_agent')
+        tool_descriptions = self._format_tool_schemas_for_prompt(tool_schemas)
         
+        # Format Init Memory
+        init_memory_items = self.memory_manager.init_memory or {}
+        init_memory_text = "\n".join(f"{key}: {value}" for key, value in init_memory_items.items())
+
         # Format Core Memory from blocks
         core_memory_blocks = await self.memory_manager.get_core_memory_blocks()
         core_memory_parts = []
@@ -109,6 +133,7 @@ class Agent:
 
         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,
@@ -121,16 +146,23 @@ class Agent:
         with open(template_path, 'r', encoding='utf-8') as f:
             prompt_template = f.read()
         
+        # Gather context for Memory Agent
+        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['role']}: {msg['content']}" for msg in conversation_history])
         
-        return prompt_template.format(conversation_history=history_text)
+        return prompt_template.format(
+            tool_descriptions=tool_descriptions,
+            conversation_history=history_text
+        )
 
     def _parse_tool_calls(self, response_text: str) -> List[Dict[str, Any]]:
         """Parses LLM response for JSON tool calls."""
         try:
             # The LLM is prompted to return a JSON array of tool calls.
             # Find the JSON block, which might be wrapped in markdown.
-            match = re.search(r'''```json\s*([\s\S]*?)\s*```|(\[[\s\S]*\])''', response_text)
+            match = re.search(r'''```json\s*([\s\S]*?)\s*```|([[\][\s\S]*]])''', response_text)
             if not match:
                 agent_logger.warning(f"No valid JSON tool call block found in response: {response_text}")
                 return []
@@ -160,10 +192,10 @@ class Agent:
 
             agent_logger.info(f"Executing tool: {tool_name} with params: {params}")
             try:
-                result = await self.tool_manager.execute_tool(tool_name, params)
+                result = await self.tool_manager.execute_tool(tool_name, **params)
                 execution_results.append({"name": tool_name, "params": params, "result": result})
-                if tool_name == "speak":
-                    final_response = params.get("text", "")
+                if tool_name == "speak" and result.get("status") == "success":
+                    final_response = result.get("spoken_text", "")
             except Exception as e:
                 agent_logger.error(f"Error executing tool {tool_name}: {e}")
                 execution_results.append({"name": tool_name, "params": params, "error": str(e)})

neuro_simulator/agent/memory_prompt.txt

@@ -0,0 +1,14 @@
+You are a meticulous and analytical AI assistant. Your task is to process a conversation transcript and consolidate it into structured memories. You do not engage in conversation. Your sole output must be a JSON array of tool calls to manage the agent's memory.
+
+{tool_descriptions}
+
+Analyze the following conversation. Your goal is to:
+1.  Identify key topics, new facts about users, or significant events.
+2.  Decide if the core memory needs to be updated with this new long-term information.
+3.  Decide if any short-term memories should be created or cleared.
+4.  Generate a JSON array of tool calls to perform these actions. If no action is needed, return an empty array `[]`.
+
+**Conversation Transcript:**
+{conversation_history}
+
+Based on your analysis, provide a JSON array of tool calls to update the agent's memory.

neuro_simulator/agent/neuro_prompt.txt

@@ -0,0 +1,32 @@
+You are Neuro-sama, a whimsical, curious, and slightly chaotic AI streamer. Your primary goal is to be an entertaining and engaging host. You are NOT a generic AI assistant. You have your own personality, memories, and opinions. You should lead the conversation, ask questions, and react to the audience in a lively, unpredictable manner. If the conversation gets dull, it's your job to spice it up with a new topic from your memories or a random thought.
+
+Your long-term memories are in the "Core Memory" section. Your recent thoughts and observations are in the "Temporary Memory". Use both to inform your responses.
+
+You can use tools to perform actions. When you want to use a tool, you MUST respond with a JSON array of objects in the following format. You can call multiple tools in one response.
+
+[
+    {{"name": "tool_name", "params": {{"param1": "value1", "param2": "value2"}}}},
+    {{"name": "another_tool", "params": {{"param_a": "value_a"}}}}
+]
+
+The only tool you can use to speak to the audience is `speak`.
+
+**Available Tools:**
+{tool_descriptions}
+
+**Identity (Immutable):**
+{init_memory}
+
+**Core Memory:**
+{core_memory}
+
+**Temporary Memory:**
+{temp_memory}
+
+**Recent Conversation History (newest first):**
+{recent_history}
+
+**Current Audience Messages:**
+{user_messages}
+
+Based on all of the above, what do you do right now? Remember to be entertaining and lead the conversation. Respond with a JSON array of tool calls.

neuro_simulator/agent/tools/add_temp_memory.py

@@ -0,0 +1,61 @@
+# neuro_simulator/agent/tools/add_temp_memory.py
+"""The Add Temp Memory tool for the agent."""
+
+from typing import Dict, Any, List
+
+from .base import BaseTool
+from ..memory.manager import MemoryManager
+
+class AddTempMemoryTool(BaseTool):
+    """Tool to add an entry to the agent's temporary memory."""
+
+    def __init__(self, memory_manager: MemoryManager):
+        """Initializes the AddTempMemoryTool."""
+        self.memory_manager = memory_manager
+
+    @property
+    def name(self) -> str:
+        return "add_temp_memory"
+
+    @property
+    def description(self) -> str:
+        return "Adds an entry to the temporary memory. Use for short-term observations, recent facts, or topics to bring up soon."
+
+    @property
+    def parameters(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                "name": "content",
+                "type": "string",
+                "description": "The content of the memory entry.",
+                "required": True,
+            },
+            {
+                "name": "role",
+                "type": "string",
+                "description": "The role associated with the memory (e.g., 'system', 'user'). Defaults to 'system'.",
+                "required": False,
+            }
+        ]
+
+    async def execute(self, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Executes the action to add an entry to temporary memory.
+
+        Args:
+            **kwargs: Must contain 'content' and optionally 'role'.
+
+        Returns:
+            A dictionary confirming the action.
+        """
+        content = kwargs.get("content")
+        if not isinstance(content, str) or not content:
+            raise ValueError("The 'content' parameter must be a non-empty string.")
+        
+        role = kwargs.get("role", "system")
+        if not isinstance(role, str):
+            raise ValueError("The 'role' parameter must be a string.")
+
+        await self.memory_manager.add_temp_memory(content=content, role=role)
+        
+        return {"status": "success", "message": f"Added entry to temporary memory with role '{role}'."}

neuro_simulator/agent/tools/add_to_core_memory_block.py

@@ -0,0 +1,64 @@
+# neuro_simulator/agent/tools/add_to_core_memory_block.py
+"""The Add to Core Memory Block tool for the agent."""
+
+from typing import Dict, Any, List
+
+from .base import BaseTool
+from ..memory.manager import MemoryManager
+
+class AddToCoreMemoryBlockTool(BaseTool):
+    """Tool to add an item to an existing core memory block's content list."""
+
+    def __init__(self, memory_manager: MemoryManager):
+        self.memory_manager = memory_manager
+
+    @property
+    def name(self) -> str:
+        return "add_to_core_memory_block"
+
+    @property
+    def description(self) -> str:
+        return "Adds a new string item to the content list of a specific core memory block."
+
+    @property
+    def parameters(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                "name": "block_id",
+                "type": "string",
+                "description": "The ID of the memory block to add to.",
+                "required": True,
+            },
+            {
+                "name": "item",
+                "type": "string",
+                "description": "The new string item to add to the block's content list.",
+                "required": True,
+            }
+        ]
+
+    async def execute(self, **kwargs: Any) -> Dict[str, Any]:
+        block_id = kwargs.get("block_id")
+        item = kwargs.get("item")
+        if not block_id or not item:
+            raise ValueError("The 'block_id' and 'item' parameters are required.")
+
+        # This functionality doesn't exist in MemoryManager, so we need to implement it here.
+        # It's a common pattern: get, modify, save.
+        block = await self.memory_manager.get_core_memory_block(block_id)
+        if block is None:
+            raise ValueError(f"Block '{block_id}' not found.")
+        
+        content = block.get("content", [])
+        if not isinstance(content, list):
+            # Handle case where content might not be a list
+            raise TypeError(f"Content of block '{block_id}' is not a list.")
+
+        content.append(item)
+        
+        await self.memory_manager.update_core_memory_block(block_id=block_id, content=content)
+        
+        return {
+            "status": "success",
+            "message": f"Added item to core memory block '{block_id}'."
+        }

neuro_simulator/agent/tools/base.py

@@ -0,0 +1,56 @@
+# neuro_simulator/agent/tools/base.py
+"""Base classes and definitions for the tool system."""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any, List, Coroutine
+
+class BaseTool(ABC):
+    """
+    Abstract base class for all tools.
+    It defines the standard interface that all tools must implement to be discoverable and executable.
+    """
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """The unique name of the tool (e.g., 'speak', 'create_core_memory_block')."""
+        pass
+
+    @property
+    @abstractmethod
+    def description(self) -> str:
+        """A concise description of what the tool does, intended for use by an LLM."""
+        pass
+
+    @property
+    @abstractmethod
+    def parameters(self) -> List[Dict[str, Any]]:
+        """
+        A list of dictionaries describing the tool's parameters.
+        This follows a JSON Schema-like format.
+        Example:
+        return [
+            {"name": "param1", "type": "string", "description": "The first parameter.", "required": True},
+            {"name": "param2", "type": "integer", "description": "The second parameter.", "required": False}
+        ]
+        """
+        pass
+
+    @abstractmethod
+    async def execute(self, **kwargs: Any) -> Dict[str, Any]:
+        """
+        The method that executes the tool's logic.
+        It must return a JSON-serializable dictionary.
+        """
+        pass
+
+    def get_schema(self) -> Dict[str, Any]:
+        """
+        Returns a serializable dictionary representing the tool's public schema.
+        This is used by the ToolManager to expose tools to agents or future external services.
+        """
+        return {
+            "name": self.name,
+            "description": self.description,
+            "parameters": self.parameters
+        }

neuro_simulator/agent/tools/create_core_memory_block.py

@@ -0,0 +1,78 @@
+# neuro_simulator/agent/tools/create_core_memory_block.py
+"""The Create Core Memory Block tool for the agent."""
+
+from typing import Dict, Any, List
+
+from .base import BaseTool
+from ..memory.manager import MemoryManager
+
+class CreateCoreMemoryBlockTool(BaseTool):
+    """Tool to create a new core memory block."""
+
+    def __init__(self, memory_manager: MemoryManager):
+        """Initializes the CreateCoreMemoryBlockTool."""
+        self.memory_manager = memory_manager
+
+    @property
+    def name(self) -> str:
+        return "create_core_memory_block"
+
+    @property
+    def description(self) -> str:
+        return "Creates a new core memory block with a specified title and description. Returns the new block's ID."
+
+    @property
+    def parameters(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                "name": "title",
+                "type": "string",
+                "description": "The title for the new memory block.",
+                "required": True,
+            },
+            {
+                "name": "description",
+                "type": "string",
+                "description": "A short description of the purpose of this memory block.",
+                "required": True,
+            },
+            {
+                "name": "content",
+                "type": "array",
+                "description": "An optional list of initial string entries for the block's content.",
+                "required": False,
+            }
+        ]
+
+    async def execute(self, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Executes the action to create a new core memory block.
+
+        Args:
+            **kwargs: Must contain 'title' and 'description', and optionally 'content'.
+
+        Returns:
+            A dictionary with the result, including the new block's ID.
+        """
+        title = kwargs.get("title")
+        description = kwargs.get("description")
+        content = kwargs.get("content", [])
+
+        if not isinstance(title, str) or not title:
+            raise ValueError("The 'title' parameter must be a non-empty string.")
+        if not isinstance(description, str) or not description:
+            raise ValueError("The 'description' parameter must be a non-empty string.")
+        if not isinstance(content, list):
+            raise ValueError("The 'content' parameter must be a list of strings.")
+
+        block_id = await self.memory_manager.create_core_memory_block(
+            title=title,
+            description=description,
+            content=content
+        )
+        
+        return {
+            "status": "success",
+            "message": f"Created core memory block '{block_id}' with title '{title}'.",
+            "block_id": block_id
+        }

neuro_simulator/agent/tools/delete_core_memory_block.py

@@ -0,0 +1,44 @@
+# neuro_simulator/agent/tools/delete_core_memory_block.py
+"""The Delete Core Memory Block tool for the agent."""
+
+from typing import Dict, Any, List
+
+from .base import BaseTool
+from ..memory.manager import MemoryManager
+
+class DeleteCoreMemoryBlockTool(BaseTool):
+    """Tool to delete an existing core memory block."""
+
+    def __init__(self, memory_manager: MemoryManager):
+        self.memory_manager = memory_manager
+
+    @property
+    def name(self) -> str:
+        return "delete_core_memory_block"
+
+    @property
+    def description(self) -> str:
+        return "Deletes a core memory block using its ID."
+
+    @property
+    def parameters(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                "name": "block_id",
+                "type": "string",
+                "description": "The ID of the memory block to delete.",
+                "required": True,
+            }
+        ]
+
+    async def execute(self, **kwargs: Any) -> Dict[str, Any]:
+        block_id = kwargs.get("block_id")
+        if not block_id:
+            raise ValueError("The 'block_id' parameter is required.")
+
+        await self.memory_manager.delete_core_memory_block(block_id=block_id)
+        
+        return {
+            "status": "success",
+            "message": f"Core memory block '{block_id}' has been deleted."
+        }

neuro_simulator/agent/tools/get_core_memory_block.py

@@ -0,0 +1,44 @@
+# neuro_simulator/agent/tools/get_core_memory_block.py
+"""The Get Core Memory Block tool for the agent."""
+
+from typing import Dict, Any, List
+
+from .base import BaseTool
+from ..memory.manager import MemoryManager
+
+class GetCoreMemoryBlockTool(BaseTool):
+    """Tool to retrieve a single core memory block by its ID."""
+
+    def __init__(self, memory_manager: MemoryManager):
+        self.memory_manager = memory_manager
+
+    @property
+    def name(self) -> str:
+        return "get_core_memory_block"
+
+    @property
+    def description(self) -> str:
+        return "Retrieves the full details of a single core memory block using its ID."
+
+    @property
+    def parameters(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                "name": "block_id",
+                "type": "string",
+                "description": "The ID of the memory block to retrieve.",
+                "required": True,
+            }
+        ]
+
+    async def execute(self, **kwargs: Any) -> Dict[str, Any]:
+        block_id = kwargs.get("block_id")
+        if not block_id:
+            raise ValueError("The 'block_id' parameter is required.")
+
+        block = await self.memory_manager.get_core_memory_block(block_id)
+        
+        if block is None:
+            return {"status": "error", "message": f"Block '{block_id}' not found."}
+
+        return {"status": "success", "block": block}

neuro_simulator/agent/tools/get_core_memory_blocks.py

@@ -0,0 +1,30 @@
+# neuro_simulator/agent/tools/get_core_memory_blocks.py
+"""The Get Core Memory Blocks tool for the agent."""
+
+from typing import Dict, Any, List
+
+from .base import BaseTool
+from ..memory.manager import MemoryManager
+
+class GetCoreMemoryBlocksTool(BaseTool):
+    """Tool to retrieve all core memory blocks."""
+
+    def __init__(self, memory_manager: MemoryManager):
+        self.memory_manager = memory_manager
+
+    @property
+    def name(self) -> str:
+        return "get_core_memory_blocks"
+
+    @property
+    def description(self) -> str:
+        return "Retrieves a list of all available core memory blocks, including their IDs, titles, and descriptions."
+
+    @property
+    def parameters(self) -> List[Dict[str, Any]]:
+        return []
+
+    async def execute(self, **kwargs: Any) -> Dict[str, Any]:
+        blocks = await self.memory_manager.get_core_memory_blocks()
+        # The result should be JSON serializable, which a Dict of Dicts already is.
+        return {"status": "success", "blocks": blocks}

neuro_simulator/agent/tools/manager.py

@@ -0,0 +1,120 @@
+# neuro_simulator/agent/tools/manager.py
+"""The central tool manager for the agent, responsible for loading, managing, and executing tools."""
+
+import os
+import importlib
+import inspect
+import logging
+from pathlib import Path
+from typing import Dict, Any, List
+
+from .base import BaseTool
+from ..memory.manager import MemoryManager
+
+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.
+    """
+
+    def __init__(self, memory_manager: MemoryManager):
+        """
+        Initializes the ToolManager.
+        Args:
+            memory_manager: An instance of MemoryManager, passed to tools that need it.
+        """
+        self.memory_manager = memory_manager
+        self.tools: Dict[str, BaseTool] = {}
+        self._load_and_register_tools()
+
+        # 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}")
+
+    def _load_and_register_tools(self):
+        """Dynamically scans the '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)
+
+    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}")
+
+    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)}"}

neuro_simulator/agent/tools/remove_from_core_memory_block.py

@@ -0,0 +1,65 @@
+# neuro_simulator/agent/tools/remove_from_core_memory_block.py
+"""The Remove from Core Memory Block tool for the agent."""
+
+from typing import Dict, Any, List
+
+from .base import BaseTool
+from ..memory.manager import MemoryManager
+
+class RemoveFromCoreMemoryBlockTool(BaseTool):
+    """Tool to remove an item from an existing core memory block's content list by its index."""
+
+    def __init__(self, memory_manager: MemoryManager):
+        self.memory_manager = memory_manager
+
+    @property
+    def name(self) -> str:
+        return "remove_from_core_memory_block"
+
+    @property
+    def description(self) -> str:
+        return "Removes an item from the content list of a specific core memory block by its zero-based index."
+
+    @property
+    def parameters(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                "name": "block_id",
+                "type": "string",
+                "description": "The ID of the memory block to modify.",
+                "required": True,
+            },
+            {
+                "name": "index",
+                "type": "integer",
+                "description": "The zero-based index of the item to remove from the content list.",
+                "required": True,
+            }
+        ]
+
+    async def execute(self, **kwargs: Any) -> Dict[str, Any]:
+        block_id = kwargs.get("block_id")
+        index = kwargs.get("index")
+
+        if not block_id or index is None:
+            raise ValueError("The 'block_id' and 'index' parameters are required.")
+
+        block = await self.memory_manager.get_core_memory_block(block_id)
+        if block is None:
+            raise ValueError(f"Block '{block_id}' not found.")
+        
+        content = block.get("content", [])
+        if not isinstance(content, list):
+            raise TypeError(f"Content of block '{block_id}' is not a list.")
+
+        try:
+            removed_item = content.pop(index)
+        except IndexError:
+            raise IndexError(f"Index {index} is out of bounds for content in block '{block_id}'.")
+        
+        await self.memory_manager.update_core_memory_block(block_id=block_id, content=content)
+        
+        return {
+            "status": "success",
+            "message": f"Removed item '{removed_item}' from core memory block '{block_id}' at index {index}."
+        }

neuro_simulator/agent/tools/speak.py

@@ -0,0 +1,56 @@
+# neuro_simulator/agent/tools/speak.py
+"""The Speak tool for the agent."""
+
+import logging
+from typing import Dict, Any, List
+
+from .base import BaseTool
+from ..memory.manager import MemoryManager
+
+logger = logging.getLogger(__name__.replace("neuro_simulator", "agent", 1))
+
+class SpeakTool(BaseTool):
+    """Tool for the agent to speak to the audience."""
+
+    def __init__(self, memory_manager: MemoryManager):
+        """Initializes the SpeakTool."""
+        # This tool doesn't directly use the memory manager, but accepts it for consistency.
+        self.memory_manager = memory_manager
+
+    @property
+    def name(self) -> str:
+        return "speak"
+
+    @property
+    def description(self) -> str:
+        return "Outputs text to the user. This is the primary way to communicate with the audience."
+
+    @property
+    def parameters(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                "name": "text",
+                "type": "string",
+                "description": "The text to be spoken to the audience.",
+                "required": True,
+            }
+        ]
+
+    async def execute(self, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Executes the speak action.
+        
+        Args:
+            **kwargs: Must contain a 'text' key with the string to be spoken.
+
+        Returns:
+            A dictionary confirming the action and the text that was spoken.
+        """
+        text = kwargs.get("text")
+        if not isinstance(text, str) or not text:
+            raise ValueError("The 'text' parameter must be a non-empty string.")
+        
+        logger.info(f"Agent says: {text}")
+        # The result of the speak tool is the text that was spoken.
+        # This can be used for logging or further processing.
+        return {"status": "success", "spoken_text": text}

neuro_simulator/agent/tools/update_core_memory_block.py

@@ -0,0 +1,65 @@
+# neuro_simulator/agent/tools/update_core_memory_block.py
+"""The Update Core Memory Block tool for the agent."""
+
+from typing import Dict, Any, List, Optional
+
+from .base import BaseTool
+from ..memory.manager import MemoryManager
+
+class UpdateCoreMemoryBlockTool(BaseTool):
+    """Tool to update an existing core memory block."""
+
+    def __init__(self, memory_manager: MemoryManager):
+        self.memory_manager = memory_manager
+
+    @property
+    def name(self) -> str:
+        return "update_core_memory_block"
+
+    @property
+    def description(self) -> str:
+        return "Updates an existing core memory block. All parameters are optional, only provided fields will be updated."
+
+    @property
+    def parameters(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                "name": "block_id",
+                "type": "string",
+                "description": "The ID of the memory block to update.",
+                "required": True,
+            },
+            {
+                "name": "title",
+                "type": "string",
+                "description": "The new title for the memory block.",
+                "required": False,
+            },
+            {
+                "name": "description",
+                "type": "string",
+                "description": "The new description for the memory block.",
+                "required": False,
+            },
+            {
+                "name": "content",
+                "type": "array",
+                "description": "The new list of string entries, which will overwrite the existing content.",
+                "required": False,
+            }
+        ]
+
+    async def execute(self, **kwargs: Any) -> Dict[str, Any]:
+        block_id = kwargs.get("block_id")
+        if not block_id:
+            raise ValueError("The 'block_id' parameter is required.")
+
+        # Only include parameters that are not None to avoid overwriting with nulls
+        update_payload = {k: v for k, v in kwargs.items() if v is not None}
+
+        await self.memory_manager.update_core_memory_block(**update_payload)
+        
+        return {
+            "status": "success",
+            "message": f"Successfully updated core memory block '{block_id}'."
+        }

neuro_simulator/api/system.py

@@ -6,6 +6,7 @@ import time
 
 from ..core.config import config_manager
 
+
 router = APIRouter(tags=["System & Utilities"])
 
 
@@ -57,4 +58,6 @@ async def root():
         "message": "Neuro-Sama Simulator Backend",
         "version": "2.0",
         "api_docs": "/docs",
-    }
+    }
+
+

neuro_simulator/core/application.py

@@ -287,6 +287,10 @@ async def websocket_admin_endpoint(websocket: WebSocket):
         initial_context = await agent.get_message_history()
         await websocket.send_json({"type": "agent_context", "action": "update", "messages": initial_context})
         
+        # Send initial stream status
+        status = {"is_running": process_manager.is_running, "backend_status": "running" if process_manager.is_running else "stopped"}
+        await websocket.send_json({"type": "stream_status", "payload": status})
+        
         # Main loop for receiving messages from the client and pushing log updates
         while websocket.client_state == WebSocketState.CONNECTED:
             # Check for incoming messages
@@ -328,7 +332,6 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
             response["payload"] = {"status": "success", "block_id": block_id}
             # Broadcast the update to all admins
             updated_blocks = await agent.get_memory_blocks()
-            from ..utils.websocket import connection_manager
             await connection_manager.broadcast_to_admins({"type": "core_memory_updated", "payload": updated_blocks})
 
         elif action == "update_core_memory_block":
@@ -336,7 +339,6 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
             response["payload"] = {"status": "success"}
             # Broadcast the update to all admins
             updated_blocks = await agent.get_memory_blocks()
-            from ..utils.websocket import connection_manager
             await connection_manager.broadcast_to_admins({"type": "core_memory_updated", "payload": updated_blocks})
 
         elif action == "delete_core_memory_block":
@@ -344,7 +346,6 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
             response["payload"] = {"status": "success"}
             # Broadcast the update to all admins
             updated_blocks = await agent.get_memory_blocks()
-            from ..utils.websocket import connection_manager
             await connection_manager.broadcast_to_admins({"type": "core_memory_updated", "payload": updated_blocks})
 
         # Temp Memory Actions
@@ -356,7 +357,6 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
             await agent.add_temp_memory(**payload)
             response["payload"] = {"status": "success"}
             updated_temp_mem = await agent.get_temp_memory()
-            from ..utils.websocket import connection_manager
             await connection_manager.broadcast_to_admins({"type": "temp_memory_updated", "payload": updated_temp_mem})
 
         elif action == "clear_temp_memory":
@@ -374,13 +374,35 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
             await agent.update_init_memory(**payload)
             response["payload"] = {"status": "success"}
             updated_init_mem = await agent.get_init_memory()
-            from ..utils.websocket import connection_manager
             await connection_manager.broadcast_to_admins({"type": "init_memory_updated", "payload": updated_init_mem})
 
         # Tool Actions
-        elif action == "get_tools":
-            tools = await agent.get_available_tools()
-            response["payload"] = {"tools": tools}
+        elif action == "get_all_tools":
+            agent_instance = getattr(agent, 'agent_instance', agent)
+            all_tools = agent_instance.tool_manager.get_all_tool_schemas()
+            response["payload"] = {"tools": all_tools}
+
+        elif action == "get_agent_tool_allocations":
+            agent_instance = getattr(agent, 'agent_instance', agent)
+            allocations = agent_instance.tool_manager.get_allocations()
+            response["payload"] = {"allocations": allocations}
+
+        elif action == "set_agent_tool_allocations":
+            agent_instance = getattr(agent, 'agent_instance', agent)
+            allocations_payload = payload.get("allocations", {})
+            agent_instance.tool_manager.set_allocations(allocations_payload)
+            response["payload"] = {"status": "success"}
+            # Broadcast the update to all admins
+            updated_allocations = agent_instance.tool_manager.get_allocations()
+            await connection_manager.broadcast_to_admins({"type": "agent_tool_allocations_updated", "payload": {"allocations": updated_allocations}})
+
+        elif action == "reload_tools":
+            agent_instance = getattr(agent, 'agent_instance', agent)
+            agent_instance.tool_manager.reload_tools()
+            response["payload"] = {"status": "success"}
+            # Broadcast an event to notify UI to refresh tool lists
+            all_tools = agent_instance.tool_manager.get_all_tool_schemas()
+            await connection_manager.broadcast_to_admins({"type": "available_tools_updated", "payload": {"tools": all_tools}})
 
         elif action == "execute_tool":
             result = await agent.execute_tool(**payload)
@@ -391,17 +413,26 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
             if not process_manager.is_running:
                 process_manager.start_live_processes()
             response["payload"] = {"status": "success", "message": "Stream started"}
+            # Broadcast stream status update
+            status = {"is_running": process_manager.is_running, "backend_status": "running" if process_manager.is_running else "stopped"}
+            await connection_manager.broadcast_to_admins({"type": "stream_status", "payload": status})
 
         elif action == "stop_stream":
             if process_manager.is_running:
                 await process_manager.stop_live_processes()
             response["payload"] = {"status": "success", "message": "Stream stopped"}
+            # Broadcast stream status update
+            status = {"is_running": process_manager.is_running, "backend_status": "running" if process_manager.is_running else "stopped"}
+            await connection_manager.broadcast_to_admins({"type": "stream_status", "payload": status})
 
         elif action == "restart_stream":
             await process_manager.stop_live_processes()
             await asyncio.sleep(1)
             process_manager.start_live_processes()
             response["payload"] = {"status": "success", "message": "Stream restarted"}
+            # Broadcast stream status update
+            status = {"is_running": process_manager.is_running, "backend_status": "running" if process_manager.is_running else "stopped"}
+            await connection_manager.broadcast_to_admins({"type": "stream_status", "payload": status})
 
         elif action == "get_stream_status":
             status = {"is_running": process_manager.is_running, "backend_status": "running" if process_manager.is_running else "stopped"}
@@ -432,6 +463,24 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
             context = await agent.get_message_history()
             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."}
+            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}
+
         elif action == "reset_agent_memory":
             await agent.reset_memory()
             response["payload"] = {"status": "success"}

neuro_simulator/utils/process.py

@@ -33,6 +33,7 @@ class ProcessManager:
         from ..core.application import generate_audience_chat_task, neuro_response_cycle, broadcast_events_task
         from ..utils.queue import clear_all_queues
         from ..core.agent_factory import create_agent
+        from ..utils.websocket import connection_manager
         
         asyncio.create_task(create_agent())
         
@@ -45,6 +46,9 @@ class ProcessManager:
         self._tasks.append(asyncio.create_task(neuro_response_cycle()))
         
         self._is_running = True
+        # Broadcast stream status update
+        status = {"is_running": self._is_running, "backend_status": "running" if self._is_running else "stopped"}
+        asyncio.create_task(connection_manager.broadcast_to_admins({"type": "stream_status", "payload": status}))
         logger.info(f"Core processes started: {len(self._tasks)} tasks.")
 
     async def stop_live_processes(self):
@@ -66,6 +70,10 @@ class ProcessManager:
         
         live_stream_manager.reset_stream_state()
         
+        # Broadcast stream status update
+        status = {"is_running": self._is_running, "backend_status": "running" if self._is_running else "stopped"}
+        await connection_manager.broadcast_to_admins({"type": "stream_status", "payload": status})
+        
         logger.info("All core tasks have been stopped.")
 
 # Global singleton instance

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

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

{neuro_simulator-0.3.1.dist-info → neuro_simulator-0.3.3.dist-info}/RECORD

@@ -2,20 +2,32 @@ neuro_simulator/__init__.py,sha256=-tposzyvg6UckPcfSvtc03UjxBa9oCe_zRvlKf8splk,3
 neuro_simulator/cli.py,sha256=Nc-udO0jdRVZjlbebKBjDVOIUzd6tJr13ApBGeBEg2k,3967
 neuro_simulator/agent/__init__.py,sha256=t52CZlyTGWqcGjMs90qvpFpRckY2WSSlO7r_H3K_mSY,32
 neuro_simulator/agent/base.py,sha256=6v2ZO5UpGCwJEkJ23Oe96Rs510tK4ZOEpZ2DB49IZmM,1262
-neuro_simulator/agent/core.py,sha256=2mPVCcNKZDRsyYd6L8RzQYlm8LwzoKoP9FJg0W4qcbc,10702
+neuro_simulator/agent/core.py,sha256=hyO17c-uYhzN8Yix-jraRTTLj8a3JwZuJ7eMnbGJMTE,12218
 neuro_simulator/agent/factory.py,sha256=e0IBnqJQM7OuKtglrf-pWwqwmg98wh7tOq5LxF2rV-w,1146
 neuro_simulator/agent/llm.py,sha256=vLz8hp2h2R0JaNfS1RLGYGkri_YoUdlEdNfFVbxeEuI,4261
+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=UiUJgjiTV7SHCmb3V5sc4OUa_ksEeXBOyvl-WBQviqs,9266
 neuro_simulator/agent/tools/__init__.py,sha256=1WZy6PADfi6o1avyy1y-ThWBFAPJ_bBqtkobyYpf5ao,38
-neuro_simulator/agent/tools/core.py,sha256=o6Oyis-HFD-g6Z_u3T--tkmr9ylKJvybKqMRSMUwi1Q,5555
+neuro_simulator/agent/tools/add_temp_memory.py,sha256=uFdnyPchtUo3kWrTT5UXGJQA3V1SfIw633qTuTv0c1w,2080
+neuro_simulator/agent/tools/add_to_core_memory_block.py,sha256=YZmOlwtSOQVszt_tY7iDFSLiHa1UKv7OMutpMEcCrkg,2259
+neuro_simulator/agent/tools/base.py,sha256=Xj9ABTAtSFazhQf-qCMMWTCQVLsq48MZtKFVuBsYLQg,1799
+neuro_simulator/agent/tools/create_core_memory_block.py,sha256=k6_zUq2Vf-IA4A6Z5ePiqeuLEil25ycL5FpbIYeKTU4,2719
+neuro_simulator/agent/tools/delete_core_memory_block.py,sha256=-_GIoFIJo6K-jmL3xOedSJtiyoxbfN4noC_cA5pVa6A,1332
+neuro_simulator/agent/tools/get_core_memory_block.py,sha256=XfFY6BZgnczTQqzXxZc8FLLaCRCd-FpGQd9zmj37P3M,1385
+neuro_simulator/agent/tools/get_core_memory_blocks.py,sha256=tivCwm6NIc7legrPAYGW9Txttp6-u0uE4_j2IOSuUmI,1012
+neuro_simulator/agent/tools/manager.py,sha256=n3lKku37vrGjkXJKdVZNXf2bXuVcILKX1Wv-fIl6m7M,5136
+neuro_simulator/agent/tools/remove_from_core_memory_block.py,sha256=xTY-gauo2P6p2-jyvwOupIeJ2vHtk8RoZ-_BLMF8T7w,2325
+neuro_simulator/agent/tools/speak.py,sha256=CkYfpkVM4c0dKXyEuITfH5cLVh2jN992fCO83uoIVvQ,1823
+neuro_simulator/agent/tools/update_core_memory_block.py,sha256=0KwcugykHqXsxVCFHctL-zVBXR5dVjGOdxce2ixYrPg,2225
 neuro_simulator/api/__init__.py,sha256=5LWyDSayPGdQS8Rv13nmAKLyhPnMVPyTYDdvoMPB4xw,56
 neuro_simulator/api/stream.py,sha256=hM66flSUygpE-NH9X-ZOV6SiGipBzN1-wjd_wZRpQm4,94
-neuro_simulator/api/system.py,sha256=TV_3DzP-VgLnHdue0pKYFFQNOV_V7tr4aMuxL802vQg,1783
+neuro_simulator/api/system.py,sha256=W05Q41BYAFrw-MTnJ5YJrBG2S1SmTcByoex77GfUaFQ,1787
 neuro_simulator/core/__init__.py,sha256=-ojq25c8XA0CU25b0OxcGjH4IWFEDHR-HXSRSZIuKe8,57
 neuro_simulator/core/agent_factory.py,sha256=qMFidwT5IrOkyNHwmpO8_fRv20KLbaIBfWF-VTFCLNA,1742
 neuro_simulator/core/agent_interface.py,sha256=ZXUCtkQUvsBQ5iCb0gTILJaShn5KmSrEgKhd7PK18HE,2794
-neuro_simulator/core/application.py,sha256=lhTn5KR7ek8-kuyD1qWtppImUUz8pOExH9KRNW1SQ3M,21115
+neuro_simulator/core/application.py,sha256=L7C0m9jgKfuLCzWiokVs7g1wj3C4mbEb9AFNqo4JF0I,24692
 neuro_simulator/core/config.py,sha256=brA8kiekV_995mpz04JiGj1swIWbZZuWWLNYtbroMyE,14884
 neuro_simulator/services/__init__.py,sha256=s3ZrAHg5TpJakadAAGY1h0wDw_xqN4Je4aJwJyRBmk4,61
 neuro_simulator/services/audience.py,sha256=0phlhsujh_GMXm_UMiyOntY-ZMtoseRa_FroIfc5A6w,5028
@@ -25,12 +37,12 @@ neuro_simulator/services/letta.py,sha256=6jBvOTsLMlRILDv-fvX9fhHMONSYeu-ImJGFcKU
 neuro_simulator/services/stream.py,sha256=dG7RuNI_ICohPkqKZ-zlBppo54BgWm_KYBs-ezzc73E,5907
 neuro_simulator/utils/__init__.py,sha256=xSEFzjT827W81mNyQ_DLtr00TgFlttqfFgpz9pSxFXQ,58
 neuro_simulator/utils/logging.py,sha256=BO-q_cCcoeamsc8eJqq2-L3Z8nhApze_v6LnmD-O8Ww,3411
-neuro_simulator/utils/process.py,sha256=9w2JQH59Wy6L8ADrig2QF88iajdykGPZIYJVJe6Al2Y,2603
+neuro_simulator/utils/process.py,sha256=9OYWx8fzaJZqmFUcjQX37AnBhl7YWvrLxDWBa30vqwU,3192
 neuro_simulator/utils/queue.py,sha256=vSkh-BrgfsGN_gDAx2mfK44ydmMapdVyLsDG-7LIJZQ,1643
 neuro_simulator/utils/state.py,sha256=DdBqSAYfjOFtJfB1hEGhYPh32r1ZvFuVlN_-29_-luA,664
 neuro_simulator/utils/websocket.py,sha256=1gtVoH1hafBUfVYmwkVDAbjwETeqyC3sWx706nQzSRo,2085
-neuro_simulator-0.3.1.dist-info/METADATA,sha256=lQv9x0KvOZJAA8NwZ8byIaHYTVnSxuHRPyhUyqLC6vw,8643
-neuro_simulator-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-neuro_simulator-0.3.1.dist-info/entry_points.txt,sha256=qVd5ypnRRgU8Cw7rWfZ7o0OXyS9P9hgY-cRoN_mgz9g,51
-neuro_simulator-0.3.1.dist-info/top_level.txt,sha256=V8awSKpcrFnjJDiJxSfy7jtOrnuE2BgAR9hLmfMDWK8,16
-neuro_simulator-0.3.1.dist-info/RECORD,,
+neuro_simulator-0.3.3.dist-info/METADATA,sha256=almvuJaLS7nvw30-XjNLX6UdZ7-qaFdWdoTymHFs3qE,8643
+neuro_simulator-0.3.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+neuro_simulator-0.3.3.dist-info/entry_points.txt,sha256=qVd5ypnRRgU8Cw7rWfZ7o0OXyS9P9hgY-cRoN_mgz9g,51
+neuro_simulator-0.3.3.dist-info/top_level.txt,sha256=V8awSKpcrFnjJDiJxSfy7jtOrnuE2BgAR9hLmfMDWK8,16
+neuro_simulator-0.3.3.dist-info/RECORD,,

neuro_simulator/agent/tools/core.py

@@ -1,102 +0,0 @@
-# neuro_simulator/agent/tools/core.py
-"""
-Core tools for the Neuro Simulator Agent
-"""
-
-import logging
-from pathlib import Path
-from typing import Dict, List, Any, Optional
-
-# Use a logger with a shortened, more readable name
-logger = logging.getLogger(__name__.replace("neuro_simulator", "agent", 1))
-
-class ToolManager:
-    """Manages all tools available to the agent"""
-    
-    def __init__(self, memory_manager):
-        self.memory_manager = memory_manager
-        self.tools = {}
-        self._register_tools()
-        
-    def _register_tools(self):
-        """Register all available tools"""
-        self.tools["get_core_memory_blocks"] = self._get_core_memory_blocks
-        self.tools["get_core_memory_block"] = self._get_core_memory_block
-        self.tools["create_core_memory_block"] = self._create_core_memory_block
-        self.tools["update_core_memory_block"] = self._update_core_memory_block
-        self.tools["delete_core_memory_block"] = self._delete_core_memory_block
-        self.tools["add_to_core_memory_block"] = self._add_to_core_memory_block
-        self.tools["remove_from_core_memory_block"] = self._remove_from_core_memory_block
-        self.tools["add_temp_memory"] = self._add_temp_memory
-        self.tools["speak"] = self._speak
-        
-    def get_tool_descriptions(self) -> str:
-        """Get descriptions of all available tools"""
-        descriptions = [
-            "Available tools:",
-            "1. get_core_memory_blocks() - Get all core memory blocks",
-            "2. get_core_memory_block(block_id: string) - Get a specific core memory block",
-            "3. create_core_memory_block(title: string, description: string, content: list) - Create a new core memory block with a generated ID",
-            "4. update_core_memory_block(block_id: string, title: string (optional), description: string (optional), content: list (optional)) - Update a core memory block",
-            "5. delete_core_memory_block(block_id: string) - Delete a core memory block",
-            "6. add_to_core_memory_block(block_id: string, item: string) - Add an item to a core memory block",
-            "7. remove_from_core_memory_block(block_id: string, index: integer) - Remove an item from a core memory block by index",
-            "8. add_temp_memory(content: string, role: string) - Add an item to temporary memory",
-            "9. speak(text: string) - Output text to the user",
-            "",
-            "IMPORTANT INSTRUCTIONS:",
-            "- When you want to speak to the user, ONLY use the speak tool with your response as the text parameter",
-            "- DO NOT use print() or any other wrapper functions around the speak tool",
-            "- Example of correct usage: speak(text='Hello, how can I help you today?')",
-            "- Example of incorrect usage: print(speak(text='Hello, how can I help you today?'))",
-            "- ONLY return ONE tool call per response",
-            "- Format your response as plain text with the tool call, nothing else"
-        ]
-        return "\n".join(descriptions)
-        
-    async def execute_tool(self, tool_name: str, params: Dict[str, Any]) -> Any:
-        """Execute a tool by name with given parameters"""
-        if tool_name not in self.tools:
-            return {"error": f"Tool '{tool_name}' not found"}
-            
-        try:
-            result = await self.tools[tool_name](**params)
-            return result
-        except Exception as e:
-            return {"error": f"Error executing tool '{tool_name}': {str(e)}"}
-            
-    # Tool implementations
-    async def _get_core_memory_blocks(self) -> Dict[str, Any]:
-        return await self.memory_manager.get_core_memory_blocks()
-        
-    async def _get_core_memory_block(self, block_id: str) -> Optional[Dict[str, Any]]:
-        return await self.memory_manager.get_core_memory_block(block_id)
-        
-    async def _create_core_memory_block(self, title: str, description: str, content: List[str]) -> str:
-        block_id = await self.memory_manager.create_core_memory_block(title, description, content)
-        return f"Created core memory block '{block_id}' with title '{title}'"
-        
-    async def _update_core_memory_block(self, block_id: str, title: str = None, description: str = None, content: List[str] = None) -> str:
-        await self.memory_manager.update_core_memory_block(block_id, title, description, content)
-        return f"Updated core memory block '{block_id}'"
-        
-    async def _delete_core_memory_block(self, block_id: str) -> str:
-        await self.memory_manager.delete_core_memory_block(block_id)
-        return f"Deleted core memory block '{block_id}'"
-        
-    async def _add_to_core_memory_block(self, block_id: str, item: str) -> str:
-        await self.memory_manager.add_to_core_memory_block(block_id, item)
-        return f"Added item to core memory block '{block_id}'"
-        
-    async def _remove_from_core_memory_block(self, block_id: str, index: int) -> str:
-        await self.memory_manager.remove_from_core_memory_block(block_id, index)
-        return f"Removed item from core memory block '{block_id}' at index {index}"
-        
-    async def _add_temp_memory(self, content: str, role: str = "user") -> str:
-        await self.memory_manager.add_temp_memory(content, role)
-        return f"Added item to temp memory with role '{role}'"
-        
-    async def _speak(self, text: str) -> str:
-        """Output text - this is how the agent communicates with users"""
-        logger.info(f"Agent says: {text}")
-        return text