neuro-simulator 0.5.3__py3-none-any.whl → 0.6.0__py3-none-any.whl

neuro_simulator/agent/llm.py

@@ -33,33 +33,37 @@ class LLMClient:
 
         logger.info("First use of built-in agent's LLMClient, performing initialization...")
         settings = config_manager.settings
-        provider = settings.agent.agent_provider.lower()
-        
-        if provider == "gemini":
-            api_key = settings.api_keys.gemini_api_key
-            if not api_key:
-                raise ValueError("GEMINI_API_KEY is not set in configuration for the agent.")
-            
-            self.client = genai.Client(api_key=api_key)
-            self.model_name = settings.agent.agent_model
+
+        provider_id = settings.neuro.llm_provider_id
+        if not provider_id:
+            raise ValueError("LLM Provider ID is not set for the agent.")
+
+        provider_config = next((p for p in settings.llm_providers if p.provider_id == provider_id), None)
+        if not provider_config:
+            raise ValueError(f"LLM Provider with ID '{provider_id}' not found in configuration.")
+
+        provider_type = provider_config.provider_type.lower()
+        self.model_name = provider_config.model_name
+
+        if provider_type == "gemini":
+            if not provider_config.api_key:
+                raise ValueError(f"API key for Gemini provider '{provider_config.display_name}' is not set.")
+            self.client = genai.Client(api_key=provider_config.api_key)
             self._generate_func = self._generate_gemini
             
-        elif provider == "openai":
-            api_key = settings.api_keys.openai_api_key
-            if not api_key:
-                raise ValueError("OPENAI_API_KEY is not set in configuration for the agent.")
-            
-            self.model_name = settings.agent.agent_model
+        elif provider_type == "openai":
+            if not provider_config.api_key:
+                raise ValueError(f"API key for OpenAI provider '{provider_config.display_name}' is not set.")
             self.client = AsyncOpenAI(
-                api_key=api_key, 
-                base_url=settings.api_keys.openai_api_base_url
+                api_key=provider_config.api_key, 
+                base_url=provider_config.base_url
             )
             self._generate_func = self._generate_openai
         else:
-            raise ValueError(f"Unsupported agent provider in config: {settings.agent.agent_provider}")
+            raise ValueError(f"Unsupported provider type in agent config: {provider_type}")
             
         self._initialized = True
-        logger.info(f"Agent LLM client initialized. Provider: {provider.upper()}, Model: {self.model_name}")
+        logger.info(f"Agent LLM client initialized. Provider: {provider_type.upper()}, Model: {self.model_name}")
 
     async def _generate_gemini(self, prompt: str, max_tokens: int) -> str:
         """Generates text using the Gemini model."""

neuro_simulator/chatbot/core.py

@@ -63,7 +63,7 @@ class ChatbotAgent:
              package_source_dir = Path(__file__).parent.parent
 
         files_to_copy = {
-            "chatbot/prompts/chatbot_prompt.txt": path_manager.chatbot_agent_prompt_path,
+            "chatbot/prompts/chatbot_prompt.txt": path_manager.chatbot_prompt_path,
             "chatbot/prompts/memory_prompt.txt": path_manager.chatbot_memory_agent_prompt_path,
             "chatbot/memory/init_memory.json": path_manager.chatbot_init_memory_path,
             "chatbot/memory/core_memory.json": path_manager.chatbot_core_memory_path,
@@ -132,17 +132,17 @@ class ChatbotAgent:
 
     async def _build_chatbot_prompt(self, neuro_speech: str, recent_history: List[Dict[str, str]]) -> str:
         """Builds the prompt for the Chatbot (Actor) LLM."""
-        with open(path_manager.chatbot_agent_prompt_path, 'r', encoding='utf-8') as f:
+        with open(path_manager.chatbot_prompt_path, 'r', encoding='utf-8') as f:
             prompt_template = f.read()
         
-        tool_descriptions = self._format_tool_schemas_for_prompt('chatbot_agent')
+        tool_descriptions = self._format_tool_schemas_for_prompt('chatbot')
         init_memory_text = json.dumps(self.memory_manager.init_memory, indent=2)
         core_memory_text = json.dumps(self.memory_manager.core_memory, indent=2)
         temp_memory_text = json.dumps(self.memory_manager.temp_memory, indent=2)
         recent_history_text = "\n".join([f"{msg.get('role')}: {msg.get('content')}" for msg in recent_history])
 
         from ..core.config import config_manager
-        chats_per_batch = config_manager.settings.chatbot_agent.chats_per_batch
+        chats_per_batch = config_manager.settings.chatbot.chats_per_batch
 
         return prompt_template.format(
             tool_descriptions=tool_descriptions,
@@ -186,20 +186,20 @@ class ChatbotAgent:
             params = tool_call.get("params", {})
             result = await self.tool_manager.execute_tool(tool_name, **params)
             
-            if agent_name == 'chatbot_agent' and tool_name == "post_chat_message" and result.get("status") == "success":
+            if agent_name == 'chatbot' and tool_name == "post_chat_message" and result.get("status") == "success":
                 text_to_post = result.get("text_to_post", "")
                 if text_to_post:
                     nickname = self.nickname_generator.generate_nickname()
                     message = {"username": nickname, "text": text_to_post}
                     generated_messages.append(message)
-                    await self._append_to_history(path_manager.chatbot_agent_history_path, {'role': 'assistant', 'content': f"{nickname}: {text_to_post}"})
+                    await self._append_to_history(path_manager.chatbot_history_path, {'role': 'assistant', 'content': f"{nickname}: {text_to_post}"})
         logger.info(f"Returning generated messages: {generated_messages}")
         return generated_messages
 
     async def generate_chat_messages(self, neuro_speech: str, recent_history: List[Dict[str, str]]) -> List[Dict[str, str]]:
         """The main actor loop to generate chat messages."""
         for entry in recent_history:
-            await self._append_to_history(path_manager.chatbot_agent_history_path, entry)
+            await self._append_to_history(path_manager.chatbot_history_path, entry)
         
         prompt = await self._build_chatbot_prompt(neuro_speech, recent_history)
         response_text = await self.chatbot_llm.generate(prompt)
@@ -208,7 +208,7 @@ class ChatbotAgent:
         tool_calls = self._parse_tool_calls(response_text)
         if not tool_calls: return []
 
-        messages = await self._execute_tool_calls(tool_calls, 'chatbot_agent')
+        messages = await self._execute_tool_calls(tool_calls, 'chatbot')
         
         self.turn_counter += 1
         if self.turn_counter >= self.reflection_threshold:
@@ -220,7 +220,7 @@ class ChatbotAgent:
         """The main thinker loop to consolidate memories."""
         logger.info("Chatbot is reflecting on recent conversations...")
         self.turn_counter = 0
-        history = await self._read_history(path_manager.chatbot_agent_history_path, limit=50)
+        history = await self._read_history(path_manager.chatbot_history_path, limit=50)
         if len(history) < self.reflection_threshold:
             return
 
@@ -232,4 +232,4 @@ class ChatbotAgent:
         if not tool_calls: return
 
         await self._execute_tool_calls(tool_calls, 'chatbot_memory_agent')
-        logger.info("Chatbot memory consolidation complete.")
+        logger.info("Chatbot memory consolidation complete.")

neuro_simulator/chatbot/llm.py

@@ -31,34 +31,37 @@ class ChatbotLLMClient:
 
         logger.info("First use of Chatbot's LLMClient, performing initialization...")
         settings = config_manager.settings
-        # Use the new chatbot_agent config block
-        provider = settings.chatbot_agent.agent_provider.lower()
         
-        if provider == "gemini":
-            api_key = settings.api_keys.gemini_api_key
-            if not api_key:
-                raise ValueError("GEMINI_API_KEY is not set in configuration for the chatbot agent.")
-            
-            self.client = genai.Client(api_key=api_key)
-            self.model_name = settings.chatbot_agent.agent_model
+        provider_id = settings.chatbot.llm_provider_id
+        if not provider_id:
+            raise ValueError("LLM Provider ID is not set for the chatbot.")
+
+        provider_config = next((p for p in settings.llm_providers if p.provider_id == provider_id), None)
+        if not provider_config:
+            raise ValueError(f"LLM Provider with ID '{provider_id}' not found in configuration.")
+
+        provider_type = provider_config.provider_type.lower()
+        self.model_name = provider_config.model_name
+
+        if provider_type == "gemini":
+            if not provider_config.api_key:
+                raise ValueError(f"API key for Gemini provider '{provider_config.display_name}' is not set.")
+            self.client = genai.Client(api_key=provider_config.api_key)
             self._generate_func = self._generate_gemini
             
-        elif provider == "openai":
-            api_key = settings.api_keys.openai_api_key
-            if not api_key:
-                raise ValueError("OPENAI_API_KEY is not set in configuration for the chatbot agent.")
-            
-            self.model_name = settings.chatbot_agent.agent_model
+        elif provider_type == "openai":
+            if not provider_config.api_key:
+                raise ValueError(f"API key for OpenAI provider '{provider_config.display_name}' is not set.")
             self.client = AsyncOpenAI(
-                api_key=api_key, 
-                base_url=settings.api_keys.openai_api_base_url
+                api_key=provider_config.api_key, 
+                base_url=provider_config.base_url
             )
             self._generate_func = self._generate_openai
         else:
-            raise ValueError(f"Unsupported agent provider in chatbot_agent config: {provider}")
+            raise ValueError(f"Unsupported provider type in chatbot config: {provider_type}")
             
         self._initialized = True
-        logger.info(f"Chatbot LLM client initialized. Provider: {provider.upper()}, Model: {self.model_name}")
+        logger.info(f"Chatbot LLM client initialized. Provider: {provider_type.upper()}, Model: {self.model_name}")
 
     async def _generate_gemini(self, prompt: str, max_tokens: int) -> str:
         """Generates text using the Gemini model."""

neuro_simulator/chatbot/nickname_gen/generator.py

@@ -50,7 +50,7 @@ class NicknameGenerator:
         if not self.base_adjectives or not self.base_nouns:
             logger.warning("Base adjective or noun pools are empty. Nickname generation quality will be affected.")
 
-        if config_manager.settings.chatbot_agent.nickname_generation.enable_dynamic_pool:
+        if config_manager.settings.chatbot.nickname_generation.enable_dynamic_pool:
             await self._populate_dynamic_pools()
         
         logger.info("NicknameGenerator initialized.")
@@ -58,7 +58,7 @@ class NicknameGenerator:
     async def _populate_dynamic_pools(self):
         """Uses an LLM to generate and populate the dynamic word pools."""
         logger.info("Attempting to populate dynamic nickname pools using LLM...")
-        pool_size = config_manager.settings.chatbot_agent.nickname_generation.dynamic_pool_size
+        pool_size = config_manager.settings.chatbot.nickname_generation.dynamic_pool_size
         try:
             adj_prompt = f"Generate a list of {pool_size} diverse, cool-sounding English adjectives for online usernames. Output only the words, one per line."
             noun_prompt = f"Generate a list of {pool_size} diverse, cool-sounding English nouns for online usernames. Output only the words, one per line."
@@ -141,4 +141,4 @@ class NicknameGenerator:
             k=1
         )[0]
 
-        return chosen_strategy()
+        return chosen_strategy()

neuro_simulator/chatbot/tools/manager.py

@@ -1,5 +1,7 @@
 # neuro_simulator/chatbot/tools/manager.py
-"""The central tool manager for the chatbot agent."""
+"""
+The central tool manager for the chatbot agent.
+"""
 
 import importlib
 import inspect
@@ -56,18 +58,18 @@ class ChatbotToolManager:
     def _load_allocations(self):
         """Loads tool allocations from JSON files, creating defaults if they don't exist."""
         default_allocations = {
-            "chatbot_agent": ["post_chat_message"],
+            "chatbot": ["post_chat_message"],
             "chatbot_memory_agent": ["add_temp_memory"] # Add more memory tools later
         }
 
         # Load actor agent allocations
-        if path_manager.chatbot_agent_tools_path.exists():
-            with open(path_manager.chatbot_agent_tools_path, 'r', encoding='utf-8') as f:
-                self.agent_tool_allocations['chatbot_agent'] = json.load(f)
+        if path_manager.chatbot_tools_path.exists():
+            with open(path_manager.chatbot_tools_path, 'r', encoding='utf-8') as f:
+                self.agent_tool_allocations['chatbot'] = json.load(f)
         else:
-            self.agent_tool_allocations['chatbot_agent'] = default_allocations['chatbot_agent']
-            with open(path_manager.chatbot_agent_tools_path, 'w', encoding='utf-8') as f:
-                json.dump(default_allocations['chatbot_agent'], f, indent=2)
+            self.agent_tool_allocations['chatbot'] = default_allocations['chatbot']
+            with open(path_manager.chatbot_tools_path, 'w', encoding='utf-8') as f:
+                json.dump(default_allocations['chatbot'], f, indent=2)
 
         # Load thinker agent allocations
         if path_manager.chatbot_memory_agent_tools_path.exists():

neuro_simulator/cli.py

@@ -48,8 +48,8 @@ def main():
                 shutil.copy(src, dest)
                 logging.info(f"Copied default file to {dest}")
 
-        # Copy config.yaml.example
-        copy_if_not_exists(package_source_path / "config.yaml.example", work_dir / "config.yaml.example")
+        # Copy config.yaml if it doesn't exist
+        copy_if_not_exists(package_source_path / "config.yaml", work_dir / "config.yaml")
 
         # Copy prompts
         copy_if_not_exists(package_source_path / "agent" / "neuro_prompt.txt", path_manager.path_manager.neuro_prompt_path)
@@ -60,12 +60,11 @@ def main():
         copy_if_not_exists(package_source_path / "agent" / "memory" / "init_memory.json", path_manager.path_manager.init_memory_path)
         copy_if_not_exists(package_source_path / "agent" / "memory" / "temp_memory.json", path_manager.path_manager.temp_memory_path)
 
-        # Copy default assets directory
-        source_assets_dir = package_source_path / "assets"
-        destination_assets_dir = path_manager.path_manager.assets_dir
-        if not destination_assets_dir.exists():
-            shutil.copytree(source_assets_dir, destination_assets_dir)
-            logging.info(f"Copied default asset directory to {destination_assets_dir}")
+        # Copy default video asset if it doesn't exist
+        copy_if_not_exists(
+            package_source_path / "assets" / "neuro_start.mp4",
+            path_manager.path_manager.assets_dir / "neuro_start.mp4"
+        )
 
     except Exception as e:
         logging.warning(f"Could not copy all default files: {e}")
@@ -78,10 +77,6 @@ def main():
     main_config_path = path_manager.path_manager.working_dir / "config.yaml"
     try:
         config_manager.load(str(main_config_path))
-    except FileNotFoundError:
-        logging.error(f"FATAL: Configuration file '{main_config_path.name}' not found.")
-        logging.error(f"If this is your first time, please rename 'config.yaml.example' to 'config.yaml' after filling it out.")
-        sys.exit(1)
     except ValidationError as e:
         logging.error(f"FATAL: Configuration error in '{main_config_path.name}':")
         logging.error(e)

neuro_simulator/core/agent_factory.py

@@ -19,32 +19,23 @@ config_manager.register_update_callback(_reset_agent_on_config_update)
 
 async def create_agent() -> BaseAgent:
     """
-    Factory function to create and initialize an agent instance based on the configuration.
+    Factory function to create and initialize the agent instance.
     Returns a cached instance unless the configuration has changed.
     """
     global _agent_instance
     if _agent_instance is not None:
         return _agent_instance
 
-    agent_type = config_manager.settings.agent_type
-    logger.info(f"Creating new agent instance of type: {agent_type}")
+    logger.info(f"Creating new agent instance...")
     
-    if agent_type == "builtin":
-        from ..services.builtin import BuiltinAgentWrapper, initialize_builtin_agent
-        
-        agent_impl = await initialize_builtin_agent()
-        
-        if agent_impl is None:
-            raise RuntimeError("Failed to initialize the Builtin agent implementation.")
-        
-        _agent_instance = BuiltinAgentWrapper(agent_impl)
-
-    elif agent_type == "letta":
-        from ..services.letta import LettaAgent
-        _agent_instance = LettaAgent()
+    from ..services.builtin import BuiltinAgentWrapper, initialize_builtin_agent
     
-    else:
-        raise ValueError(f"Unknown agent type: {agent_type}")
+    agent_impl = await initialize_builtin_agent()
+    
+    if agent_impl is None:
+        raise RuntimeError("Failed to initialize the Builtin agent implementation.")
+    
+    _agent_instance = BuiltinAgentWrapper(agent_impl)
 
     await _agent_instance.initialize()
     

neuro_simulator/core/application.py

@@ -18,7 +18,6 @@ from .config import config_manager, AppSettings
 from ..core.agent_factory import create_agent
 from ..agent.core import Agent as LocalAgent
 from ..chatbot.core import ChatbotAgent
-from ..services.letta import LettaAgent
 from ..services.builtin import BuiltinAgentWrapper
 
 # --- API Routers ---
@@ -71,7 +70,7 @@ app.include_router(system_router)
 
 # --- Background Task Definitions ---
 
-chatbot_agent: ChatbotAgent = None
+chatbot: ChatbotAgent = None
 
 async def broadcast_events_task():
     """Broadcasts events from the live_stream_manager's queue to all clients."""
@@ -87,7 +86,7 @@ async def broadcast_events_task():
 
 async def fetch_and_process_audience_chats():
     """Generates a batch of audience chat messages using the new ChatbotAgent."""
-    if not chatbot_agent:
+    if not chatbot:
         return
     try:
         # Get context for the chatbot
@@ -96,7 +95,7 @@ async def fetch_and_process_audience_chats():
         recent_history = get_recent_audience_chats_for_chatbot(limit=10)
 
         # Generate messages
-        generated_messages = await chatbot_agent.generate_chat_messages(
+        generated_messages = await chatbot.generate_chat_messages(
             neuro_speech=context_message,
             recent_history=recent_history
         )
@@ -125,8 +124,8 @@ async def generate_audience_chat_task():
             
             asyncio.create_task(fetch_and_process_audience_chats())
             
-            # Use the interval from the new chatbot_agent config
-            await asyncio.sleep(config_manager.settings.chatbot_agent.generation_interval_sec)
+            # Use the interval from the new chatbot config
+            await asyncio.sleep(config_manager.settings.chatbot.generation_interval_sec)
         except asyncio.CancelledError:
             break
         except Exception as e:
@@ -148,20 +147,14 @@ async def neuro_response_cycle():
                 app_state.last_superchat_time = time.time()
                 await connection_manager.broadcast({"type": "processing_superchat", "data": sc})
 
-                # Agent-specific payload generation for superchats
-                if isinstance(agent, LettaAgent):
-                    selected_chats = [
-                        {"role": "system", "content": "=== RANDOM 10 MSG IN CHATROOM ===\nNO MSG FETCH DUE TO UNPROCESSED HIGHLIGHTED MESSAGE"},
-                        {"role": "system", "content": f"=== HIGHLIGHTED MESSAGE ===\n{sc['username']}: {sc['text']}"}
-                    ]
-                else: # For BuiltinAgent and any other future agents
-                    selected_chats = [{'username': sc['username'], 'text': sc['text']}]
+                # For BuiltinAgent and any other future agents
+                selected_chats = [{'username': sc['username'], 'text': sc['text']}]
 
                 # Clear the regular input queue to prevent immediate follow-up with normal chats
                 get_all_neuro_input_chats()
             else:
                 if is_first_response:
-                    add_to_neuro_input_queue({"username": "System", "text": config_manager.settings.neuro_behavior.initial_greeting})
+                    add_to_neuro_input_queue({"username": "System", "text": config_manager.settings.neuro.initial_greeting})
                     is_first_response = False
                 elif is_neuro_input_queue_empty():
                     await asyncio.sleep(1)
@@ -170,7 +163,7 @@ async def neuro_response_cycle():
                 current_queue_snapshot = get_all_neuro_input_chats()
                 if not current_queue_snapshot:
                     continue
-                sample_size = min(config_manager.settings.neuro_behavior.input_chat_sample_size, len(current_queue_snapshot))
+                sample_size = min(config_manager.settings.neuro.input_chat_sample_size, len(current_queue_snapshot))
                 selected_chats = random.sample(current_queue_snapshot, sample_size)
             
             if not selected_chats:
@@ -192,7 +185,12 @@ async def neuro_response_cycle():
             sentences = [s.strip() for s in re.split(r'(?<=[.!?])\s+', response_text.replace('\n', ' ')) if s.strip()]
             if not sentences: continue
 
-            synthesis_tasks = [synthesize_audio_segment(s) for s in sentences]
+            tts_id = config_manager.settings.neuro.tts_provider_id
+            if not tts_id:
+                logger.warning("TTS Provider ID is not set for the agent. Skipping speech synthesis.")
+                continue
+
+            synthesis_tasks = [synthesize_audio_segment(s, tts_provider_id=tts_id) for s in sentences]
             synthesis_results = await asyncio.gather(*synthesis_tasks, return_exceptions=True)
             
             speech_packages = [
@@ -210,7 +208,7 @@ async def neuro_response_cycle():
             await connection_manager.broadcast({"type": "neuro_speech_segment", "is_end": True})
             live_stream_manager.set_neuro_speaking_status(False)
             
-            await asyncio.sleep(config_manager.settings.neuro_behavior.post_speech_cooldown_sec)
+            await asyncio.sleep(config_manager.settings.neuro.post_speech_cooldown_sec)
 
         except asyncio.TimeoutError:
             logger.warning("Agent response timed out, skipping this cycle.")
@@ -271,10 +269,7 @@ async def startup_event():
     # 2. Initialize queues now that config is loaded
     initialize_queues()
 
-    # 3. Initialize the new Chatbot Agent
-    global chatbot_agent
-    chatbot_agent = ChatbotAgent()
-    await chatbot_agent.initialize()
+    # 3. Chatbot Agent will be initialized on stream start.
 
     # 4. Register callbacks
     async def metadata_callback(settings: AppSettings):
@@ -285,7 +280,7 @@ async def startup_event():
     # 5. Initialize main agent (which will load its own configs)
     try:
         await create_agent()
-        logger.info(f"Successfully initialized agent type: {config_manager.settings.agent_type}")
+        logger.info(f"Successfully initialized agent.")
     except Exception as e:
         logger.critical(f"Agent initialization failed on startup: {e}", exc_info=True)
     
@@ -305,9 +300,9 @@ async def websocket_stream_endpoint(websocket: WebSocket):
     await connection_manager.connect(websocket)
     try:
         await connection_manager.send_personal_message(live_stream_manager.get_initial_state_for_client(), websocket)
-        await connection_manager.send_personal_message({"type": "update_stream_metadata", **config_manager.settings.stream_metadata.model_dump()}, websocket)
+        await connection_manager.send_personal_message({"type": "update_stream_metadata", **config_manager.settings.stream.model_dump()}, websocket)
         
-        initial_chats = get_recent_audience_chats(config_manager.settings.performance.initial_chat_backlog_limit)
+        initial_chats = get_recent_audience_chats(config_manager.settings.server.initial_chat_backlog_limit)
         for chat in initial_chats:
             await connection_manager.send_personal_message({"type": "chat_message", **chat, "is_user_message": False}, websocket)
             await asyncio.sleep(0.01)
@@ -494,6 +489,23 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
 
         # Stream Control Actions
         elif action == "start_stream":
+            # Validate that required providers are set before starting
+            agent_cfg = config_manager.settings.neuro
+            chatbot_cfg = config_manager.settings.chatbot
+            if not agent_cfg.llm_provider_id:
+                raise ValueError("Agent (Neuro) does not have an LLM Provider configured.")
+            if not agent_cfg.tts_provider_id:
+                raise ValueError("Agent (Neuro) does not have a TTS Provider configured.")
+            if not chatbot_cfg.llm_provider_id:
+                raise ValueError("Chatbot does not have an LLM Provider configured.")
+
+            # Initialize chatbot agent on first stream start if not already initialized
+            global chatbot
+            if chatbot is None:
+                logger.info("Initializing ChatbotAgent for the first time...")
+                chatbot = ChatbotAgent()
+                await chatbot.initialize()
+
             logger.info("Start stream action received. Resetting agent memory before starting processes...")
             await agent.reset_memory()
             if not process_manager.is_running:
@@ -549,34 +561,28 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
             response["payload"] = context
 
         elif action == "get_last_prompt":
-            # This is specific to the builtin agent, as Letta doesn't expose its prompt.
-            agent_instance = getattr(agent, 'agent_instance', agent)
-            if not isinstance(agent_instance, LocalAgent):
-                 response["payload"] = {"prompt": "The active agent does not support prompt generation introspection."}
-            else:
-                try:
-                    # 1. Get the recent history from the agent itself
-                    history = await agent_instance.get_neuro_history(limit=10)
-                    
-                    # 2. Reconstruct the 'messages' list that _build_neuro_prompt expects
-                    messages_for_prompt = []
-                    for entry in history:
-                        if entry.get('role') == 'user':
-                            # Content is in the format "username: text"
-                            content = entry.get('content', '')
-                            parts = content.split(':', 1)
-                            if len(parts) == 2:
-                                messages_for_prompt.append({'username': parts[0].strip(), 'text': parts[1].strip()})
-                            elif content: # Handle cases where there's no colon
-                                messages_for_prompt.append({'username': 'user', 'text': content})
-
-                    # 3. Build the prompt using the agent's own internal logic
-                    prompt = await agent_instance._build_neuro_prompt(messages_for_prompt)
-                    response["payload"] = {"prompt": prompt}
-                except Exception as e:
-                    logger.error(f"Error generating last prompt: {e}", exc_info=True)
-                    response["payload"] = {"prompt": f"Failed to generate prompt: {e}"}
-
+            try:
+                # 1. Get the recent history from the agent itself
+                history = await agent.get_message_history(limit=10)
+                
+                # 2. Reconstruct the 'messages' list that _build_neuro_prompt expects
+                messages_for_prompt = []
+                for entry in history:
+                    if entry.get('role') == 'user':
+                        # Content is in the format "username: text"
+                        content = entry.get('content', '')
+                        parts = content.split(':', 1)
+                        if len(parts) == 2:
+                            messages_for_prompt.append({'username': parts[0].strip(), 'text': parts[1].strip()})
+                        elif content: # Handle cases where there's no colon
+                            messages_for_prompt.append({'username': 'user', 'text': content})
+
+                # 3. Build the prompt using the agent's own internal logic
+                prompt = await agent.build_neuro_prompt(messages_for_prompt)
+                response["payload"] = {"prompt": prompt}
+            except Exception as e:
+                logger.error(f"Error generating last prompt: {e}", exc_info=True)
+                response["payload"] = {"prompt": f"Failed to generate prompt: {e}"}
         elif action == "reset_agent_memory":
             await agent.reset_memory()
             response["payload"] = {"status": "success"}
@@ -598,6 +604,3 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
         if request_id:
             response["payload"] = {"status": "error", "message": str(e)}
             await websocket.send_json(response)
-
-
-