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

neuro_simulator/agent/core.py

@@ -1,22 +1,19 @@
 # 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
-import sys
 from pathlib import Path
-from datetime import datetime
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List
 
-# Updated imports for the new structure
 from ..utils.logging import QueueLogHandler, agent_log_queue
 from ..utils.websocket import connection_manager
-
-# --- Agent-specific imports ---
 from .llm import LLMClient
 from .memory.manager import MemoryManager
 from .tools.core import ToolManager
@@ -32,8 +29,7 @@ def configure_agent_logging():
         agent_logger.handlers.clear()
     
     agent_queue_handler = QueueLogHandler(agent_log_queue)
-    # Use the same format as the server for consistency
-    formatter = logging.Formatter('%(asctime)s - [%(name)-24s] - %(levelname)-8s - %(message)s', datefmt='%H:%M:%S')
+    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
@@ -42,14 +38,25 @@ def configure_agent_logging():
 configure_agent_logging()
 
 class Agent:
-    """Main Agent class that integrates LLM, memory, and tools. This is the concrete implementation."""
+    """
+    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)
-        self.llm_client = LLMClient()
+        
+        # Dual LLM clients
+        self.neuro_llm = LLMClient()
+        self.memory_llm = LLMClient()
+        
         self._initialized = False
-        agent_logger.info("Agent instance created.")
+        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):
@@ -63,139 +70,165 @@ class Agent:
     async def reset_all_memory(self):
         """Reset all agent memory types."""
         await self.memory_manager.reset_temp_memory()
-        await self.memory_manager.reset_context()
+        await self.memory_manager.reset_chat_history()
         agent_logger.info("All agent memory has been reset.")
-        
-    async def process_messages(self, messages: List[Dict[str, str]]) -> Dict[str, Any]:
-        """Process incoming messages and generate a response with tool usage."""
-        await self.initialize()
-        agent_logger.info(f"Processing {len(messages)} messages.")
 
-        for msg in messages:
-            content = f"{msg['username']}: {msg['text']}"
-            await self.memory_manager.add_context_entry("user", content)
-        
-        context_messages = await self.memory_manager.get_recent_context()
-        await connection_manager.broadcast({"type": "agent_context", "action": "update", "messages": context_messages})
-        
-        processing_entry_id = await self.memory_manager.add_detailed_context_entry(
-            input_messages=messages, prompt="Processing started", llm_response="",
-            tool_executions=[], final_response="Processing started"
-        )
-            
-        context = await self.memory_manager.get_full_context()
-        tool_descriptions = self.tool_manager.get_tool_descriptions()
-        
-        # --- CORRECTED HISTORY GATHERING ---
-        recent_history = await self.memory_manager.get_detailed_context_history()
-        assistant_responses = []
-        for entry in reversed(recent_history):
-            if entry.get("type") == "llm_interaction":
-                for tool in entry.get("tool_executions", []):
-                    if tool.get("name") == "speak" and tool.get("result"):
-                        assistant_responses.append(tool["result"])
-
-        # Create LLM prompt from template
-        template_path = Path(self.memory_manager.memory_dir).parent / "prompt_template.txt"
+    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()
 
-        recent_speak_history_text = "\n".join([f"- {response}" for response in assistant_responses[:5]]) if assistant_responses else "You haven't said anything yet."
+        # 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])
 
-        prompt = prompt_template.format(
-            full_context=context,
+        return prompt_template.format(
             tool_descriptions=tool_descriptions,
-            recent_speak_history=recent_speak_history_text,
+            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()
         
-        await self.memory_manager.add_detailed_context_entry(
-            input_messages=messages, prompt=prompt, llm_response="", tool_executions=[],
-            final_response="Prompt sent to LLM", entry_id=processing_entry_id
-        )
-        
-        response_text = await self.llm_client.generate(prompt)
-        agent_logger.debug(f"LLM raw response: {response_text[:100] if response_text else 'None'}...")
-        
-        await self.memory_manager.add_detailed_context_entry(
-            input_messages=messages, prompt=prompt, llm_response=response_text, tool_executions=[],
-            final_response="LLM response received", entry_id=processing_entry_id
-        )
-        
-        processing_result = {
-            "input_messages": messages, "llm_response": response_text,
-            "tool_executions": [], "final_response": ""
-        }
-        
-        if response_text:
-            tool_calls = self._parse_tool_calls(response_text)
-            for tool_call in tool_calls:
-                agent_logger.info(f"Executing tool: {tool_call['name']}")
-                await self._execute_parsed_tool(tool_call, processing_result)
-
-        await self.memory_manager.add_detailed_context_entry(
-            input_messages=messages, prompt=prompt, llm_response=response_text,
-            tool_executions=processing_result["tool_executions"],
-            final_response=processing_result["final_response"], entry_id=processing_entry_id
-        )
-            
-        final_context = await self.memory_manager.get_recent_context()
-        await connection_manager.broadcast({"type": "agent_context", "action": "update", "messages": final_context})
-            
-        agent_logger.info("Message processing completed.")
-        return processing_result
+        history_text = "\n".join([f"{msg['role']}: {msg['content']}" for msg in conversation_history])
         
-    async def _execute_parsed_tool(self, tool_call: Dict[str, Any], processing_result: Dict[str, Any]):
-        """Execute a parsed tool call and update processing result."""
+        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:
-            tool_result = await self.execute_tool(tool_call["name"], tool_call["params"])
-            tool_call["result"] = tool_result
-            if tool_call["name"] == "speak":
-                processing_result["final_response"] = tool_call["params"].get("text", "")
-            processing_result["tool_executions"].append(tool_call)
-        except Exception as e:
-            tool_call["error"] = str(e)
-            processing_result["tool_executions"].append(tool_call)
-            agent_logger.error(f"Error executing tool {tool_call['name']}: {e}")
+            # 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)
             
-    def _parse_tool_calls(self, text: str) -> List[Dict[str, Any]]:
-        """Parse tool calls using ast.literal_eval for robustness."""
-        import ast
-        calls = []
-        text = text.strip()
-        if text.startswith("speak(") and text.endswith(")"):
+            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:
-                # Extract the content inside speak(...)
-                # e.g., "text='Hello, I'm here'"
-                inner_content = text[len("speak("):-1].strip()
-
-                # Ensure it's a text=... call
-                if not inner_content.startswith("text="):
-                    return []
-                
-                # Get the quoted string part
-                quoted_string = inner_content[len("text="):
-].strip()
-
-                # Use ast.literal_eval to safely parse the Python string literal
-                parsed_text = ast.literal_eval(quoted_string)
-                
-                if isinstance(parsed_text, str):
-                    calls.append({
-                        "name": "speak",
-                        "params": {"text": parsed_text}
-                    })
-
-            except (ValueError, SyntaxError, TypeError) as e:
-                agent_logger.warning(f"Could not parse tool call using ast.literal_eval: {text}. Error: {e}")
-
-        return calls
+                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)})
         
-    async def execute_tool(self, tool_name: str, params: Dict[str, Any]) -> Any:
-        """Execute a registered tool."""
+        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.debug(f"Executing tool: {tool_name} with params: {params}")
-        result = await self.tool_manager.execute_tool(tool_name, params)
-        agent_logger.debug(f"Tool execution result: {result}")
-        return result
+        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/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/api/stream.py

@@ -1,55 +1 @@
-# neuro_simulator/api/stream.py
-"""API endpoints for controlling the live stream lifecycle."""
-
-import asyncio
-import logging
-from pathlib import Path
-
-from fastapi import APIRouter, Depends
-
-from ..core.agent_factory import create_agent
-from ..utils.process import process_manager
-from .agent import get_api_token # Re-using the auth dependency from agent API
-
-logger = logging.getLogger(__name__.replace("neuro_simulator", "server", 1))
-router = APIRouter(prefix="/api/stream", tags=["Stream Control"])
-
-@router.post("/start", dependencies=[Depends(get_api_token)])
-async def start_stream():
-    """Starts the live stream processes."""
-    try:
-        agent = await create_agent()
-        await agent.reset_memory()
-    except Exception as e:
-        logger.error(f"Could not reset agent memory on stream start: {e}", exc_info=True)
-
-    if not process_manager.is_running:
-        process_manager.start_live_processes()
-        return {"status": "success", "message": "Stream started"}
-    else:
-        return {"status": "info", "message": "Stream is already running"}
-
-@router.post("/stop", dependencies=[Depends(get_api_token)])
-async def stop_stream():
-    """Stops the live stream processes."""
-    if process_manager.is_running:
-        await process_manager.stop_live_processes()
-        return {"status": "success", "message": "Stream stopped"}
-    else:
-        return {"status": "info", "message": "Stream is not running"}
-
-@router.post("/restart", dependencies=[Depends(get_api_token)])
-async def restart_stream():
-    """Restarts the live stream processes."""
-    await process_manager.stop_live_processes()
-    await asyncio.sleep(1) # Give time for tasks to cancel
-    process_manager.start_live_processes()
-    return {"status": "success", "message": "Stream restarted"}
-
-@router.get("/status", dependencies=[Depends(get_api_token)])
-async def get_stream_status():
-    """Gets the current status of the stream."""
-    return {
-        "is_running": process_manager.is_running,
-        "backend_status": "running" if process_manager.is_running else "stopped"
-    }
+# This file is now empty as all stream control API endpoints have been migrated to WebSockets.

neuro_simulator/api/system.py

@@ -1,71 +1,41 @@
 # neuro_simulator/api/system.py
 """API endpoints for system, config, and utility functions."""
 
-from fastapi import APIRouter, Depends, HTTPException
-from pydantic import BaseModel
+from fastapi import APIRouter, Depends, HTTPException, status, Request
 import time
 
-from ..core.config import config_manager, AppSettings
-from ..services.audio import synthesize_audio_segment
-from .agent import get_api_token # Re-using the auth dependency
+from ..core.config import config_manager
 
 router = APIRouter(tags=["System & Utilities"])
 
-# --- TTS Endpoint ---
 
-class SpeechRequest(BaseModel):
-    text: str
-    voice_name: str | None = None
-    pitch: float | None = None
-
-@router.post("/api/tts/synthesize", dependencies=[Depends(get_api_token)])
-async def synthesize_speech_endpoint(request: SpeechRequest):
-    """Synthesizes text to speech using the configured TTS service."""
-    try:
-        audio_base64, _ = await synthesize_audio_segment(
-            text=request.text, voice_name=request.voice_name, pitch=request.pitch
-        )
-        return {"audio_base64": audio_base64}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-# --- Config Management Endpoints ---
-
-# This helper can be moved to a more central location if needed
-def filter_config_for_frontend(settings: AppSettings):
-    """Filters the settings to return only the fields safe for the frontend."""
-    # Using .model_dump() with include is a more robust Pydantic approach
-    return settings.model_dump(include={
-        'stream_metadata': {'stream_title', 'stream_category', 'stream_tags'},
-        'agent': {'agent_provider', 'agent_model'},
-        'neuro_behavior': {'input_chat_sample_size', 'post_speech_cooldown_sec', 'initial_greeting'},
-        'audience_simulation': {'llm_provider', 'gemini_model', 'openai_model', 'llm_temperature', 'chat_generation_interval_sec', 'chats_per_batch', 'max_output_tokens', 'username_blocklist', 'username_pool'},
-        'performance': {'neuro_input_queue_max_size', 'audience_chat_buffer_max_size', 'initial_chat_backlog_limit'}
-    })
-
-@router.get("/api/configs", dependencies=[Depends(get_api_token)])
-async def get_configs():
-    """Gets the current, frontend-safe configuration."""
-    return filter_config_for_frontend(config_manager.settings)
-
-@router.patch("/api/configs", dependencies=[Depends(get_api_token)])
-async def update_configs(new_settings: dict):
-    """Updates the configuration with new values from the frontend."""
-    try:
-        await config_manager.update_settings(new_settings)
-        return filter_config_for_frontend(config_manager.settings)
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Failed to update settings: {str(e)}")
-
-@router.post("/api/configs/reload", dependencies=[Depends(get_api_token)])
-async def reload_configs():
-    """Triggers a reload of the configuration from the config.yaml file."""
-    try:
-        # Passing an empty dict forces a reload and triggers callbacks
-        await config_manager.update_settings({})
-        return {"status": "success", "message": "Configuration reloaded"}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Failed to reload settings: {str(e)}")
+# --- 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 ---
 
@@ -87,4 +57,4 @@ async def root():
         "message": "Neuro-Sama Simulator Backend",
         "version": "2.0",
         "api_docs": "/docs",
-    }
+    }

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/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
 

neuro_simulator/core/application.py

@@ -21,8 +21,6 @@ from ..services.letta import LettaAgent
 from ..services.builtin import BuiltinAgentWrapper
 
 # --- API Routers ---
-from ..api.agent import router as agent_router
-from ..api.stream import router as stream_router
 from ..api.system import router as system_router
 
 # --- Services and Utilities ---
@@ -60,8 +58,6 @@ app.add_middleware(
     expose_headers=["X-API-Token"],
 )
 
-app.include_router(agent_router)
-app.include_router(stream_router)
 app.include_router(system_router)
 
 # --- Background Task Definitions ---
@@ -167,7 +163,7 @@ async def neuro_response_cycle():
             if not selected_chats:
                 continue
             
-            response_result = await asyncio.wait_for(agent.process_messages(selected_chats), timeout=20.0)
+            response_result = await asyncio.wait_for(agent.process_and_respond(selected_chats), timeout=20.0)
             
             response_text = response_result.get("final_response", "").strip()
             if not response_text:
@@ -280,7 +276,10 @@ async def websocket_stream_endpoint(websocket: WebSocket):
 @app.websocket("/ws/admin")
 async def websocket_admin_endpoint(websocket: WebSocket):
     await websocket.accept()
+    # Add the new admin client to a dedicated list
+    connection_manager.admin_connections.append(websocket)
     try:
+        # Send initial state
         for log_entry in list(server_log_queue): await websocket.send_json({"type": "server_log", "data": log_entry})
         for log_entry in list(agent_log_queue): await websocket.send_json({"type": "agent_log", "data": log_entry})
         
@@ -288,15 +287,174 @@ async def websocket_admin_endpoint(websocket: WebSocket):
         initial_context = await agent.get_message_history()
         await websocket.send_json({"type": "agent_context", "action": "update", "messages": initial_context})
         
+        # Main loop for receiving messages from the client and pushing log updates
         while websocket.client_state == WebSocketState.CONNECTED:
+            # Check for incoming messages
+            try:
+                raw_data = await asyncio.wait_for(websocket.receive_text(), timeout=0.01)
+                data = json.loads(raw_data)
+                await handle_admin_ws_message(websocket, data)
+            except asyncio.TimeoutError:
+                pass # No message received, continue to push logs
+
+            # Push log updates
             if server_log_queue: await websocket.send_json({"type": "server_log", "data": server_log_queue.popleft()})
             if agent_log_queue: await websocket.send_json({"type": "agent_log", "data": agent_log_queue.popleft()})
             await asyncio.sleep(0.1)
+            
     except WebSocketDisconnect:
         pass
     finally:
+        connection_manager.admin_connections.remove(websocket)
         logger.info("Admin WebSocket client disconnected.")
 
+async def handle_admin_ws_message(websocket: WebSocket, data: dict):
+    """Handles incoming messages from the admin WebSocket."""
+    action = data.get("action")
+    payload = data.get("payload", {})
+    request_id = data.get("request_id")
+    
+    agent = await create_agent()
+    response = {"type": "response", "request_id": request_id, "payload": {}}
+
+    try:
+        # Core Memory Actions
+        if action == "get_core_memory_blocks":
+            blocks = await agent.get_memory_blocks()
+            response["payload"] = blocks
+        
+        elif action == "create_core_memory_block":
+            block_id = await agent.create_memory_block(**payload)
+            response["payload"] = {"status": "success", "block_id": block_id}
+            # Broadcast the update to all admins
+            updated_blocks = await agent.get_memory_blocks()
+            from ..utils.websocket import connection_manager
+            await connection_manager.broadcast_to_admins({"type": "core_memory_updated", "payload": updated_blocks})
+
+        elif action == "update_core_memory_block":
+            await agent.update_memory_block(**payload)
+            response["payload"] = {"status": "success"}
+            # Broadcast the update to all admins
+            updated_blocks = await agent.get_memory_blocks()
+            from ..utils.websocket import connection_manager
+            await connection_manager.broadcast_to_admins({"type": "core_memory_updated", "payload": updated_blocks})
+
+        elif action == "delete_core_memory_block":
+            await agent.delete_memory_block(**payload)
+            response["payload"] = {"status": "success"}
+            # Broadcast the update to all admins
+            updated_blocks = await agent.get_memory_blocks()
+            from ..utils.websocket import connection_manager
+            await connection_manager.broadcast_to_admins({"type": "core_memory_updated", "payload": updated_blocks})
+
+        # Temp Memory Actions
+        elif action == "get_temp_memory":
+            temp_mem = await agent.get_temp_memory()
+            response["payload"] = temp_mem
+
+        elif action == "add_temp_memory":
+            await agent.add_temp_memory(**payload)
+            response["payload"] = {"status": "success"}
+            updated_temp_mem = await agent.get_temp_memory()
+            from ..utils.websocket import connection_manager
+            await connection_manager.broadcast_to_admins({"type": "temp_memory_updated", "payload": updated_temp_mem})
+
+        elif action == "clear_temp_memory":
+            await agent.clear_temp_memory()
+            response["payload"] = {"status": "success"}
+            updated_temp_mem = await agent.get_temp_memory()
+            await connection_manager.broadcast_to_admins({"type": "temp_memory_updated", "payload": updated_temp_mem})
+
+        # Init Memory Actions
+        elif action == "get_init_memory":
+            init_mem = await agent.get_init_memory()
+            response["payload"] = init_mem
+
+        elif action == "update_init_memory":
+            await agent.update_init_memory(**payload)
+            response["payload"] = {"status": "success"}
+            updated_init_mem = await agent.get_init_memory()
+            from ..utils.websocket import connection_manager
+            await connection_manager.broadcast_to_admins({"type": "init_memory_updated", "payload": updated_init_mem})
+
+        # Tool Actions
+        elif action == "get_tools":
+            tools = await agent.get_available_tools()
+            response["payload"] = {"tools": tools}
+
+        elif action == "execute_tool":
+            result = await agent.execute_tool(**payload)
+            response["payload"] = {"result": result}
+
+        # Stream Control Actions
+        elif action == "start_stream":
+            if not process_manager.is_running:
+                process_manager.start_live_processes()
+            response["payload"] = {"status": "success", "message": "Stream started"}
+
+        elif action == "stop_stream":
+            if process_manager.is_running:
+                await process_manager.stop_live_processes()
+            response["payload"] = {"status": "success", "message": "Stream stopped"}
+
+        elif action == "restart_stream":
+            await process_manager.stop_live_processes()
+            await asyncio.sleep(1)
+            process_manager.start_live_processes()
+            response["payload"] = {"status": "success", "message": "Stream restarted"}
+
+        elif action == "get_stream_status":
+            status = {"is_running": process_manager.is_running, "backend_status": "running" if process_manager.is_running else "stopped"}
+            response["payload"] = status
+
+        # Config Management Actions
+        elif action == "get_configs":
+            from ..api.system import filter_config_for_frontend
+            configs = filter_config_for_frontend(config_manager.settings)
+            response["payload"] = configs
+
+        elif action == "update_configs":
+            from ..api.system import filter_config_for_frontend
+            await config_manager.update_settings(payload)
+            updated_configs = filter_config_for_frontend(config_manager.settings)
+            response["payload"] = updated_configs
+            await connection_manager.broadcast_to_admins({"type": "config_updated", "payload": updated_configs})
+
+        elif action == "reload_configs":
+            await config_manager.update_settings({})
+            response["payload"] = {"status": "success", "message": "Configuration reloaded"}
+            from ..api.system import filter_config_for_frontend
+            updated_configs = filter_config_for_frontend(config_manager.settings)
+            await connection_manager.broadcast_to_admins({"type": "config_updated", "payload": updated_configs})
+
+        # Other Agent Actions
+        elif action == "get_agent_context":
+            context = await agent.get_message_history()
+            response["payload"] = context
+
+        elif action == "reset_agent_memory":
+            await agent.reset_memory()
+            response["payload"] = {"status": "success"}
+            # Broadcast updates for all memory types
+            await connection_manager.broadcast_to_admins({"type": "core_memory_updated", "payload": await agent.get_memory_blocks()})
+            await connection_manager.broadcast_to_admins({"type": "temp_memory_updated", "payload": await agent.get_temp_memory()})
+            await connection_manager.broadcast_to_admins({"type": "init_memory_updated", "payload": await agent.get_init_memory()})
+            await connection_manager.broadcast_to_admins({"type": "agent_context", "action": "update", "messages": await agent.get_message_history()})
+
+        else:
+            response["payload"] = {"status": "error", "message": f"Unknown action: {action}"}
+
+        # Send the direct response to the requesting client
+        if request_id:
+            await websocket.send_json(response)
+
+    except Exception as e:
+        logger.error(f"Error handling admin WS message (action: {action}): {e}", exc_info=True)
+        if request_id:
+            response["payload"] = {"status": "error", "message": str(e)}
+            await websocket.send_json(response)
+
+
 # --- Server Entrypoint ---
 
 def run_server(host: str = None, port: int = None):

neuro_simulator/services/builtin.py

@@ -37,8 +37,8 @@ class BuiltinAgentWrapper(BaseAgent):
     async def reset_memory(self):
         await self.agent_instance.reset_all_memory()
 
-    async def process_messages(self, messages: List[Dict[str, str]]) -> Dict[str, Any]:
-        return await self.agent_instance.process_messages(messages)
+    async def process_and_respond(self, messages: List[Dict[str, str]]) -> Dict[str, Any]:
+        return await self.agent_instance.process_and_respond(messages)
 
     # Memory Block Management
     async def get_memory_blocks(self) -> List[Dict[str, Any]]:
@@ -50,13 +50,25 @@ class BuiltinAgentWrapper(BaseAgent):
 
     async def create_memory_block(self, title: str, description: str, content: List[str]) -> Dict[str, str]:
         block_id = await self.agent_instance.memory_manager.create_core_memory_block(title, description, content)
+        # Broadcast core_memory_updated event
+        updated_blocks = await self.get_memory_blocks()
+        from ..utils.websocket import connection_manager
+        await connection_manager.broadcast_to_admins({"type": "core_memory_updated", "payload": updated_blocks})
         return {"block_id": block_id}
 
     async def update_memory_block(self, block_id: str, title: Optional[str], description: Optional[str], content: Optional[List[str]]):
         await self.agent_instance.memory_manager.update_core_memory_block(block_id, title, description, content)
+        # Broadcast core_memory_updated event
+        updated_blocks = await self.get_memory_blocks()
+        from ..utils.websocket import connection_manager
+        await connection_manager.broadcast_to_admins({"type": "core_memory_updated", "payload": updated_blocks})
 
     async def delete_memory_block(self, block_id: str):
         await self.agent_instance.memory_manager.delete_core_memory_block(block_id)
+        # Broadcast core_memory_updated event
+        updated_blocks = await self.get_memory_blocks()
+        from ..utils.websocket import connection_manager
+        await connection_manager.broadcast_to_admins({"type": "core_memory_updated", "payload": updated_blocks})
 
     # Init Memory Management
     async def get_init_memory(self) -> Dict[str, Any]:
@@ -64,6 +76,10 @@ class BuiltinAgentWrapper(BaseAgent):
 
     async def update_init_memory(self, memory: Dict[str, Any]):
         await self.agent_instance.memory_manager.update_init_memory(memory)
+        # Broadcast init_memory_updated event
+        updated_init_mem = await self.get_init_memory()
+        from ..utils.websocket import connection_manager
+        await connection_manager.broadcast_to_admins({"type": "init_memory_updated", "payload": updated_init_mem})
 
     # Temp Memory Management
     async def get_temp_memory(self) -> List[Dict[str, Any]]:
@@ -71,17 +87,31 @@ class BuiltinAgentWrapper(BaseAgent):
 
     async def add_temp_memory(self, content: str, role: str):
         await self.agent_instance.memory_manager.add_temp_memory(content, role)
+        # Broadcast temp_memory_updated event
+        updated_temp_mem = await self.get_temp_memory()
+        from ..utils.websocket import connection_manager
+        await connection_manager.broadcast_to_admins({"type": "temp_memory_updated", "payload": updated_temp_mem})
 
     async def clear_temp_memory(self):
         await self.agent_instance.memory_manager.reset_temp_memory()
+        # Broadcast temp_memory_updated event
+        updated_temp_mem = await self.get_temp_memory()
+        from ..utils.websocket import connection_manager
+        await connection_manager.broadcast_to_admins({"type": "temp_memory_updated", "payload": updated_temp_mem})
 
     # Tool Management
     async def get_available_tools(self) -> str:
         return self.agent_instance.tool_manager.get_tool_descriptions()
 
     async def execute_tool(self, tool_name: str, params: Dict[str, Any]) -> Any:
-        return await self.agent_instance.execute_tool(tool_name, params)
+        result = await self.agent_instance.execute_tool(tool_name, params)
+        # If the tool was add_temp_memory, broadcast temp_memory_updated event
+        if tool_name == "add_temp_memory":
+            updated_temp_mem = await self.get_temp_memory()
+            from ..utils.websocket import connection_manager
+            await connection_manager.broadcast_to_admins({"type": "temp_memory_updated", "payload": updated_temp_mem})
+        return result
 
     # Context/Message History
     async def get_message_history(self, limit: int = 20) -> List[Dict[str, Any]]:
-        return await self.agent_instance.memory_manager.get_recent_context(limit)
+        return await self.agent_instance.memory_manager.get_recent_chat(limit)

neuro_simulator/utils/websocket.py

@@ -12,7 +12,8 @@ logger = logging.getLogger(__name__.replace("neuro_simulator", "server", 1))
 class WebSocketManager:
     """Manages all active WebSocket connections and provides broadcasting capabilities."""
     def __init__(self):
-        self.active_connections: deque[WebSocket] = deque()
+        self.active_connections: list[WebSocket] = []
+        self.admin_connections: list[WebSocket] = []
         logger.info("WebSocketManager initialized.")
 
     async def connect(self, websocket: WebSocket):
@@ -37,19 +38,15 @@ class WebSocketManager:
                 self.disconnect(websocket)
 
     async def broadcast(self, message: dict):
-        disconnected_sockets = []
-        for connection in list(self.active_connections):
-            if connection.client_state == WebSocketState.CONNECTED:
-                try:
-                    await connection.send_json(message)
-                except Exception as e:
-                    logger.warning(f"Could not broadcast message to client {connection}, it may have disconnected: {e}")
-                    disconnected_sockets.append(connection)
-            else:
-                disconnected_sockets.append(connection)
-        
-        for disconnected_socket in disconnected_sockets:
-            self.disconnect(disconnected_socket)
+        for connection in self.active_connections:
+            await connection.send_json(message)
+
+    async def broadcast_to_admins(self, message: dict):
+        for connection in self.admin_connections:
+            try:
+                await connection.send_json(message)
+            except Exception as e:
+                logger.error(f"Failed to send message to admin connection: {e}")
 
 # Global singleton instance
 connection_manager = WebSocketManager()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuro_simulator
-Version: 0.3.0
+Version: 0.3.1
 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.dist-info → neuro_simulator-0.3.1.dist-info}/RECORD

@@ -1,27 +1,26 @@
 neuro_simulator/__init__.py,sha256=-tposzyvg6UckPcfSvtc03UjxBa9oCe_zRvlKf8splk,31
-neuro_simulator/cli.py,sha256=p2jSNbMsQ2HYau-EX3ygmTRhECU9dbSg0v53xgYjOZ4,3894
+neuro_simulator/cli.py,sha256=Nc-udO0jdRVZjlbebKBjDVOIUzd6tJr13ApBGeBEg2k,3967
 neuro_simulator/agent/__init__.py,sha256=t52CZlyTGWqcGjMs90qvpFpRckY2WSSlO7r_H3K_mSY,32
 neuro_simulator/agent/base.py,sha256=6v2ZO5UpGCwJEkJ23Oe96Rs510tK4ZOEpZ2DB49IZmM,1262
-neuro_simulator/agent/core.py,sha256=CJv0We7ZjW_EKQB54Xq-y3wDu2a2HmoaOAdYR057HOg,8941
+neuro_simulator/agent/core.py,sha256=2mPVCcNKZDRsyYd6L8RzQYlm8LwzoKoP9FJg0W4qcbc,10702
 neuro_simulator/agent/factory.py,sha256=e0IBnqJQM7OuKtglrf-pWwqwmg98wh7tOq5LxF2rV-w,1146
 neuro_simulator/agent/llm.py,sha256=vLz8hp2h2R0JaNfS1RLGYGkri_YoUdlEdNfFVbxeEuI,4261
 neuro_simulator/agent/memory/__init__.py,sha256=YJ7cynQJI6kD7vjyv3rKc-CZqmoYSuGQtRZl_XdGEps,39
-neuro_simulator/agent/memory/manager.py,sha256=z5ZI1agkuOev5gtuGA_g6MS3atB7ufdPRVNZZ89yg1w,9259
+neuro_simulator/agent/memory/manager.py,sha256=UiUJgjiTV7SHCmb3V5sc4OUa_ksEeXBOyvl-WBQviqs,9266
 neuro_simulator/agent/tools/__init__.py,sha256=1WZy6PADfi6o1avyy1y-ThWBFAPJ_bBqtkobyYpf5ao,38
 neuro_simulator/agent/tools/core.py,sha256=o6Oyis-HFD-g6Z_u3T--tkmr9ylKJvybKqMRSMUwi1Q,5555
 neuro_simulator/api/__init__.py,sha256=5LWyDSayPGdQS8Rv13nmAKLyhPnMVPyTYDdvoMPB4xw,56
-neuro_simulator/api/agent.py,sha256=ABl_JoIxB4wW_J2J52bWndmTXkfGJBS5LZmbGuh7zv8,6343
-neuro_simulator/api/stream.py,sha256=Yg-cwjVI2HTLAt7moWbDQ1ZbbP6QE1ZB8LrW6A3tcQk,2081
-neuro_simulator/api/system.py,sha256=hXznMcThuFhwopYWgpzrRxwtBuFnF_b_vinkOaE5XOs,3712
+neuro_simulator/api/stream.py,sha256=hM66flSUygpE-NH9X-ZOV6SiGipBzN1-wjd_wZRpQm4,94
+neuro_simulator/api/system.py,sha256=TV_3DzP-VgLnHdue0pKYFFQNOV_V7tr4aMuxL802vQg,1783
 neuro_simulator/core/__init__.py,sha256=-ojq25c8XA0CU25b0OxcGjH4IWFEDHR-HXSRSZIuKe8,57
 neuro_simulator/core/agent_factory.py,sha256=qMFidwT5IrOkyNHwmpO8_fRv20KLbaIBfWF-VTFCLNA,1742
-neuro_simulator/core/agent_interface.py,sha256=r58Opcgs7SWVovYTjMWuxF8AiTy9QfRz276_YGmSei0,2791
-neuro_simulator/core/application.py,sha256=fM9XgYBvx-mNB173rYDezbKdLJRTJ5Mr0nOtxNlSfSc,13365
+neuro_simulator/core/agent_interface.py,sha256=ZXUCtkQUvsBQ5iCb0gTILJaShn5KmSrEgKhd7PK18HE,2794
+neuro_simulator/core/application.py,sha256=lhTn5KR7ek8-kuyD1qWtppImUUz8pOExH9KRNW1SQ3M,21115
 neuro_simulator/core/config.py,sha256=brA8kiekV_995mpz04JiGj1swIWbZZuWWLNYtbroMyE,14884
 neuro_simulator/services/__init__.py,sha256=s3ZrAHg5TpJakadAAGY1h0wDw_xqN4Je4aJwJyRBmk4,61
 neuro_simulator/services/audience.py,sha256=0phlhsujh_GMXm_UMiyOntY-ZMtoseRa_FroIfc5A6w,5028
 neuro_simulator/services/audio.py,sha256=ZscQA25wVYpm9FUl4Hya7tKH8t0TjR3th9-OEZ0G7xk,2934
-neuro_simulator/services/builtin.py,sha256=7ePxEom5HIK6wGto_H5M8JOnAjyiHqUuE381DEGgzjE,3821
+neuro_simulator/services/builtin.py,sha256=nn3sJFPy09JxQkw35icdyGU9hzLTXXazAJkNpdcz6Zs,5848
 neuro_simulator/services/letta.py,sha256=6jBvOTsLMlRILDv-fvX9fhHMONSYeu-ImJGFcKU00kc,11067
 neuro_simulator/services/stream.py,sha256=dG7RuNI_ICohPkqKZ-zlBppo54BgWm_KYBs-ezzc73E,5907
 neuro_simulator/utils/__init__.py,sha256=xSEFzjT827W81mNyQ_DLtr00TgFlttqfFgpz9pSxFXQ,58
@@ -29,9 +28,9 @@ neuro_simulator/utils/logging.py,sha256=BO-q_cCcoeamsc8eJqq2-L3Z8nhApze_v6LnmD-O
 neuro_simulator/utils/process.py,sha256=9w2JQH59Wy6L8ADrig2QF88iajdykGPZIYJVJe6Al2Y,2603
 neuro_simulator/utils/queue.py,sha256=vSkh-BrgfsGN_gDAx2mfK44ydmMapdVyLsDG-7LIJZQ,1643
 neuro_simulator/utils/state.py,sha256=DdBqSAYfjOFtJfB1hEGhYPh32r1ZvFuVlN_-29_-luA,664
-neuro_simulator/utils/websocket.py,sha256=yOdFvJzbNhcUn5EAuyS55G_R8q-snas5OvkOtS8g19E,2292
-neuro_simulator-0.3.0.dist-info/METADATA,sha256=PELlUyyTi3i1u1_EOLIntPwd7-FAXAoy6uiSs2QA2uE,8676
-neuro_simulator-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-neuro_simulator-0.3.0.dist-info/entry_points.txt,sha256=qVd5ypnRRgU8Cw7rWfZ7o0OXyS9P9hgY-cRoN_mgz9g,51
-neuro_simulator-0.3.0.dist-info/top_level.txt,sha256=V8awSKpcrFnjJDiJxSfy7jtOrnuE2BgAR9hLmfMDWK8,16
-neuro_simulator-0.3.0.dist-info/RECORD,,
+neuro_simulator/utils/websocket.py,sha256=1gtVoH1hafBUfVYmwkVDAbjwETeqyC3sWx706nQzSRo,2085
+neuro_simulator-0.3.1.dist-info/METADATA,sha256=lQv9x0KvOZJAA8NwZ8byIaHYTVnSxuHRPyhUyqLC6vw,8643
+neuro_simulator-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+neuro_simulator-0.3.1.dist-info/entry_points.txt,sha256=qVd5ypnRRgU8Cw7rWfZ7o0OXyS9P9hgY-cRoN_mgz9g,51
+neuro_simulator-0.3.1.dist-info/top_level.txt,sha256=V8awSKpcrFnjJDiJxSfy7jtOrnuE2BgAR9hLmfMDWK8,16
+neuro_simulator-0.3.1.dist-info/RECORD,,

neuro_simulator/api/agent.py

@@ -1,163 +0,0 @@
-# neuro_simulator/api/agent.py
-"""Unified API endpoints for agent management, decoupled from implementation."""
-
-from fastapi import APIRouter, Depends, HTTPException, status, Request
-from typing import Dict, Any, List, Optional
-from pydantic import BaseModel
-
-# Imports for the new structure
-from ..core.config import config_manager
-from ..core.agent_factory import create_agent
-from ..core.agent_interface import BaseAgent
-
-router = APIRouter(prefix="/api/agent", tags=["Agent Management"])
-
-# Security dependency (remains the same)
-async def get_api_token(request: Request):
-    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"},
-    )
-
-# Pydantic models (remains the same)
-class MessageItem(BaseModel):
-    username: str
-    text: str
-    role: str = "user"
-
-class ToolExecutionRequest(BaseModel):
-    tool_name: str
-    params: Dict[str, Any]
-
-class MemoryUpdateRequest(BaseModel):
-    title: Optional[str] = None
-    description: Optional[str] = None
-    content: Optional[List[str]] = None
-
-class MemoryCreateRequest(BaseModel):
-    title: str
-    description: str
-    content: List[str]
-
-class InitMemoryUpdateRequest(BaseModel):
-    memory: Dict[str, Any]
-
-class TempMemoryItem(BaseModel):
-    content: str
-    role: str = "system"
-
-# Dependency to get the agent instance, making endpoints cleaner
-async def get_agent() -> BaseAgent:
-    return await create_agent()
-
-# A single dependency for both auth and agent instance
-class AgentDeps:
-    def __init__(self, token: bool = Depends(get_api_token), agent: BaseAgent = Depends(get_agent)):
-        self.agent = agent
-
-# --- Refactored Agent Endpoints ---
-
-@router.get("/messages", response_model=List[Dict[str, Any]])
-async def get_agent_messages(deps: AgentDeps = Depends()):
-    """Get agent's detailed message processing history."""
-    return await deps.agent.get_message_history()
-
-@router.get("/context", response_model=List[Dict[str, Any]])
-async def get_agent_context(deps: AgentDeps = Depends()):
-    """Get agent's recent conversation context (last 20 entries)."""
-    return await deps.agent.get_message_history(limit=20)
-
-@router.delete("/messages")
-async def clear_agent_messages(deps: AgentDeps = Depends()):
-    """Clear agent's message history."""
-    await deps.agent.reset_memory()
-    return {"status": "success", "message": "Agent memory reset successfully"}
-
-@router.post("/messages")
-async def send_message_to_agent(message: MessageItem, deps: AgentDeps = Depends()):
-    """Send a message to the agent."""
-    response = await deps.agent.process_messages([message.dict()])
-    return {"response": response}
-
-@router.get("/memory/init", response_model=Dict[str, Any])
-async def get_init_memory(deps: AgentDeps = Depends()):
-    """Get initialization memory content."""
-    return await deps.agent.get_init_memory()
-
-@router.put("/memory/init")
-async def update_init_memory(request: InitMemoryUpdateRequest, deps: AgentDeps = Depends()):
-    """Update initialization memory content."""
-    await deps.agent.update_init_memory(request.memory)
-    return {"status": "success", "message": "Initialization memory updated"}
-
-@router.get("/memory/temp", response_model=List[Dict[str, Any]])
-async def get_temp_memory(deps: AgentDeps = Depends()):
-    """Get all temporary memory content."""
-    return await deps.agent.get_temp_memory()
-
-@router.post("/memory/temp")
-async def add_temp_memory_item(request: TempMemoryItem, deps: AgentDeps = Depends()):
-    """Add an item to temporary memory."""
-    await deps.agent.add_temp_memory(request.content, request.role)
-    return {"status": "success", "message": "Item added to temporary memory"}
-
-@router.delete("/memory/temp")
-async def clear_temp_memory(deps: AgentDeps = Depends()):
-    """Clear temporary memory."""
-    await deps.agent.clear_temp_memory()
-    return {"status": "success", "message": "Temporary memory cleared"}
-
-@router.get("/memory/blocks", response_model=List[Dict[str, Any]])
-async def get_memory_blocks(deps: AgentDeps = Depends()):
-    """Get all memory blocks."""
-    return await deps.agent.get_memory_blocks()
-
-@router.get("/memory/blocks/{block_id}", response_model=Dict[str, Any])
-async def get_memory_block(block_id: str, deps: AgentDeps = Depends()):
-    """Get a specific memory block."""
-    block = await deps.agent.get_memory_block(block_id)
-    if block is None:
-        raise HTTPException(status_code=404, detail="Memory block not found")
-    return block
-
-@router.post("/memory/blocks", response_model=Dict[str, str])
-async def create_memory_block(request: MemoryCreateRequest, deps: AgentDeps = Depends()):
-    """Create a new memory block."""
-    return await deps.agent.create_memory_block(request.title, request.description, request.content)
-
-@router.put("/memory/blocks/{block_id}")
-async def update_memory_block(block_id: str, request: MemoryUpdateRequest, deps: AgentDeps = Depends()):
-    """Update a memory block."""
-    await deps.agent.update_memory_block(block_id, request.title, request.description, request.content)
-    return {"status": "success"}
-
-@router.delete("/memory/blocks/{block_id}")
-async def delete_memory_block(block_id: str, deps: AgentDeps = Depends()):
-    """Delete a memory block."""
-    await deps.agent.delete_memory_block(block_id)
-    return {"status": "success"}
-
-@router.post("/reset_memory")
-async def reset_agent_memory(deps: AgentDeps = Depends()):
-    """Reset all agent memory types."""
-    await deps.agent.reset_memory()
-    return {"status": "success", "message": "Agent memory reset successfully"}
-
-@router.get("/tools")
-async def get_available_tools(deps: AgentDeps = Depends()):
-    """Get list of available tools."""
-    # Return in the format expected by the frontend
-    return {"tools": await deps.agent.get_available_tools()}
-
-@router.post("/tools/execute")
-async def execute_tool(request: ToolExecutionRequest, deps: AgentDeps = Depends()):
-    """Execute a tool with given parameters."""
-    result = await deps.agent.execute_tool(request.tool_name, request.params)
-    return {"result": result}