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

neuro_simulator/core/agent_interface.py

@@ -0,0 +1,91 @@
+# neuro_simulator/core/agent_interface.py
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Optional
+
+class BaseAgent(ABC):
+    """Abstract base class for all agents, defining a common interface for the server."""
+
+    @abstractmethod
+    async def initialize(self):
+        """Initialize the agent."""
+        pass
+
+    @abstractmethod
+    async def reset_memory(self):
+        """Reset all types of agent memory."""
+        pass
+
+    @abstractmethod
+    async def process_messages(self, messages: List[Dict[str, str]]) -> Dict[str, Any]:
+        """Process messages and generate a response."""
+        pass
+
+    # Memory Block Management
+    @abstractmethod
+    async def get_memory_blocks(self) -> List[Dict[str, Any]]:
+        """Get all memory blocks."""
+        pass
+
+    @abstractmethod
+    async def get_memory_block(self, block_id: str) -> Optional[Dict[str, Any]]:
+        """Get a specific memory block by its ID."""
+        pass
+
+    @abstractmethod
+    async def create_memory_block(self, title: str, description: str, content: List[str]) -> Dict[str, str]:
+        """Create a new memory block."""
+        pass
+
+    @abstractmethod
+    async def update_memory_block(self, block_id: str, title: Optional[str], description: Optional[str], content: Optional[List[str]]):
+        """Update an existing memory block."""
+        pass
+
+    @abstractmethod
+    async def delete_memory_block(self, block_id: str):
+        """Delete a memory block."""
+        pass
+
+    # Init Memory Management
+    @abstractmethod
+    async def get_init_memory(self) -> Dict[str, Any]:
+        """Get the agent's initialization memory."""
+        pass
+
+    @abstractmethod
+    async def update_init_memory(self, memory: Dict[str, Any]):
+        """Update the agent's initialization memory."""
+        pass
+
+    # Temp Memory Management
+    @abstractmethod
+    async def get_temp_memory(self) -> List[Dict[str, Any]]:
+        """Get the agent's temporary memory."""
+        pass
+
+    @abstractmethod
+    async def add_temp_memory(self, content: str, role: str):
+        """Add an item to the agent's temporary memory."""
+        pass
+
+    @abstractmethod
+    async def clear_temp_memory(self):
+        """Clear the agent's temporary memory."""
+        pass
+
+    # Tool Management
+    @abstractmethod
+    async def get_available_tools(self) -> List[Dict[str, Any]]:
+        """Get a list of available tools."""
+        pass
+
+    @abstractmethod
+    async def execute_tool(self, tool_name: str, params: Dict[str, Any]) -> Any:
+        """Execute a tool with given parameters."""
+        pass
+
+    # Context/Message History
+    @abstractmethod
+    async def get_message_history(self, limit: int = 20) -> List[Dict[str, Any]]:
+        """Get the recent message history."""
+        pass

neuro_simulator/core/application.py

@@ -0,0 +1,278 @@
+# neuro_simulator/core/application.py
+"""Main application file: FastAPI app instance, events, and websockets."""
+
+import asyncio
+import json
+import logging
+import random
+import re
+import time
+from pathlib import Path
+from typing import List
+
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+from starlette.websockets import WebSocketState
+
+# --- Core Imports ---
+from .config import config_manager, AppSettings
+from ..core.agent_factory import create_agent
+
+# --- 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 ---
+from ..services.audience import AudienceChatbotManager, get_dynamic_audience_prompt
+from ..services.audio import synthesize_audio_segment
+from ..services.stream import live_stream_manager
+from ..utils.logging import configure_server_logging, server_log_queue, agent_log_queue
+from ..utils.process import process_manager
+from ..utils.queue import (
+    add_to_audience_buffer,
+    add_to_neuro_input_queue,
+    get_recent_audience_chats,
+    is_neuro_input_queue_empty,
+    get_all_neuro_input_chats
+)
+from ..utils.state import app_state
+from ..utils.websocket import connection_manager
+
+# --- Logger Setup ---
+logger = logging.getLogger(__name__.replace("neuro_simulator", "server", 1))
+
+# --- FastAPI App Initialization ---
+app = FastAPI(
+    title="Neuro-Sama Simulator API",
+    version="2.0.0",
+    description="Backend for the Neuro-Sama digital being simulator."
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=config_manager.settings.server.client_origins + ["http://localhost:8080", "https://dashboard.live.jiahui.cafe"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+    expose_headers=["X-API-Token"],
+)
+
+app.include_router(agent_router)
+app.include_router(stream_router)
+app.include_router(system_router)
+
+# --- Background Task Definitions ---
+
+chatbot_manager: AudienceChatbotManager = None
+
+async def broadcast_events_task():
+    """Broadcasts events from the live_stream_manager's queue to all clients."""
+    while True:
+        try:
+            event = await live_stream_manager.event_queue.get()
+            await connection_manager.broadcast(event)
+            live_stream_manager.event_queue.task_done()
+        except asyncio.CancelledError:
+            break
+        except Exception as e:
+            logger.error(f"Error in broadcast_events_task: {e}", exc_info=True)
+
+async def fetch_and_process_audience_chats():
+    """Generates a batch of audience chat messages."""
+    if not chatbot_manager or not chatbot_manager.client:
+        return
+    try:
+        dynamic_prompt = await get_dynamic_audience_prompt()
+        raw_chat_text = await chatbot_manager.client.generate_chat_messages(
+            prompt=dynamic_prompt, 
+            max_tokens=config_manager.settings.audience_simulation.max_output_tokens
+        )
+        
+        parsed_chats = []
+        for line in raw_chat_text.split('\n'):
+            line = line.strip()
+            if ':' in line:
+                username_raw, text = line.split(':', 1)
+                username = username_raw.strip()
+                if username in config_manager.settings.audience_simulation.username_blocklist:
+                    username = random.choice(config_manager.settings.audience_simulation.username_pool)
+                if username and text.strip(): 
+                    parsed_chats.append({"username": username, "text": text.strip()})
+            elif line: 
+                parsed_chats.append({"username": random.choice(config_manager.settings.audience_simulation.username_pool), "text": line})
+        
+        chats_to_broadcast = parsed_chats[:config_manager.settings.audience_simulation.chats_per_batch]
+        
+        for chat in chats_to_broadcast: 
+            add_to_audience_buffer(chat)
+            add_to_neuro_input_queue(chat)
+            broadcast_message = {"type": "chat_message", **chat, "is_user_message": False}
+            await connection_manager.broadcast(broadcast_message)
+            await asyncio.sleep(random.uniform(0.1, 0.4))
+    except Exception as e:
+        logger.error(f"Error in fetch_and_process_audience_chats: {e}", exc_info=True)
+
+async def generate_audience_chat_task():
+    """Periodically triggers the audience chat generation task."""
+    while True:
+        try:
+            asyncio.create_task(fetch_and_process_audience_chats())
+            await asyncio.sleep(config_manager.settings.audience_simulation.chat_generation_interval_sec)
+        except asyncio.CancelledError:
+            break
+
+async def neuro_response_cycle():
+    """The core response loop for the agent."""
+    await app_state.live_phase_started_event.wait()
+    agent = await create_agent()
+    is_first_response = True
+
+    while True:
+        try:
+            if is_first_response:
+                add_to_neuro_input_queue({"username": "System", "text": config_manager.settings.neuro_behavior.initial_greeting})
+                is_first_response = False
+            elif is_neuro_input_queue_empty():
+                await asyncio.sleep(1)
+                continue
+            
+            current_queue_snapshot = get_all_neuro_input_chats()
+            sample_size = min(config_manager.settings.neuro_behavior.input_chat_sample_size, len(current_queue_snapshot))
+            selected_chats = random.sample(current_queue_snapshot, sample_size)
+            
+            response_result = await asyncio.wait_for(agent.process_messages(selected_chats), timeout=20.0)
+            
+            response_text = response_result.get("final_response", "").strip()
+            if not response_text:
+                continue
+
+            async with app_state.neuro_last_speech_lock:
+                app_state.neuro_last_speech = response_text
+
+            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]
+            synthesis_results = await asyncio.gather(*synthesis_tasks, return_exceptions=True)
+            
+            speech_packages = [
+                {"segment_id": i, "text": sentences[i], "audio_base64": res[0], "duration": res[1]}
+                for i, res in enumerate(synthesis_results) if not isinstance(res, Exception)
+            ]
+
+            if not speech_packages: continue
+
+            live_stream_manager.set_neuro_speaking_status(True)
+            for package in speech_packages:
+                await connection_manager.broadcast({"type": "neuro_speech_segment", **package, "is_end": False})
+                await asyncio.sleep(package['duration'])
+            
+            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)
+
+        except asyncio.TimeoutError:
+            logger.warning("Agent response timed out, skipping this cycle.")
+            await asyncio.sleep(5)
+        except asyncio.CancelledError:
+            live_stream_manager.set_neuro_speaking_status(False)
+            break
+        except Exception as e:
+            logger.error(f"Critical error in neuro_response_cycle: {e}", exc_info=True)
+            live_stream_manager.set_neuro_speaking_status(False)
+            await asyncio.sleep(10)
+
+# --- Application Lifecycle Events ---
+
+@app.on_event("startup")
+async def startup_event():
+    """Actions to perform on application startup."""
+    global chatbot_manager
+    configure_server_logging()
+    
+    chatbot_manager = AudienceChatbotManager()
+
+    async def metadata_callback(settings: AppSettings):
+        await live_stream_manager.broadcast_stream_metadata()
+    
+    config_manager.register_update_callback(metadata_callback)
+    config_manager.register_update_callback(chatbot_manager.handle_config_update)
+    
+    try:
+        await create_agent()
+        logger.info(f"Successfully initialized agent type: {config_manager.settings.agent_type}")
+    except Exception as e:
+        logger.critical(f"Agent initialization failed on startup: {e}", exc_info=True)
+    
+    logger.info("FastAPI application has started.")
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Actions to perform on application shutdown."""
+    if process_manager.is_running:
+        process_manager.stop_live_processes()
+    logger.info("FastAPI application has shut down.")
+
+# --- WebSocket Endpoints ---
+
+@app.websocket("/ws/stream")
+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)
+        
+        initial_chats = get_recent_audience_chats(config_manager.settings.performance.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)
+        
+        while True:
+            raw_data = await websocket.receive_text()
+            data = json.loads(raw_data)
+            if data.get("type") == "user_message":
+                user_message = {"username": data.get("username", "User"), "text": data.get("message", "").strip()}
+                if user_message["text"]:
+                    add_to_audience_buffer(user_message)
+                    add_to_neuro_input_queue(user_message)
+                    await connection_manager.broadcast({"type": "chat_message", **user_message, "is_user_message": True})
+    except WebSocketDisconnect:
+        pass
+    finally:
+        connection_manager.disconnect(websocket)
+
+@app.websocket("/ws/admin")
+async def websocket_admin_endpoint(websocket: WebSocket):
+    await websocket.accept()
+    try:
+        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})
+        
+        agent = await create_agent()
+        initial_context = await agent.get_message_history()
+        await websocket.send_json({"type": "agent_context", "action": "update", "messages": initial_context})
+        
+        while websocket.client_state == WebSocketState.CONNECTED:
+            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:
+        logger.info("Admin WebSocket client disconnected.")
+
+# --- Server Entrypoint ---
+
+def run_server(host: str = None, port: int = None):
+    """Runs the FastAPI server with Uvicorn."""
+    import uvicorn
+    server_host = host or config_manager.settings.server.host
+    server_port = port or config_manager.settings.server.port
+    
+    uvicorn.run(
+        "neuro_simulator.core.application:app",
+        host=server_host,
+        port=server_port,
+        reload=False
+    )

neuro_simulator/services/__init__.py

@@ -0,0 +1 @@
+# This file makes the 'services' directory a Python package.

neuro_simulator/{chatbot.py → services/audience.py}

@@ -1,11 +1,16 @@
-# backend/chatbot.py
+# neuro_simulator/services/audience.py
+import asyncio
+import logging
+import random
+
 from google import genai
 from google.genai import types
 from openai import AsyncOpenAI
-import random
-import asyncio
-from .config import config_manager, AppSettings
-import neuro_simulator.shared_state as shared_state
+
+from ..core.config import config_manager, AppSettings
+from ..utils.state import app_state
+
+logger = logging.getLogger(__name__.replace("neuro_simulator", "server", 1))
 
 class AudienceLLMClient:
     async def generate_chat_messages(self, prompt: str, max_tokens: int) -> str:
@@ -15,13 +20,11 @@ class GeminiAudienceLLM(AudienceLLMClient):
     def __init__(self, api_key: str, model_name: str):
         if not api_key:
             raise ValueError("Gemini API Key is not provided for GeminiAudienceLLM.")
-        # 根据新文档，正确初始化客户端
         self.client = genai.Client(api_key=api_key)
         self.model_name = model_name
-        print(f"已初始化 GeminiAudienceLLM (new SDK)，模型: {self.model_name}")
+        logger.info(f"Initialized GeminiAudienceLLM (new SDK), model: {self.model_name}")
 
     async def generate_chat_messages(self, prompt: str, max_tokens: int) -> str:
-        # 根据新文档，使用正确的异步方法和参数
         response = await self.client.aio.models.generate_content(
             model=self.model_name,
             contents=prompt,
@@ -45,7 +48,7 @@ class OpenAIAudienceLLM(AudienceLLMClient):
             raise ValueError("OpenAI API Key is not provided for OpenAIAudienceLLM.")
         self.client = AsyncOpenAI(api_key=api_key, base_url=base_url)
         self.model_name = model_name
-        print(f"已初始化 OpenAIAudienceLLM，模型: {self.model_name}，API Base: {base_url}")
+        logger.info(f"Initialized OpenAIAudienceLLM, model: {self.model_name}, API Base: {base_url}")
 
     async def generate_chat_messages(self, prompt: str, max_tokens: int) -> str:
         response = await self.client.chat.completions.create(
@@ -60,45 +63,42 @@ class OpenAIAudienceLLM(AudienceLLMClient):
 
 async def get_dynamic_audience_prompt() -> str:
     current_neuro_speech = ""
-    async with shared_state.neuro_last_speech_lock:
-        current_neuro_speech = shared_state.neuro_last_speech
-    
-    # 使用 settings 对象中的模板和变量
+    async with app_state.neuro_last_speech_lock:
+        current_neuro_speech = app_state.neuro_last_speech
+
     prompt = config_manager.settings.audience_simulation.prompt_template.format(
         neuro_speech=current_neuro_speech,
         num_chats_to_generate=config_manager.settings.audience_simulation.chats_per_batch
     )
     return prompt
 
-class ChatbotManager:
+class AudienceChatbotManager:
     def __init__(self):
         self.client: AudienceLLMClient = self._create_client(config_manager.settings)
         self._last_checked_settings: dict = config_manager.settings.audience_simulation.model_dump()
-        print("ChatbotManager initialized.")
+        logger.info("AudienceChatbotManager initialized.")
 
     def _create_client(self, settings: AppSettings) -> AudienceLLMClient:
         provider = settings.audience_simulation.llm_provider
-        print(f"正在为 provider 创建新的 audience LLM client: {provider}")
+        logger.info(f"Creating new audience LLM client for provider: {provider}")
         if provider.lower() == "gemini":
             if not settings.api_keys.gemini_api_key:
-                raise ValueError("GEMINI_API_KEY 未在配置中设置")
+                raise ValueError("GEMINI_API_KEY not set in config")
             return GeminiAudienceLLM(api_key=settings.api_keys.gemini_api_key, model_name=settings.audience_simulation.gemini_model)
         elif provider.lower() == "openai":
             if not settings.api_keys.openai_api_key:
-                raise ValueError("OPENAI_API_KEY 未在配置中设置")
+                raise ValueError("OPENAI_API_KEY not set in config")
             return OpenAIAudienceLLM(api_key=settings.api_keys.openai_api_key, model_name=settings.audience_simulation.openai_model, base_url=settings.api_keys.openai_api_base_url)
         else:
-            raise ValueError(f"不支持的 AUDIENCE_LLM_PROVIDER: {provider}")
+            raise ValueError(f"Unsupported AUDIENCE_LLM_PROVIDER: {provider}")
 
     def handle_config_update(self, new_settings: AppSettings):
         new_audience_settings = new_settings.audience_simulation.model_dump()
         if new_audience_settings != self._last_checked_settings:
-            print("检测到观众模拟设置已更改，正在重新初始化 LLM client...")
+            logger.info("Audience simulation settings changed, re-initializing LLM client...")
             try:
                 self.client = self._create_client(new_settings)
                 self._last_checked_settings = new_audience_settings
-                print("LLM client 已成功热重载。")
+                logger.info("LLM client hot-reloaded successfully.")
             except Exception as e:
-                print(f"错误：热重载 LLM client 失败: {e}")
-        else:
-            print("观众模拟设置未更改，跳过 LLM client 重载。")
+                logger.error(f"Error hot-reloading LLM client: {e}", exc_info=True)

neuro_simulator/{audio_synthesis.py → services/audio.py}

@@ -1,24 +1,27 @@
-# backend/audio_synthesis.py
-import html
+# neuro_simulator/services/audio.py
+import asyncio
 import base64
+import html
+import logging
+from pathlib import Path
+
 import azure.cognitiveservices.speech as speechsdk
-import asyncio
-from .config import config_manager
+
+from ..core.config import config_manager
+
+logger = logging.getLogger(__name__.replace("neuro_simulator", "server", 1))
 
 async def synthesize_audio_segment(text: str, voice_name: str = None, pitch: float = None) -> tuple[str, float]:
     """
-    使用 Azure TTS 合成音频。
-    如果 voice_name 或 pitch 未提供，则使用配置中的默认值。
-    返回 Base64 编码的音频字符串和音频时长（秒）。
+    Synthesizes audio using Azure TTS.
+    Returns a Base64 encoded audio string and the audio duration in seconds.
     """
-    # 使用 config_manager.settings 中的值
     azure_key = config_manager.settings.api_keys.azure_speech_key
     azure_region = config_manager.settings.api_keys.azure_speech_region
     
     if not azure_key or not azure_region:
-        raise ValueError("Azure Speech Key 或 Region 未在配置中设置。")
+        raise ValueError("Azure Speech Key or Region is not set in the configuration.")
 
-    # 如果未传入参数，则使用配置的默认值
     final_voice_name = voice_name if voice_name is not None else config_manager.settings.tts.voice_name
     final_pitch = pitch if pitch is not None else config_manager.settings.tts.voice_pitch
 
@@ -52,15 +55,15 @@ async def synthesize_audio_segment(text: str, voice_name: str = None, pitch: flo
             audio_data = result.audio_data
             encoded_audio = base64.b64encode(audio_data).decode('utf-8')
             audio_duration_sec = result.audio_duration.total_seconds()
-            print(f"TTS 合成完成: '{text[:30]}...' (时长: {audio_duration_sec:.2f}s)")
+            logger.info(f"TTS synthesis completed: '{text[:30]}...' (Duration: {audio_duration_sec:.2f}s)")
             return encoded_audio, audio_duration_sec
         else:
             cancellation_details = result.cancellation_details
-            error_message = f"TTS 合成失败/取消 (原因: {cancellation_details.reason})。文本: '{text}'"
+            error_message = f"TTS synthesis failed (Reason: {cancellation_details.reason}). Text: '{text}'"
             if cancellation_details.error_details:
-                error_message += f" | 详情: {cancellation_details.error_details}"
-            print(f"错误: {error_message}")
+                error_message += f" | Details: {cancellation_details.error_details}"
+            logger.error(error_message)
             raise Exception(error_message)
     except Exception as e:
-        print(f"错误: 在调用 Azure TTS SDK 时发生异常: {e}")
+        logger.error(f"An exception occurred during the Azure TTS SDK call: {e}", exc_info=True)
         raise

neuro_simulator/services/builtin.py

@@ -0,0 +1,87 @@
+# neuro_simulator/services/builtin.py
+"""Builtin agent module for Neuro Simulator"""
+
+import asyncio
+import re
+import logging
+from typing import List, Dict, Any, Optional
+
+from ..core.agent_interface import BaseAgent
+from ..agent.core import Agent as LocalAgent
+from ..services.stream import live_stream_manager
+
+logger = logging.getLogger(__name__.replace("neuro_simulator", "server", 1))
+
+async def initialize_builtin_agent() -> Optional[LocalAgent]:
+    """Initializes the builtin agent instance and returns it."""
+    try:
+        working_dir = live_stream_manager._working_dir
+        agent_instance = LocalAgent(working_dir=working_dir)
+        await agent_instance.initialize()
+        logger.info("Builtin agent implementation initialized successfully.")
+        return agent_instance
+    except Exception as e:
+        logger.error(f"Failed to initialize local agent implementation: {e}", exc_info=True)
+        return None
+
+class BuiltinAgentWrapper(BaseAgent):
+    """Wrapper for the builtin agent to implement the BaseAgent interface."""    
+    def __init__(self, agent_instance: LocalAgent):
+        self.agent_instance = agent_instance
+        
+    async def initialize(self):
+        if self.agent_instance is None:
+            raise RuntimeError("Builtin agent not initialized")
+        await self.agent_instance.initialize()
+
+    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)
+
+    # Memory Block Management
+    async def get_memory_blocks(self) -> List[Dict[str, Any]]:
+        blocks_dict = await self.agent_instance.memory_manager.get_core_memory_blocks()
+        return list(blocks_dict.values())
+
+    async def get_memory_block(self, block_id: str) -> Optional[Dict[str, Any]]:
+        return await self.agent_instance.memory_manager.get_core_memory_block(block_id)
+
+    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)
+        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)
+
+    async def delete_memory_block(self, block_id: str):
+        await self.agent_instance.memory_manager.delete_core_memory_block(block_id)
+
+    # Init Memory Management
+    async def get_init_memory(self) -> Dict[str, Any]:
+        return self.agent_instance.memory_manager.init_memory
+
+    async def update_init_memory(self, memory: Dict[str, Any]):
+        await self.agent_instance.memory_manager.update_init_memory(memory)
+
+    # Temp Memory Management
+    async def get_temp_memory(self) -> List[Dict[str, Any]]:
+        return self.agent_instance.memory_manager.temp_memory
+
+    async def add_temp_memory(self, content: str, role: str):
+        await self.agent_instance.memory_manager.add_temp_memory(content, role)
+
+    async def clear_temp_memory(self):
+        await self.agent_instance.memory_manager.reset_temp_memory()
+
+    # 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)
+
+    # 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)