neuro-simulator 0.3.0__tar.gz → 0.3.2__tar.gz

{neuro_simulator-0.3.0 → neuro_simulator-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuro_simulator
-Version: 0.3.0
+Version: 0.3.2
 Summary: Neuro Simulator Server
 Author-email: Moha-Master <hongkongreporter@outlook.com>
 License-Expression: MIT
@@ -69,7 +69,7 @@ neuro_simulator/
 │   ├── memory/          # 记忆管理模块
 │   │   ├── __init__.py
 │   │   ├── manager.py   # 记忆管理器
-│   │   ├── context.json # 上下文记忆文件
+│   │   ├── chat_history.json # 上下文记忆文件
 │   │   ├── core_memory.json # 核心记忆文件
 │   │   ├── init_memory.json # 初始化记忆文件
 │   │   └── temp_memory.json # 临时记忆文件
@@ -109,7 +109,7 @@ working_dir_example/     # 工作目录结构，请将这个目录重命名和
 ├── config.yaml.example  # 自动生成的配置文件模板，必须手动重命名和填写
 └── agent/               # Agent相关文件夹
     └── memory/          # Agent记忆文件夹
-        ├── context.json     # 上下文记忆文件
+        ├── chat_history.json     # 上下文记忆文件
         ├── core_memory.json # 核心记忆文件
         ├── init_memory.json # 初始化记忆文件
         └── temp_memory.json # 临时记忆文件
@@ -191,7 +191,6 @@ neuro -D /path/to/your/config -H 0.0.0.0 -P 8080
 - `/api/configs/*` - 配置管理接口（获取/更新/重载配置）
   - `api_keys` `server` 等敏感配置项无法从接口获取和修改
 - `/api/logs` - 日志获取接口
-- `/api/tts/synthesize` - TTS 合成接口
 - `/api/system/health` - 健康检查接口
 - `/ws/stream` - 客户端使用的直播接口
 - `/ws/admin` - 日志和内建 Agent的 Context 流接口

{neuro_simulator-0.3.0 → neuro_simulator-0.3.2}/README.md

@@ -32,7 +32,7 @@ neuro_simulator/
 │   ├── memory/          # 记忆管理模块
 │   │   ├── __init__.py
 │   │   ├── manager.py   # 记忆管理器
-│   │   ├── context.json # 上下文记忆文件
+│   │   ├── chat_history.json # 上下文记忆文件
 │   │   ├── core_memory.json # 核心记忆文件
 │   │   ├── init_memory.json # 初始化记忆文件
 │   │   └── temp_memory.json # 临时记忆文件
@@ -72,7 +72,7 @@ working_dir_example/     # 工作目录结构，请将这个目录重命名和
 ├── config.yaml.example  # 自动生成的配置文件模板，必须手动重命名和填写
 └── agent/               # Agent相关文件夹
     └── memory/          # Agent记忆文件夹
-        ├── context.json     # 上下文记忆文件
+        ├── chat_history.json     # 上下文记忆文件
         ├── core_memory.json # 核心记忆文件
         ├── init_memory.json # 初始化记忆文件
         └── temp_memory.json # 临时记忆文件
@@ -154,7 +154,6 @@ neuro -D /path/to/your/config -H 0.0.0.0 -P 8080
 - `/api/configs/*` - 配置管理接口（获取/更新/重载配置）
   - `api_keys` `server` 等敏感配置项无法从接口获取和修改
 - `/api/logs` - 日志获取接口
-- `/api/tts/synthesize` - TTS 合成接口
 - `/api/system/health` - 健康检查接口
 - `/ws/stream` - 客户端使用的直播接口
 - `/ws/admin` - 日志和内建 Agent的 Context 流接口

neuro_simulator-0.3.2/neuro_simulator/agent/core.py

@@ -0,0 +1,234 @@
+# neuro_simulator/agent/core.py
+"""
+Core module for the Neuro Simulator's built-in agent.
+Implements a dual-LLM "Actor/Thinker" architecture for responsive interaction
+and asynchronous memory consolidation.
+"""
+
+import asyncio
+import json
+import logging
+import re
+from pathlib import Path
+from typing import Any, Dict, List
+
+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
+
+# Create a logger for the agent
+agent_logger = logging.getLogger("neuro_agent")
+agent_logger.setLevel(logging.DEBUG)
+
+# Configure agent logging to use the shared queue
+def configure_agent_logging():
+    """Configure agent logging to use the shared agent_log_queue."""
+    if agent_logger.hasHandlers():
+        agent_logger.handlers.clear()
+    
+    agent_queue_handler = QueueLogHandler(agent_log_queue)
+    formatter = logging.Formatter('%(asctime)s - [%(name)-32s] - %(levelname)-8s - %(message)s', datefmt='%H:%M:%S')
+    agent_queue_handler.setFormatter(formatter)
+    agent_logger.addHandler(agent_queue_handler)
+    agent_logger.propagate = False
+    agent_logger.info("Agent logging configured to use agent_log_queue.")
+
+configure_agent_logging()
+
+class Agent:
+    """
+    Main Agent class implementing the Actor/Thinker model.
+    - The "Neuro" part (Actor) handles real-time interaction.
+    - The "Memory" part (Thinker) handles background memory consolidation.
+    """
+    
+    def __init__(self, working_dir: str = None):
+        self.memory_manager = MemoryManager(working_dir)
+        self.tool_manager = ToolManager(self.memory_manager)
+        
+        # Dual LLM clients
+        self.neuro_llm = LLMClient()
+        self.memory_llm = LLMClient()
+        
+        self._initialized = False
+        self.turn_counter = 0
+        self.reflection_threshold = 3  # Trigger reflection every 3 turns
+        
+        agent_logger.info("Agent instance created with dual-LLM architecture.")
+        agent_logger.debug(f"Agent working directory: {working_dir}")
+        
+    async def initialize(self):
+        """Initialize the agent, loading any persistent memory."""
+        if not self._initialized:
+            agent_logger.info("Initializing agent memory manager...")
+            await self.memory_manager.initialize()
+            self._initialized = True
+            agent_logger.info("Agent initialized successfully.")
+        
+    async def reset_all_memory(self):
+        """Reset all agent memory types."""
+        await self.memory_manager.reset_temp_memory()
+        await self.memory_manager.reset_chat_history()
+        agent_logger.info("All agent memory has been reset.")
+
+    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()
+        
+        # Format Core Memory from blocks
+        core_memory_blocks = await self.memory_manager.get_core_memory_blocks()
+        core_memory_parts = []
+        if core_memory_blocks:
+            for block_id, block in core_memory_blocks.items():
+                core_memory_parts.append(f"\nBlock: {block.get('title', '')} ({block_id})")
+                core_memory_parts.append(f"Description: {block.get('description', '')}")
+                content_items = block.get("content", [])
+                if content_items:
+                    core_memory_parts.append("Content:")
+                    for item in content_items:
+                        core_memory_parts.append(f"  - {item}")
+        core_memory_text = "\n".join(core_memory_parts) if core_memory_parts else "Not set."
+
+        # Format Temp Memory
+        temp_memory_items = self.memory_manager.temp_memory
+        temp_memory_text = "\n".join(
+            [f"[{item.get('role', 'system')}] {item.get('content', '')}" for item in temp_memory_items]
+        ) if temp_memory_items else "Empty."
+
+        recent_history = await self.memory_manager.get_recent_chat(entries=10)
+        
+        user_messages_text = "\n".join([f"{msg['username']}: {msg['text']}" for msg in messages])
+        recent_history_text = "\n".join([f"{msg['role']}: {msg['content']}" for msg in recent_history])
+
+        return prompt_template.format(
+            tool_descriptions=tool_descriptions,
+            core_memory=core_memory_text,
+            temp_memory=temp_memory_text,
+            recent_history=recent_history_text,
+            user_messages=user_messages_text
+        )
+
+    async def _build_memory_prompt(self, conversation_history: List[Dict[str, str]]) -> str:
+        """Builds the prompt for the Memory (Thinker) LLM."""
+        template_path = Path(self.memory_manager.memory_dir).parent / "memory_prompt.txt"
+        with open(template_path, 'r', encoding='utf-8') as f:
+            prompt_template = f.read()
+        
+        history_text = "\n".join([f"{msg['role']}: {msg['content']}" for msg in conversation_history])
+        
+        return prompt_template.format(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)
+            if not match:
+                agent_logger.warning(f"No valid JSON tool call block found in response: {response_text}")
+                return []
+
+            json_str = match.group(1) or match.group(2)
+            tool_calls = json.loads(json_str)
+            
+            if isinstance(tool_calls, list):
+                return tool_calls
+            return []
+        except json.JSONDecodeError as e:
+            agent_logger.error(f"Failed to decode JSON from LLM response: {e}\nResponse text: {response_text}")
+            return []
+        except Exception as e:
+            agent_logger.error(f"An unexpected error occurred while parsing tool calls: {e}")
+            return []
+
+    async def _execute_tool_calls(self, tool_calls: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """Executes a list of parsed tool calls."""
+        execution_results = []
+        final_response = ""
+        for tool_call in tool_calls:
+            tool_name = tool_call.get("name")
+            params = tool_call.get("params", {})
+            if not tool_name:
+                continue
+
+            agent_logger.info(f"Executing tool: {tool_name} with params: {params}")
+            try:
+                result = await self.tool_manager.execute_tool(tool_name, params)
+                execution_results.append({"name": tool_name, "params": params, "result": result})
+                if tool_name == "speak":
+                    final_response = params.get("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)})
+        
+        return {"tool_executions": execution_results, "final_response": final_response}
+
+    async def process_and_respond(self, messages: List[Dict[str, str]]) -> Dict[str, Any]:
+        """
+        The main entry point for the "Neuro" (Actor) flow.
+        Handles real-time interaction and triggers background reflection.
+        """
+        await self.initialize()
+        agent_logger.info(f"Processing {len(messages)} messages in Actor flow.")
+
+        # Add user messages to context
+        for msg in messages:
+            await self.memory_manager.add_chat_entry("user", f"{msg['username']}: {msg['text']}")
+
+        # Build prompt and get response from Neuro LLM
+        prompt = await self._build_neuro_prompt(messages)
+        response_text = await self.neuro_llm.generate(prompt)
+        agent_logger.debug(f"Neuro LLM raw response: {response_text[:150] if response_text else 'None'}...")
+
+        # Parse and execute tools
+        tool_calls = self._parse_tool_calls(response_text)
+        processing_result = await self._execute_tool_calls(tool_calls)
+
+        # Add agent's response to context
+        if processing_result["final_response"]:
+            await self.memory_manager.add_chat_entry("assistant", processing_result["final_response"])
+
+        # Update dashboard/UI
+        final_context = await self.memory_manager.get_recent_chat()
+        # Broadcast to stream clients
+        await connection_manager.broadcast({"type": "agent_context", "action": "update", "messages": final_context})
+        # Broadcast to admin clients (Dashboard)
+        await connection_manager.broadcast_to_admins({"type": "agent_context", "action": "update", "messages": final_context})
+
+        # Handle reflection trigger
+        self.turn_counter += 1
+        if self.turn_counter >= self.reflection_threshold:
+            agent_logger.info(f"Reflection threshold reached ({self.turn_counter}/{self.reflection_threshold}). Scheduling background reflection.")
+            history_for_reflection = await self.memory_manager.get_recent_chat(entries=self.reflection_threshold * 2) # Get a bit more context
+            asyncio.create_task(self.reflect_on_context(history_for_reflection))
+            self.turn_counter = 0
+
+        agent_logger.info("Actor flow completed.")
+        return processing_result
+
+    async def reflect_on_context(self, conversation_history: List[Dict[str, str]]):
+        """
+        The main entry point for the "Memory" (Thinker) flow.
+        Runs in the background to consolidate memories.
+        """
+        agent_logger.info("Thinker flow started: Reflecting on recent context.")
+        
+        prompt = await self._build_memory_prompt(conversation_history)
+        response_text = await self.memory_llm.generate(prompt)
+        agent_logger.debug(f"Memory LLM raw response: {response_text[:150] if response_text else 'None'}...")
+
+        tool_calls = self._parse_tool_calls(response_text)
+        if not tool_calls:
+            agent_logger.info("Thinker flow: No memory operations were suggested by the LLM.")
+            return
+
+        agent_logger.info(f"Thinker flow: Executing {len(tool_calls)} memory operations.")
+        await self._execute_tool_calls(tool_calls)
+        agent_logger.info("Thinker flow completed, memory has been updated.")

{neuro_simulator-0.3.0 → neuro_simulator-0.3.2}/neuro_simulator/agent/memory/manager.py

@@ -31,12 +31,12 @@ class MemoryManager:
         
         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.chat_history_file = os.path.join(self.memory_dir, "chat_history.json")
         self.temp_memory_file = os.path.join(self.memory_dir, "temp_memory.json")
         
         self.init_memory: Dict[str, Any] = {}
         self.core_memory: Dict[str, Any] = {}
-        self.context_history: List[Dict[str, Any]] = []
+        self.chat_history: List[Dict[str, Any]] = []
         self.temp_memory: List[Dict[str, Any]] = []
         
     async def initialize(self):
@@ -61,12 +61,12 @@ class MemoryManager:
             self.core_memory = {"blocks": {}}
             await self._save_core_memory()
             
-        # Load context history
-        if os.path.exists(self.context_file):
-            with open(self.context_file, 'r', encoding='utf-8') as f:
-                self.context_history = json.load(f)
+        # Load chat history
+        if os.path.exists(self.chat_history_file):
+            with open(self.chat_history_file, 'r', encoding='utf-8') as f:
+                self.chat_history = json.load(f)
         else:
-            self.context_history = []
+            self.chat_history = []
             
         # Load temp memory
         if os.path.exists(self.temp_memory_file):
@@ -89,20 +89,20 @@ class MemoryManager:
         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):
-        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_chat_history(self):
+        with open(self.chat_history_file, 'w', encoding='utf-8') as f:
+            json.dump(self.chat_history, f, ensure_ascii=False, indent=2)
             
     async def _save_temp_memory(self):
         with open(self.temp_memory_file, 'w', encoding='utf-8') as f:
             json.dump(self.temp_memory, f, ensure_ascii=False, indent=2)
             
-    async def add_context_entry(self, role: str, content: str):
+    async def add_chat_entry(self, role: str, content: str):
         entry = {"id": generate_id(), "role": role, "content": content, "timestamp": datetime.now().isoformat()}
-        self.context_history.append(entry)
-        await self._save_context()
+        self.chat_history.append(entry)
+        await self._save_chat_history()
         
-    async def add_detailed_context_entry(self, input_messages: List[Dict[str, str]], 
+    async def add_detailed_chat_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):
@@ -112,25 +112,25 @@ class MemoryManager:
             "timestamp": datetime.now().isoformat()
         }
         if entry_id:
-            for entry in self.context_history:
+            for entry in self.chat_history:
                 if entry.get("id") == entry_id:
                     entry.update(update_data)
-                    await self._save_context()
+                    await self._save_chat_history()
                     return entry_id
         
         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()
+        self.chat_history.append(new_entry)
+        await self._save_chat_history()
         return new_entry["id"]
         
-    async def get_recent_context(self, entries: int = 10) -> List[Dict[str, Any]]:
-        return self.context_history[-entries:]
+    async def get_recent_chat(self, entries: int = 10) -> List[Dict[str, Any]]:
+        return self.chat_history[-entries:]
         
-    async def get_detailed_context_history(self) -> List[Dict[str, Any]]:
-        return self.context_history
+    async def get_detailed_chat_history(self) -> List[Dict[str, Any]]:
+        return self.chat_history
         
     async def get_last_agent_response(self) -> Optional[str]:
-        for entry in reversed(self.context_history):
+        for entry in reversed(self.chat_history):
             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"]:
@@ -141,9 +141,9 @@ class MemoryManager:
                     return content
         return None
         
-    async def reset_context(self):
-        self.context_history = []
-        await self._save_context()
+    async def reset_chat_history(self):
+        self.chat_history = []
+        await self._save_chat_history()
         
     async def reset_temp_memory(self):
         """Reset temp memory to a default empty state."""

neuro_simulator-0.3.2/neuro_simulator/api/stream.py

@@ -0,0 +1 @@
+# This file is now empty as all stream control API endpoints have been migrated to WebSockets.

neuro_simulator-0.3.2/neuro_simulator/api/system.py

@@ -0,0 +1,63 @@
+# neuro_simulator/api/system.py
+"""API endpoints for system, config, and utility functions."""
+
+from fastapi import APIRouter, Depends, HTTPException, status, Request
+import time
+
+from ..core.config import config_manager
+
+
+router = APIRouter(tags=["System & Utilities"])
+
+
+# --- Utility function to filter config for frontend ---
+def filter_config_for_frontend(settings):
+    """Filters the full settings object to remove sensitive fields before sending to the frontend."""
+    # Create a dictionary representation of the settings
+    config_dict = settings.model_dump()
+    
+    # Remove sensitive fields
+    config_dict.pop('api_keys', None)
+    
+    return config_dict
+
+
+# --- Auth Dependency ---
+
+async def get_api_token(request: Request):
+    """FastAPI dependency to check for the API token in headers."""
+    password = config_manager.settings.server.panel_password
+    if not password:
+        return True
+    header_token = request.headers.get("X-API-Token")
+    if header_token and header_token == password:
+        return True
+    raise HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Invalid API token",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+
+# --- System Endpoints ---
+
+@router.get("/api/system/health")
+async def health_check():
+    """Provides a simple health check of the server."""
+    from ..utils.process import process_manager
+    return {
+        "status": "healthy",
+        "backend_running": True,
+        "process_manager_running": process_manager.is_running,
+        "timestamp": time.time()
+    }
+
+@router.get("/")
+async def root():
+    """Returns basic information about the API."""
+    return {
+        "message": "Neuro-Sama Simulator Backend",
+        "version": "2.0",
+        "api_docs": "/docs",
+    }
+
+

{neuro_simulator-0.3.0 → neuro_simulator-0.3.2}/neuro_simulator/cli.py

@@ -60,12 +60,13 @@ def main():
     # Ensure agent directory and its contents exist
     agent_dir = work_dir / "agent"
     agent_dir.mkdir(parents=True, exist_ok=True)
-    copy_resource('neuro_simulator', 'agent/prompt_template.txt', agent_dir / 'prompt_template.txt')
+    copy_resource('neuro_simulator', 'agent/neuro_prompt.txt', agent_dir / 'neuro_prompt.txt')
+    copy_resource('neuro_simulator', 'agent/memory_prompt.txt', agent_dir / 'memory_prompt.txt')
 
     # Ensure agent memory directory and its contents exist
     agent_memory_dir = agent_dir / "memory"
     agent_memory_dir.mkdir(parents=True, exist_ok=True)
-    for filename in ["context.json", "core_memory.json", "dialog_history.json", "init_memory.json"]:
+    for filename in ["chat_history.json", "core_memory.json", "init_memory.json"]:
         copy_resource('neuro_simulator', f'agent/memory/{filename}', agent_memory_dir / filename)
 
     # 3. Validate essential files

{neuro_simulator-0.3.0 → neuro_simulator-0.3.2}/neuro_simulator/core/agent_interface.py

@@ -16,7 +16,7 @@ class BaseAgent(ABC):
         pass
 
     @abstractmethod
-    async def process_messages(self, messages: List[Dict[str, str]]) -> Dict[str, Any]:
+    async def process_and_respond(self, messages: List[Dict[str, str]]) -> Dict[str, Any]:
         """Process messages and generate a response."""
         pass