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

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

@@ -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 → neuro_simulator-0.3.3}/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-0.3.3/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-0.3.3/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-0.3.3/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-0.3.3/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-0.3.3/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-0.3.3/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-0.3.3/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-0.3.3/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-0.3.3/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-0.3.3/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)}"}