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

neuro_simulator/agent/tools.py

@@ -0,0 +1,69 @@
+# agent/tools.py
+"""
+Tools that the Neuro Simulator Agent can use
+"""
+
+import json
+import asyncio
+from typing import Dict, Any
+from .memory import MemoryManager
+
+class ToolManager:
+    """Manages tools that the agent can use to interact with its memory"""
+    
+    def __init__(self, memory_manager: MemoryManager):
+        self.memory_manager = memory_manager
+        self.tools = {}
+        self._register_default_tools()
+        
+    def _register_default_tools(self):
+        """Register default tools for memory management"""
+        self.tools["update_mood"] = self._update_mood
+        self.tools["update_topic"] = self._update_topic
+        self.tools["update_viewer_count"] = self._update_viewer_count
+        self.tools["get_memory_state"] = self._get_memory_state
+        
+    async def _update_mood(self, mood: str) -> str:
+        """Update the agent's mood"""
+        await self.memory_manager.update_mutable_memory({"mood": mood})
+        return f"Mood updated to: {mood}"
+        
+    async def _update_topic(self, topic: str) -> str:
+        """Update the current topic"""
+        await self.memory_manager.update_mutable_memory({"current_topic": topic})
+        return f"Topic updated to: {topic}"
+        
+    async def _update_viewer_count(self, count: int) -> str:
+        """Update the viewer count"""
+        await self.memory_manager.update_mutable_memory({"viewer_count": count})
+        return f"Viewer count updated to: {count}"
+        
+    async def _get_memory_state(self) -> Dict[str, Any]:
+        """Get the current state of all memory"""
+        return {
+            "immutable": self.memory_manager.immutable_memory,
+            "mutable": self.memory_manager.mutable_memory,
+            "conversation_history_length": len(self.memory_manager.conversation_history)
+        }
+        
+    def get_tool_descriptions(self) -> str:
+        """Get descriptions of all available tools"""
+        descriptions = [
+            "Available tools:",
+            "1. update_mood(mood: string) - Update the agent's mood",
+            "2. update_topic(topic: string) - Update the current topic of conversation",
+            "3. update_viewer_count(count: integer) - Update the viewer count",
+            "4. get_memory_state() - Get the current state of all memory"
+        ]
+        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 in self.tools:
+            try:
+                result = await self.tools[tool_name](**params)
+                return result
+            except Exception as e:
+                return f"Error executing tool '{tool_name}': {str(e)}"
+        else:
+            return f"Tool '{tool_name}' not found"

neuro_simulator/builtin_agent.py

@@ -0,0 +1,83 @@
+# backend/builtin_agent.py
+"""Builtin agent module for Neuro Simulator"""
+
+import asyncio
+from typing import List, Dict, Union
+from .config import config_manager
+import time
+from datetime import datetime
+
+# Global variables
+local_agent = None
+
+async def initialize_builtin_agent():
+    """Initialize the builtin agent"""
+    global local_agent
+    
+    try:
+        from .agent.core import Agent as LocalAgentImport
+        from .stream_manager import live_stream_manager
+        
+        local_agent = LocalAgentImport(working_dir=live_stream_manager._working_dir)
+        await local_agent.initialize()
+    except Exception as e:
+        print(f"初始化本地 Agent 失败: {e}")
+        import traceback
+        traceback.print_exc()
+        local_agent = None
+
+async def reset_builtin_agent_memory():
+    """Reset the builtin agent's memory"""
+    global local_agent
+    
+    if local_agent is not None:
+        await local_agent.reset_all_memory()
+    else:
+        print("错误: 本地 Agent 未初始化，无法重置记忆。")
+
+async def clear_builtin_agent_temp_memory():
+    """Clear the builtin agent's temp memory"""
+    global local_agent
+    
+    if local_agent is not None:
+        # Reset only temp memory
+        await local_agent.memory_manager.reset_temp_memory()
+    else:
+        print("错误: 本地 Agent 未初始化，无法清空临时记忆。")
+
+async def clear_builtin_agent_context():
+    """Clear the builtin agent's context (dialog history)"""
+    global local_agent
+    
+    if local_agent is not None:
+        # Reset only context
+        await local_agent.memory_manager.reset_context()
+        
+        # Send context update via WebSocket to notify frontend
+        from .websocket_manager import connection_manager
+        await connection_manager.broadcast({
+            "type": "agent_context",
+            "action": "update",
+            "messages": []
+        })
+    else:
+        print("错误: 本地 Agent 未初始化，无法清空上下文。")
+
+async def get_builtin_response(chat_messages: list[dict]) -> dict:
+    """Get response from the builtin agent with detailed processing information"""
+    global local_agent
+    
+    if local_agent is not None:
+        response = await local_agent.process_messages(chat_messages)
+        
+        # Return the response directly without adding processing details to temp memory
+        return response
+    else:
+        print("错误: 本地 Agent 未初始化，无法获取响应。")
+        return {
+            "input_messages": chat_messages,
+            "llm_response": "",
+            "tool_executions": [],
+            "final_response": "Someone tell Vedal there is a problem with my AI.",
+            "error": "Agent not initialized"
+        }

neuro_simulator/cli.py

@@ -6,6 +6,7 @@ import sys
 import shutil
 from pathlib import Path
 
+
 def main():
     parser = argparse.ArgumentParser(description="Neuro-Simulator Server")
     parser.add_argument("-D", "--dir", help="Working directory containing config.yaml")
@@ -98,6 +99,49 @@ def main():
         except Exception as e:
             print(f"Warning: Could not copy media folder from package: {e}")
     
+    # Handle agent/memory directory and example JSON files
+    agent_memory_dir = work_dir / "agent" / "memory"
+    agent_memory_dir.mkdir(parents=True, exist_ok=True)
+    
+    # List of example JSON files to copy
+    example_memory_files = [
+        "context.json",
+        "core_memory.json",
+        "dialog_history.json",
+        "init_memory.json"
+    ]
+    
+    # Copy each example memory file if it doesn't exist
+    for filename in example_memory_files:
+        target_path = agent_memory_dir / filename
+        if not target_path.exists():
+            try:
+                # Try pkg_resources first (for installed packages)
+                try:
+                    import pkg_resources
+                    package_example_path = pkg_resources.resource_filename('neuro_simulator', f'agent/memory/{filename}')
+                    if os.path.exists(package_example_path):
+                        shutil.copy(package_example_path, target_path)
+                        print(f"Created {target_path} from package example")
+                    else:
+                        # Fallback to relative path (for development mode)
+                        dev_example_path = Path(__file__).parent / "agent" / "memory" / filename
+                        if dev_example_path.exists():
+                            shutil.copy(dev_example_path, target_path)
+                            print(f"Created {target_path} from development example")
+                        else:
+                            print(f"Warning: {filename} not found in package or development folder")
+                except Exception:
+                    # Fallback to relative path (for development mode)
+                    dev_example_path = Path(__file__).parent / "agent" / "memory" / filename
+                    if dev_example_path.exists():
+                        shutil.copy(dev_example_path, target_path)
+                        print(f"Created {target_path} from development example")
+                    else:
+                        print(f"Warning: {filename} not found in package or development folder")
+            except Exception as e:
+                print(f"Warning: Could not copy {filename} from package: {e}")
+    
     # Now check for required files and handle errors appropriately
     errors = []
     
@@ -128,5 +172,6 @@ def main():
         from neuro_simulator.main import run_server
         run_server(args.host, args.port)
 
+
 if __name__ == "__main__":
     main()

neuro_simulator/config.py

@@ -23,73 +23,61 @@ class ApiKeysSettings(BaseModel):
     azure_speech_region: Optional[str] = None
 
 class StreamMetadataSettings(BaseModel):
-    streamer_nickname: str = "vedal987"
-    stream_title: str = "neuro-sama is here for u all"
-    stream_category: str = "谈天说地"
-    stream_tags: List[str] = Field(default_factory=lambda: ["Vtuber"])
+    streamer_nickname: str
+    stream_title: str
+    stream_category: str
+    stream_tags: List[str] = Field(default_factory=list)
+
+class AgentSettings(BaseModel):
+    """Settings for the built-in agent"""
+    agent_provider: str
+    agent_model: str
 
 class NeuroBehaviorSettings(BaseModel):
-    input_chat_sample_size: int = 10
-    post_speech_cooldown_sec: float = 1.0
-    initial_greeting: str = "The stream has just started. Greet your audience and say hello!"
+    input_chat_sample_size: int
+    post_speech_cooldown_sec: float
+    initial_greeting: str
 
 class AudienceSimSettings(BaseModel):
-    llm_provider: str = "gemini"
-    gemini_model: str = "gemini-1.5-flash-latest"
-    openai_model: str = "gpt-3.5-turbo"
-    llm_temperature: float = 1.0
-    chat_generation_interval_sec: int = 2
-    chats_per_batch: int = 3
-    max_output_tokens: int = 300
-    prompt_template: str = Field(default="""
-You are a Twitch live stream viewer. Your goal is to generate short, realistic, and relevant chat messages.
-The streamer, Neuro-Sama, just said the following:
----
-{neuro_speech}
----
-Based on what Neuro-Sama said, generate a variety of chat messages. Your messages should be:
-- Directly reacting to her words.
-- Asking follow-up questions.
-- Using relevant Twitch emotes (like LUL, Pog, Kappa, etc.).
-- General banter related to the topic.
-- Short and punchy, like real chat messages.
-Do NOT act as the streamer. Do NOT generate full conversations.
-Generate exactly {num_chats_to_generate} distinct chat messages. Each message must be prefixed with a DIFFERENT fictional username, like 'ChatterBoy: message text', 'EmoteFan: message text'.
-""")
-    username_blocklist: List[str] = Field(default_factory=lambda: ["ChatterBoy", "EmoteFan", "Username", "User"])
-    username_pool: List[str] = Field(default_factory=lambda: [
-        "ChatterBox", "EmoteLord", "QuestionMark", "StreamFan", "PixelPundit",
-        "CodeSage", "DataDiver", "ByteBard", "LogicLover", "AI_Enthusiast"
-    ])
+    llm_provider: str
+    gemini_model: str
+    openai_model: str
+    llm_temperature: float
+    chat_generation_interval_sec: int
+    chats_per_batch: int
+    max_output_tokens: int
+    prompt_template: str = Field(default="")
+    username_blocklist: List[str] = Field(default_factory=list)
+    username_pool: List[str] = Field(default_factory=list)
 
 class TTSSettings(BaseModel):
-    voice_name: str = "en-US-AshleyNeural"
-    voice_pitch: float = 1.25
+    voice_name: str
+    voice_pitch: float
 
 class PerformanceSettings(BaseModel):
-    neuro_input_queue_max_size: int = 200
-    audience_chat_buffer_max_size: int = 500
-    initial_chat_backlog_limit: int = 50
+    neuro_input_queue_max_size: int
+    audience_chat_buffer_max_size: int
+    initial_chat_backlog_limit: int
 
 class ServerSettings(BaseModel):
-    host: str = "127.0.0.1"
-    port: int = 8000
-    client_origins: List[str] = Field(default_factory=lambda: ["http://localhost:5173", "http://127.0.0.1:5173"])
+    host: str
+    port: int
+    client_origins: List[str] = Field(default_factory=list)
     panel_password: Optional[str] = None
 
 class AppSettings(BaseModel):
     api_keys: ApiKeysSettings = Field(default_factory=ApiKeysSettings)
-    stream_metadata: StreamMetadataSettings = Field(default_factory=StreamMetadataSettings)
-    neuro_behavior: NeuroBehaviorSettings = Field(default_factory=NeuroBehaviorSettings)
-    audience_simulation: AudienceSimSettings = Field(default_factory=AudienceSimSettings)
-    tts: TTSSettings = Field(default_factory=TTSSettings)
-    performance: PerformanceSettings = Field(default_factory=PerformanceSettings)
-    server: ServerSettings = Field(default_factory=ServerSettings)
+    stream_metadata: StreamMetadataSettings
+    agent_type: str  # 可选 "letta" 或 "builtin"
+    agent: AgentSettings
+    neuro_behavior: NeuroBehaviorSettings
+    audience_simulation: AudienceSimSettings
+    tts: TTSSettings
+    performance: PerformanceSettings
+    server: ServerSettings
 
 # --- 2. 加载和管理配置的逻辑 ---
 
-CONFIG_FILE_PATH = "config.yaml"
-
 def _deep_update(source: dict, overrides: dict) -> dict:
     """
     Recursively update a dictionary.
@@ -118,59 +106,209 @@ class ConfigManager:
         self._update_callbacks = []
         self._initialized = True
 
+    def _get_config_file_path(self) -> str:
+        """获取配置文件路径"""
+        import sys
+        import argparse
+        
+        # 解析命令行参数以获取工作目录
+        parser = argparse.ArgumentParser()
+        parser.add_argument('--dir', '-D', type=str, help='Working directory')
+        # 只解析已知参数，避免干扰其他模块的参数解析
+        args, _ = parser.parse_known_args()
+        
+        if args.dir:
+            # 如果指定了工作目录，使用该目录下的配置文件
+            config_path = os.path.join(args.dir, "config.yaml")
+        else:
+            # 默认使用 ~/.config/neuro-simulator 目录
+            config_path = os.path.join(os.path.expanduser("~"), ".config", "neuro-simulator", "config.yaml")
+            
+        return config_path
+
     def _load_config_from_yaml(self) -> dict:
-        if not os.path.exists(CONFIG_FILE_PATH):
-            logging.warning(f"{CONFIG_FILE_PATH} not found. Using default settings. You can create it from config.yaml.example.")
-            return {}
+        # 获取配置文件路径
+        config_path = self._get_config_file_path()
+        
+        # 检查配置文件是否存在
+        if not os.path.exists(config_path):
+            raise FileNotFoundError(f"Configuration file '{config_path}' not found. "
+                                  "Please create it from config.yaml.example.")
+        
         try:
-            with open(CONFIG_FILE_PATH, 'r', encoding='utf-8') as f:
-                return yaml.safe_load(f) or {}
+            with open(config_path, 'r', encoding='utf-8') as f:
+                content = yaml.safe_load(f)
+                if content is None:
+                    raise ValueError(f"Configuration file '{config_path}' is empty.")
+                return content
         except Exception as e:
-            logging.error(f"Error loading or parsing {CONFIG_FILE_PATH}: {e}")
-            return {}
+            logging.error(f"Error loading or parsing {config_path}: {e}")
+            raise
 
     def _load_settings(self) -> AppSettings:
         yaml_config = self._load_config_from_yaml()
+        
         base_settings = AppSettings.model_validate(yaml_config)
 
         # 检查关键配置项
-        missing_keys = []
-        if not base_settings.api_keys.letta_token:
-            missing_keys.append("api_keys.letta_token")
-        if not base_settings.api_keys.neuro_agent_id:
-            missing_keys.append("api_keys.neuro_agent_id")
+        if base_settings.agent_type == "letta":
+            missing_keys = []
+            if not base_settings.api_keys.letta_token:
+                missing_keys.append("api_keys.letta_token")
+            if not base_settings.api_keys.neuro_agent_id:
+                missing_keys.append("api_keys.neuro_agent_id")
             
-        if missing_keys:
-            raise ValueError(f"Critical config missing in config.yaml: {', '.join(missing_keys)}. "
-                           f"Please check your config.yaml file against config.yaml.example.")
+            if missing_keys:
+                raise ValueError(f"Critical config missing in config.yaml for letta agent: {', '.join(missing_keys)}. "
+                               f"Please check your config.yaml file against config.yaml.example.")
 
         logging.info("Configuration loaded successfully.")
         return base_settings
 
     def save_settings(self):
-        """Saves the current configuration to config.yaml."""
+        """Saves the current configuration to config.yaml while preserving comments and formatting."""
         try:
-            # 1. Get the current settings from memory
+            # 获取配置文件路径
+            config_file_path = self._get_config_file_path()
+            
+            # 检查配置文件目录是否存在，如果不存在则创建
+            config_dir = os.path.dirname(config_file_path)
+            if config_dir and not os.path.exists(config_dir):
+                os.makedirs(config_dir, exist_ok=True)
+            
+            # 1. Read the existing config file as text to preserve comments and formatting
+            with open(config_file_path, 'r', encoding='utf-8') as f:
+                config_lines = f.readlines()
+
+            # 2. Get the current settings from memory
             config_to_save = self.settings.model_dump(mode='json', exclude={'api_keys'})
 
-            # 2. Read the existing config on disk to get the api_keys that should be preserved.
+            # 3. Read the existing config on disk to get the api_keys that should be preserved.
             existing_config = self._load_config_from_yaml()
             if 'api_keys' in existing_config:
-                # 3. Add the preserved api_keys block back to the data to be saved.
+                # 4. Add the preserved api_keys block back to the data to be saved.
                 config_to_save['api_keys'] = existing_config['api_keys']
 
-            # 4. Rebuild the dictionary to maintain the original order from the Pydantic model.
-            final_config = {}
-            for field_name in AppSettings.model_fields:
-                if field_name in config_to_save:
-                    final_config[field_name] = config_to_save[field_name]
+            # 5. Update the config lines while preserving comments and formatting
+            updated_lines = self._update_config_lines(config_lines, config_to_save)
 
-            # 5. Write the final, correctly ordered configuration to the file.
-            with open(CONFIG_FILE_PATH, 'w', encoding='utf-8') as f:
-                yaml.dump(final_config, f, allow_unicode=True, sort_keys=False, indent=2)
-            logging.info(f"Configuration saved to {CONFIG_FILE_PATH}")
+            # 6. Write the updated lines back to the file
+            with open(config_file_path, 'w', encoding='utf-8') as f:
+                f.writelines(updated_lines)
+                
+            logging.info(f"Configuration saved to {config_file_path}")
         except Exception as e:
-            logging.error(f"Failed to save configuration to {CONFIG_FILE_PATH}: {e}")
+            logging.error(f"Failed to save configuration to {config_file_path}: {e}")
+
+    def _update_config_lines(self, lines, config_data):
+        """Updates config lines with new values while preserving comments and formatting."""
+        updated_lines = []
+        i = 0
+        while i < len(lines):
+            line = lines[i]
+            stripped_line = line.strip()
+            
+            # Skip empty lines and comments
+            if not stripped_line or stripped_line.startswith('#'):
+                updated_lines.append(line)
+                i += 1
+                continue
+            
+            # Check if this line is a top-level key
+            if ':' in stripped_line and not stripped_line.startswith(' ') and not stripped_line.startswith('\t'):
+                key = stripped_line.split(':')[0].strip()
+                if key in config_data:
+                    value = config_data[key]
+                    if isinstance(value, dict):
+                        # Handle nested dictionaries
+                        updated_lines.append(line)
+                        i += 1
+                        # Process nested items
+                        i = self._update_nested_config_lines(lines, updated_lines, i, value, 1)
+                    else:
+                        # Handle simple values
+                        indent = len(line) - len(line.lstrip())
+                        if isinstance(value, str) and '\n' in value:
+                            # Handle multiline strings
+                            updated_lines.append(' ' * indent + f"{key}: |\n")
+                            for subline in value.split('\n'):
+                                updated_lines.append(' ' * (indent + 2) + subline + '\n')
+                        elif isinstance(value, list):
+                            # Handle lists
+                            updated_lines.append(' ' * indent + f"{key}:\n")
+                            for item in value:
+                                updated_lines.append(' ' * (indent + 2) + f"- {item}\n")
+                        else:
+                            # Handle simple values
+                            updated_lines.append(' ' * indent + f"{key}: {value}\n")
+                        i += 1
+                else:
+                    updated_lines.append(line)
+                    i += 1
+            else:
+                updated_lines.append(line)
+                i += 1
+                
+        return updated_lines
+
+    def _update_nested_config_lines(self, lines, updated_lines, start_index, config_data, depth):
+        """Recursively updates nested config lines."""
+        i = start_index
+        indent_size = depth * 2
+        
+        while i < len(lines):
+            line = lines[i]
+            stripped_line = line.strip()
+            
+            # Check indentation level
+            current_indent = len(line) - len(line.lstrip())
+            
+            # If we've moved to a less indented section, we're done with this nested block
+            if current_indent < indent_size:
+                break
+                
+            # Skip empty lines and comments
+            if not stripped_line or stripped_line.startswith('#'):
+                updated_lines.append(line)
+                i += 1
+                continue
+            
+            # Check if this line is a key at the current nesting level
+            if current_indent == indent_size and ':' in stripped_line:
+                key = stripped_line.split(':')[0].strip()
+                if key in config_data:
+                    value = config_data[key]
+                    if isinstance(value, dict):
+                        # Handle nested dictionaries
+                        updated_lines.append(line)
+                        i += 1
+                        i = self._update_nested_config_lines(lines, updated_lines, i, value, depth + 1)
+                    else:
+                        # Handle simple values
+                        if isinstance(value, str) and '\n' in value:
+                            # Handle multiline strings
+                            updated_lines.append(' ' * indent_size + f"{key}: |\n")
+                            for subline in value.split('\n'):
+                                updated_lines.append(' ' * (indent_size + 2) + subline + '\n')
+                            i += 1
+                        elif isinstance(value, list):
+                            # Handle lists
+                            updated_lines.append(' ' * indent_size + f"{key}:\n")
+                            for item in value:
+                                updated_lines.append(' ' * (indent_size + 2) + f"- {item}\n")
+                            i += 1
+                        else:
+                            # Handle simple values
+                            updated_lines.append(' ' * indent_size + f"{key}: {value}\n")
+                            i += 1
+                else:
+                    updated_lines.append(line)
+                    i += 1
+            else:
+                updated_lines.append(line)
+                i += 1
+                
+        return i
 
     def register_update_callback(self, callback):
         """Registers a callback function to be called on settings update."""

neuro_simulator/config.yaml.example

@@ -39,6 +39,20 @@ stream_metadata:
   # 直播标签 - 用于描述直播内容的标签列表
   stream_tags: ["Vtuber", "AI", "Cute", "English", "Gremlin", "catgirl"]
 
+# --- Agent 类型设置 ---
+# 选择一个用来模拟Neuro的Agent提供方
+# - "letta": 使用Letta作为Agent，需要在上方配置Letta API相关信息
+# - "builtin": 使用内建Agent，请在下方填写配置
+agent_type: "builtin"
+
+# --- 内建Agent设置 ---
+# 仅当agent_type设置为"builtin"时生效
+agent:
+  # Agent的API服务商，支持"gemini"和"openai"，API Key配置使用顶部填写的值
+  agent_provider: "gemini"
+  # Agent使用的模型，切换gemini/openai时记得更改
+  agent_model: "gemini-2.5-flash-lite"
+
 # --- Neuro 行为与节奏控制 ---
 neuro_behavior:
   # 输入聊天采样数量 - 每次生成 Neuro 回复时从观众聊天中采样的消息数量，不建议太长
@@ -60,7 +74,7 @@ audience_simulation:
   gemini_model: "gemma-3-27b-it"
   
   # OpenAI 模型 - 使用 OpenAI 服务时的具体模型名称
-  # 使用 SiliconFlow 等第三方服务时可以尝试 THUDM/GLM-4-9B-0414 等模型
+  # 推荐使用SiliconFlow，9B以下模型免费不限量调用（注意TPM限制）
   openai_model: "THUDM/GLM-4-9B-0414"
   
   # LLM 温度 - 控制 AI 生成内容的随机性，值越高越随机（0-2之间）
@@ -140,4 +154,4 @@ server:
   # 客户端来源 - 允许跨域访问的客户端地址列表，非本机访问时记得添加一下
   client_origins:
     - "http://localhost:5173"
-    - "http://127.0.0.1:5173"
+    - "http://127.0.0.1:5173"