neuro-simulator 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

neuro_simulator/agent/factory.py

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

neuro_simulator/agent/llm.py

@@ -1,30 +1,37 @@
-# agent/llm.py
+# neuro_simulator/agent/llm.py
 """
-LLM client for the Neuro Simulator Agent
+LLM client for the Neuro Simulator's built-in agent.
 """
 
+import asyncio
+import logging
+from pathlib import Path
 from typing import Optional
-import os
-import sys
-
-# Add project root to path
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
 
 from google import genai
 from google.genai import types
 from openai import AsyncOpenAI
-from ..config import config_manager
+
+from ..core.config import config_manager
+
+# Use a logger with a shortened, more readable name
+logger = logging.getLogger(__name__.replace("neuro_simulator", "agent", 1))
 
 class LLMClient:
-    """A completely independent LLM client for the built-in agent."""
+    """A completely independent LLM client for the built-in agent, now with lazy initialization."""
     
     def __init__(self):
         self.client = None
         self.model_name = None
-        self._initialize_client()
-        
-    def _initialize_client(self):
-        """Initializes the LLM client based on the 'agent' section of the config."""
+        self._generate_func = None
+        self._initialized = False
+
+    async def _ensure_initialized(self):
+        """Initializes the client on first use."""
+        if self._initialized:
+            return
+
+        logger.info("First use of built-in agent's LLMClient, performing initialization...")
         settings = config_manager.settings
         provider = settings.agent.agent_provider.lower()
         
@@ -33,7 +40,6 @@ class LLMClient:
             if not api_key:
                 raise ValueError("GEMINI_API_KEY is not set in configuration for the agent.")
             
-            # Use the new client-based API as per the latest documentation
             self.client = genai.Client(api_key=api_key)
             self.model_name = settings.agent.agent_model
             self._generate_func = self._generate_gemini
@@ -52,53 +58,50 @@ class LLMClient:
         else:
             raise ValueError(f"Unsupported agent provider in config: {settings.agent.agent_provider}")
             
-        print(f"Agent LLM client initialized. Provider: {provider.upper()}, Model: {self.model_name}")
+        self._initialized = True
+        logger.info(f"Agent LLM client initialized. Provider: {provider.upper()}, Model: {self.model_name}")
 
     async def _generate_gemini(self, prompt: str, max_tokens: int) -> str:
-        """Generates text using the Gemini model with the new SDK."""
-        import asyncio
-        
+        """Generates text using the Gemini model."""
         generation_config = types.GenerateContentConfig(
             max_output_tokens=max_tokens,
-            # temperature can be added later if needed from config
         )
-        
         try:
-            # The new client's generate_content is synchronous, run it in a thread
             response = await asyncio.to_thread(
                 self.client.models.generate_content,
                 model=self.model_name,
                 contents=prompt,
                 config=generation_config
             )
-            return response.text if response and response.text else ""
+            return response.text if response and hasattr(response, 'text') else ""
         except Exception as e:
-            print(f"Error in _generate_gemini: {e}")
+            logger.error(f"Error in _generate_gemini: {e}", exc_info=True)
             return ""
 
     async def _generate_openai(self, prompt: str, max_tokens: int) -> str:
+        """Generates text using the OpenAI model."""
         try:
             response = await self.client.chat.completions.create(
                 model=self.model_name,
                 messages=[{"role": "user", "content": prompt}],
                 max_tokens=max_tokens,
-                # temperature can be added to config if needed
             )
             if response.choices and response.choices[0].message and response.choices[0].message.content:
                 return response.choices[0].message.content.strip()
             return ""
         except Exception as e:
-            print(f"Error in _generate_openai: {e}")
+            logger.error(f"Error in _generate_openai: {e}", exc_info=True)
             return ""
         
     async def generate(self, prompt: str, max_tokens: int = 1000) -> str:
-        """Generate text using the configured LLM."""
-        if not self.client:
-            raise RuntimeError("LLM Client is not initialized.")
+        """Generate text using the configured LLM, ensuring client is initialized."""
+        await self._ensure_initialized()
+
+        if not self.client or not self._generate_func:
+            raise RuntimeError("LLM Client could not be initialized.")
         try:
             result = await self._generate_func(prompt, max_tokens)
-            # Ensure we always return a string, even if the result is None
             return result if result is not None else ""
         except Exception as e:
-            print(f"Error generating text with Agent LLM: {e}")
-            return "My brain is not working, tell Vedal to check the logs."
+            logger.error(f"Error generating text with Agent LLM: {e}", exc_info=True)
+            return "My brain is not working, tell Vedal to check the logs."

neuro_simulator/agent/memory/__init__.py

@@ -1,4 +1 @@
-# agent/memory/__init__.py
-"""
-Memory module for the Neuro Simulator Agent
-"""
+# neuro_simulator.agent.memory package

neuro_simulator/agent/memory/manager.py

@@ -1,97 +1,64 @@
-# agent/memory/manager.py
+# neuro_simulator/agent/memory/manager.py
 """
-Advanced memory management for the Neuro Simulator Agent
+Advanced memory management for the Neuro Simulator Agent.
 """
 
-import os
-import json
 import asyncio
-from typing import Dict, List, Any, Optional
-from datetime import datetime
+import json
+import logging
+import os
 import random
 import string
-import sys
+from datetime import datetime
+from typing import Any, Dict, List, Optional
 
+# Use the existing agent logger for consistent logging
+logger = logging.getLogger("neuro_agent")
 
 def generate_id(length=6) -> str:
-    """Generate a random ID string"""
+    """Generate a random ID string."""
     return ''.join(random.choices(string.ascii_letters + string.digits, k=length))
 
-
 class MemoryManager:
-    """Manages different types of memory for the agent"""
+    """Manages different types of memory for the agent."""
     
     def __init__(self, working_dir: str = None):
-        # Use provided working directory or default to current directory
         if working_dir is None:
             working_dir = os.getcwd()
             
         self.memory_dir = os.path.join(working_dir, "agent", "memory")
         os.makedirs(self.memory_dir, exist_ok=True)
         
-        # Memory file paths
         self.init_memory_file = os.path.join(self.memory_dir, "init_memory.json")
         self.core_memory_file = os.path.join(self.memory_dir, "core_memory.json")
-        self.context_file = os.path.join(self.memory_dir, "context.json")  # 新的上下文文件
+        self.context_file = os.path.join(self.memory_dir, "context.json")
         self.temp_memory_file = os.path.join(self.memory_dir, "temp_memory.json")
         
-        # In-memory storage
         self.init_memory: Dict[str, Any] = {}
         self.core_memory: Dict[str, Any] = {}
-        self.context_history: List[Dict[str, Any]] = []  # 新的上下文历史
-        self.temp_memory: List[Dict[str, Any]] = []     # 真正的临时内存
+        self.context_history: List[Dict[str, Any]] = []
+        self.temp_memory: List[Dict[str, Any]] = []
         
     async def initialize(self):
-        """Load all memory types from files"""
-        # Load init memory (immutable by agent)
+        """Load all memory types from files."""
+        # Load init memory
         if os.path.exists(self.init_memory_file):
             with open(self.init_memory_file, 'r', encoding='utf-8') as f:
                 self.init_memory = json.load(f)
         else:
-            # Default init memory - this is just an example, users can customize
             self.init_memory = {
-                "name": "Neuro-Sama",
-                "role": "AI VTuber",
+                "name": "Neuro-Sama", "role": "AI VTuber",
                 "personality": "Friendly, curious, and entertaining",
-                "capabilities": [
-                    "Chat with viewers",
-                    "Answer questions",
-                    "Entertain audience",
-                    "Express opinions"
-                ]
+                "capabilities": ["Chat with viewers", "Answer questions"]
             }
             await self._save_init_memory()
             
-        # Load core memory (mutable by both agent and user)
+        # Load core memory
         if os.path.exists(self.core_memory_file):
             with open(self.core_memory_file, 'r', encoding='utf-8') as f:
                 self.core_memory = json.load(f)
         else:
-            # Default core memory with blocks
-            self.core_memory = {
-                "blocks": {
-                    "general_knowledge": {
-                        "id": "general_knowledge",
-                        "title": "General Knowledge",
-                        "description": "Basic facts and knowledge about the world",
-                        "content": [
-                            "The earth is round",
-                            "Water boils at 100°C at sea level",
-                            "Humans need oxygen to survive"
-                        ]
-                    },
-                    "stream_info": {
-                        "id": "stream_info",
-                        "title": "Stream Information",
-                        "description": "Information about this stream and Neuro-Sama",
-                        "content": [
-                            "This is a simulation of Neuro-Sama, an AI VTuber",
-                            "The stream is meant for entertainment and experimentation",
-                            "Viewers can interact with Neuro-Sama through chat"
-                        ]
-                    }
-                }
-            }
+            self.core_memory = {"blocks": {}}
             await self._save_core_memory()
             
         # Load context history
@@ -101,270 +68,137 @@ class MemoryManager:
         else:
             self.context_history = []
             
-        # Load temp memory (frequently changed by agent)
+        # Load temp memory
         if os.path.exists(self.temp_memory_file):
             with open(self.temp_memory_file, 'r', encoding='utf-8') as f:
                 self.temp_memory = json.load(f)
+        else:
+            self.temp_memory = []
                 
-        print("Memory manager initialized with all memory types")
+        logger.info("Agent memory manager initialized.")
         
     async def _save_init_memory(self):
-        """Save init memory to file"""
         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]):
-        """Update init memory with new values"""
         self.init_memory.update(new_memory)
         await self._save_init_memory()
             
     async def _save_core_memory(self):
-        """Save core memory to file"""
         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_context(self):
-        """Save context to file"""
         with open(self.context_file, 'w', encoding='utf-8') as f:
             json.dump(self.context_history, f, ensure_ascii=False, indent=2)
             
     async def _save_temp_memory(self):
-        """Save temp memory to file"""
         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 add_context_entry(self, role: str, content: str):
-        """Add an entry to context"""
-        entry = {
-            "id": generate_id(),
-            "role": role,  # "user" or "assistant"
-            "content": content,
-            "timestamp": datetime.now().isoformat()
-        }
+        entry = {"id": generate_id(), "role": role, "content": content, "timestamp": datetime.now().isoformat()}
         self.context_history.append(entry)
-        
-        # Keep only last 20 context entries (10 rounds)
-        if len(self.context_history) > 20:
-            self.context_history = self.context_history[-20:]
-            
         await self._save_context()
         
     async def add_detailed_context_entry(self, input_messages: List[Dict[str, str]], 
                                          prompt: str, llm_response: str, 
                                          tool_executions: List[Dict[str, Any]], 
-                                         final_response: str,
-                                         entry_id: str = None):
-        """Add or update a detailed context entry with full LLM interaction details"""
-        # Check if we're updating an existing entry
+                                         final_response: str, entry_id: str = None):
+        update_data = {
+            "input_messages": input_messages, "prompt": prompt, "llm_response": llm_response,
+            "tool_executions": tool_executions, "final_response": final_response,
+            "timestamp": datetime.now().isoformat()
+        }
         if entry_id:
-            # Find the entry with the given ID and update it
             for entry in self.context_history:
                 if entry.get("id") == entry_id:
-                    entry.update({
-                        "input_messages": input_messages,
-                        "prompt": prompt,
-                        "llm_response": llm_response,
-                        "tool_executions": tool_executions,
-                        "final_response": final_response,
-                        "timestamp": datetime.now().isoformat()
-                    })
+                    entry.update(update_data)
                     await self._save_context()
                     return entry_id
         
-        # If no entry_id was provided or the entry wasn't found, create a new one
-        entry = {
-            "id": entry_id or generate_id(),
-            "type": "llm_interaction",
-            "role": "assistant",  # Add role for llm_interaction entries
-            "input_messages": input_messages,
-            "prompt": prompt,
-            "llm_response": llm_response,
-            "tool_executions": tool_executions,
-            "final_response": final_response,
-            "timestamp": datetime.now().isoformat()
-        }
-        self.context_history.append(entry)
-        
-        # Keep only last 20 context entries
-        if len(self.context_history) > 20:
-            self.context_history = self.context_history[-20:]
-            
+        new_entry = {"id": entry_id or generate_id(), "type": "llm_interaction", "role": "assistant", **update_data}
+        self.context_history.append(new_entry)
         await self._save_context()
-        return entry["id"]
+        return new_entry["id"]
         
-    async def get_recent_context(self, rounds: int = 5) -> List[Dict[str, Any]]:
-        """Get recent context (default: last 5 rounds, 10 entries)"""
-        # Each round consists of user message and assistant response
-        entries_needed = rounds * 2
-        return self.context_history[-entries_needed:] if self.context_history else []
+    async def get_recent_context(self, entries: int = 10) -> List[Dict[str, Any]]:
+        return self.context_history[-entries:]
         
     async def get_detailed_context_history(self) -> List[Dict[str, Any]]:
-        """Get the full detailed context history"""
         return self.context_history
         
     async def get_last_agent_response(self) -> Optional[str]:
-        """Get the last response from the agent"""
         for entry in reversed(self.context_history):
-            if entry.get("role") == "assistant":
-                return entry.get("content")
-            elif entry.get("type") == "llm_interaction":
-                return entry.get("final_response")
+            if entry.get("type") == "llm_interaction":
+                final_response = entry.get("final_response", "")
+                if final_response and final_response not in ["Processing started", "Prompt sent to LLM", "LLM response received"]:
+                    return final_response
+            elif entry.get("role") == "assistant":
+                content = entry.get("content", "")
+                if content and content != "Processing started":
+                    return content
         return None
         
     async def reset_context(self):
-        """Reset context"""
         self.context_history = []
         await self._save_context()
         
     async def reset_temp_memory(self):
-        """Reset only temp memory to default values from example files"""
-        # Load default temp memory from example
-        example_temp_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), 
-                                         "..", "docs", "working_dir_example", "agent", "memory", "temp_memory.json")
-        if os.path.exists(example_temp_path):
-            with open(example_temp_path, 'r', encoding='utf-8') as f:
-                self.temp_memory = json.load(f)
-        else:
-            # Fallback to empty list with one test entry if example file not found
-            self.temp_memory = [
-                {
-                    "id": "0test0",
-                    "content": "This is a test temp_memory.",
-                    "role": "Vedal987",
-                    "timestamp": "2024-12-24T00:00:00.000000"
-                }
-            ]
-        
-        # Save only temp memory
+        """Reset temp memory to a default empty state."""
+        self.temp_memory = []
         await self._save_temp_memory()
-        
-        print("Temp memory has been reset to default values from example files")
+        logger.info("Agent temp memory has been reset.")
         
     async def get_full_context(self) -> str:
-        """Get all memory as context for LLM"""
-        context_parts = []
-        
-        # Add init memory
-        context_parts.append("=== INIT MEMORY (Immutable) ===")
-        for key, value in self.init_memory.items():
-            context_parts.append(f"{key}: {value}")
-            
-        # Add core memory
+        context_parts = ["=== INIT MEMORY (Immutable) ===", json.dumps(self.init_memory, indent=2)]
         context_parts.append("\n=== CORE MEMORY (Long-term, Mutable) ===")
         if "blocks" in self.core_memory:
             for block_id, block in self.core_memory["blocks"].items():
-                context_parts.append(f"\nBlock: {block['title']} ({block_id})")
-                context_parts.append(f"Description: {block['description']}")
+                context_parts.append(f"\nBlock: {block.get('title', '')} ({block_id})")
+                context_parts.append(f"Description: {block.get('description', '')}")
                 context_parts.append("Content:")
-                for item in block["content"]:
+                for item in block.get("content", []):
                     context_parts.append(f"  - {item}")
-                    
-        # Add context (recent conversation history)
-        context_parts.append("\n=== CONTEXT (Recent Conversation) ===")
-        recent_context = await self.get_recent_context(5)
-        for i, entry in enumerate(recent_context):
-            # Handle entries with and without 'role' field
-            if "role" in entry:
-                role_display = "User" if entry["role"] == "user" else "Assistant"
-                content = entry.get('content', entry.get('final_response', 'Unknown entry'))
-                context_parts.append(f"{i+1}. [{role_display}] {content}")
-            elif "type" in entry and entry["type"] == "llm_interaction":
-                # For detailed LLM interaction entries with role: assistant
-                if entry.get("role") == "assistant":
-                    context_parts.append(f"{i+1}. [Assistant] {entry.get('final_response', 'Processing step')}")
-                else:
-                    # For other llm_interaction entries without role
-                    context_parts.append(f"{i+1}. [System] {entry.get('final_response', 'Processing step')}")
-            else:
-                # Default fallback
-                context_parts.append(f"{i+1}. [System] {entry.get('content', 'Unknown entry')}")
-            
-        # Add temp memory (only for temporary state, not dialog history)
         if self.temp_memory:
             context_parts.append("\n=== TEMP MEMORY (Processing State) ===")
             for item in self.temp_memory:
                 context_parts.append(f"[{item.get('role', 'system')}] {item.get('content', '')}")
-                
         return "\n".join(context_parts)
         
     async def add_temp_memory(self, content: str, role: str = "system"):
-        """Add an item to temp memory (for temporary processing state)"""
-        self.temp_memory.append({
-            "id": generate_id(),
-            "content": content,
-            "role": role,
-            "timestamp": datetime.now().isoformat()
-        })
-        
-        # Keep only last 20 temp items
+        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()
         
-    # Core memory management methods
     async def get_core_memory_blocks(self) -> Dict[str, Any]:
-        """Get all core memory blocks"""
         return self.core_memory.get("blocks", {})
         
     async def get_core_memory_block(self, block_id: str) -> Optional[Dict[str, Any]]:
-        """Get a specific core memory block"""
-        blocks = self.core_memory.get("blocks", {})
-        return blocks.get(block_id)
+        return self.core_memory.get("blocks", {}).get(block_id)
         
-    async def create_core_memory_block(self, title: str, description: str, content: List[str]):
-        """Create a new core memory block with a generated 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 if content else []
+            "id": block_id, "title": title, "description": description, "content": content or []
         }
-        
         await self._save_core_memory()
-        return block_id  # Return the generated ID
+        return block_id
         
-    async def update_core_memory_block(self, block_id: str, title: str = None, description: str = None, content: List[str] = None):
-        """Update a core memory block"""
-        if "blocks" not in self.core_memory or block_id not in self.core_memory["blocks"]:
+    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")
-            
-        block = self.core_memory["blocks"][block_id]
-        if title is not None:
-            block["title"] = title
-        if description is not None:
-            block["description"] = description
-        if content is not None:
-            block["content"] = content
-            
+        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):
-        """Delete a core memory block"""
         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()
-            
-    async def add_to_core_memory_block(self, block_id: str, item: str):
-        """Add an item to a core memory block"""
-        if "blocks" not in self.core_memory or block_id not in self.core_memory["blocks"]:
-            raise ValueError(f"Block '{block_id}' not found")
-            
-        self.core_memory["blocks"][block_id]["content"].append(item)
-        await self._save_core_memory()
-        
-    async def remove_from_core_memory_block(self, block_id: str, index: int):
-        """Remove an item from a core memory block by index"""
-        if "blocks" not in self.core_memory or block_id not in self.core_memory["blocks"]:
-            raise ValueError(f"Block '{block_id}' not found")
-            
-        if 0 <= index < len(self.core_memory["blocks"][block_id]["content"]):
-            self.core_memory["blocks"][block_id]["content"].pop(index)
-            await self._save_core_memory()
-        else:
-            raise IndexError(f"Index {index} out of range for block '{block_id}'")
+            await self._save_core_memory()

neuro_simulator/agent/tools/__init__.py

@@ -1,4 +1 @@
-# agent/tools/__init__.py
-"""
-Tools module for the Neuro Simulator Agent
-"""
+# neuro_simulator.agent.tools package