neuro-simulator 0.4.3__py3-none-any.whl → 0.5.0__py3-none-any.whl

neuro_simulator/chatbot/tools/base.py

@@ -0,0 +1,47 @@
+# neuro_simulator/chatbot/tools/base.py
+"""Base classes and definitions for the chatbot tool system."""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any, List
+
+class BaseChatbotTool(ABC):
+    """
+    Abstract base class for all chatbot tools.
+    """
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """The unique name of the tool."""
+        pass
+
+    @property
+    @abstractmethod
+    def description(self) -> str:
+        """A concise description of what the tool does, intended for use by an LLM."""
+        pass
+
+    @property
+    @abstractmethod
+    def parameters(self) -> List[Dict[str, Any]]:
+        """
+        A list of dictionaries describing the tool's parameters.
+        """
+        pass
+
+    @abstractmethod
+    async def execute(self, **kwargs: Any) -> Dict[str, Any]:
+        """
+        The method that executes the tool's logic.
+        """
+        pass
+
+    def get_schema(self) -> Dict[str, Any]:
+        """
+        Returns a serializable dictionary representing the tool's public schema.
+        """
+        return {
+            "name": self.name,
+            "description": self.description,
+            "parameters": self.parameters
+        }

neuro_simulator/chatbot/tools/manager.py

@@ -0,0 +1,100 @@
+# neuro_simulator/chatbot/tools/manager.py
+"""The central tool manager for the chatbot agent."""
+
+import importlib
+import inspect
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Any, Dict, List
+
+from neuro_simulator.core.path_manager import path_manager
+from .base import BaseChatbotTool
+from ..memory.manager import ChatbotMemoryManager
+
+logger = logging.getLogger(__name__.replace("neuro_simulator", "chatbot", 1))
+
+class ChatbotToolManager:
+    """
+    Acts as a central registry and executor for all available chatbot tools.
+    """
+
+    def __init__(self, memory_manager: ChatbotMemoryManager):
+        self.memory_manager = memory_manager
+        self.tools_dir = path_manager.chatbot_builtin_tools_dir
+        self.tools: Dict[str, BaseChatbotTool] = {}
+        self.agent_tool_allocations: Dict[str, List[str]] = {}
+
+    def load_tools(self):
+        """Dynamically scans the tools directory, imports modules, and registers tool instances."""
+        logger.info(f"Loading chatbot tools from: {self.tools_dir}")
+        self.tools = {}
+        if not self.tools_dir.exists():
+            logger.warning(f"Chatbot tools directory not found: {self.tools_dir}")
+            return
+
+        for filename in os.listdir(self.tools_dir):
+            if filename.endswith('.py') and not filename.startswith('__'):
+                module_path = self.tools_dir / filename
+                spec = importlib.util.spec_from_file_location(module_path.stem, module_path)
+                if spec and spec.loader:
+                    try:
+                        module = importlib.util.module_from_spec(spec)
+                        spec.loader.exec_module(module)
+                        for _, cls in inspect.getmembers(module, inspect.isclass):
+                            if issubclass(cls, BaseChatbotTool) and cls is not BaseChatbotTool:
+                                tool_instance = cls(memory_manager=self.memory_manager)
+                                if tool_instance.name in self.tools:
+                                    logger.warning(f"Duplicate chatbot tool name '{tool_instance.name}' found. Overwriting.")
+                                self.tools[tool_instance.name] = tool_instance
+                                logger.info(f"Successfully loaded chatbot tool: {tool_instance.name}")
+                    except Exception as e:
+                        logger.error(f"Failed to load chatbot tool from {module_path}: {e}", exc_info=True)
+        self._load_allocations()
+
+    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_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)
+        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)
+
+        # Load thinker agent allocations
+        if path_manager.chatbot_memory_agent_tools_path.exists():
+            with open(path_manager.chatbot_memory_agent_tools_path, 'r', encoding='utf-8') as f:
+                self.agent_tool_allocations['chatbot_memory_agent'] = json.load(f)
+        else:
+            self.agent_tool_allocations['chatbot_memory_agent'] = default_allocations['chatbot_memory_agent']
+            with open(path_manager.chatbot_memory_agent_tools_path, 'w', encoding='utf-8') as f:
+                json.dump(default_allocations['chatbot_memory_agent'], f, indent=2)
+        
+        logger.info(f"Chatbot tool allocations loaded: {self.agent_tool_allocations}")
+
+    def get_tool_schemas_for_agent(self, agent_name: str) -> List[Dict[str, Any]]:
+        """Gets the tool schemas for a specific agent based on its allocation."""
+        allowed_names = set(self.agent_tool_allocations.get(agent_name, []))
+        if not allowed_names:
+            return []
+        return [tool.get_schema() for tool in self.tools.values() if tool.name in allowed_names]
+
+    async def execute_tool(self, tool_name: str, **kwargs: Any) -> Dict[str, Any]:
+        if tool_name not in self.tools:
+            logger.error(f"Attempted to execute non-existent chatbot tool: {tool_name}")
+            return {"error": f"Tool '{tool_name}' not found."}
+        tool = self.tools[tool_name]
+        try:
+            result = await tool.execute(**kwargs)
+            return result
+        except Exception as e:
+            logger.error(f"Error executing chatbot tool '{tool_name}' with params {kwargs}: {e}", exc_info=True)
+            return {"error": f"An unexpected error occurred: {str(e)}"}

neuro_simulator/chatbot/tools/post_chat_message.py

@@ -0,0 +1,49 @@
+# neuro_simulator/chatbot/tools/post_chat_message.py
+"""The Post Chat Message tool for the chatbot agent."""
+
+import logging
+from typing import Dict, Any, List
+
+from neuro_simulator.chatbot.tools.base import BaseChatbotTool
+from neuro_simulator.chatbot.memory.manager import ChatbotMemoryManager
+
+logger = logging.getLogger(__name__.replace("neuro_simulator", "chatbot", 1))
+
+class PostChatMessageTool(BaseChatbotTool):
+    """Tool for the chatbot to post a message to the stream chat."""
+
+    def __init__(self, memory_manager: ChatbotMemoryManager):
+        self.memory_manager = memory_manager
+
+    @property
+    def name(self) -> str:
+        return "post_chat_message"
+
+    @property
+    def description(self) -> str:
+        return "Posts a text message to the stream chat, as if you are a viewer." 
+
+    @property
+    def parameters(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                "name": "text",
+                "type": "string",
+                "description": "The content of the chat message to post.",
+                "required": True,
+            }
+        ]
+
+    async def execute(self, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Executes the action. This tool doesn't *actually* send the message,
+        it just structures the output for the core agent logic to handle.
+        """
+        text = kwargs.get("text")
+        if not isinstance(text, str) or not text:
+            raise ValueError("The 'text' parameter must be a non-empty string.")
+        
+        logger.info(f"Chatbot decided to say: {text}")
+        # The result is the text to be posted. The core agent will combine this
+        # with a generated nickname before sending it to the stream.
+        return {"status": "success", "text_to_post": text}

neuro_simulator/config.yaml.example

@@ -53,6 +53,22 @@ agent:
   # Agent使用的模型，切换gemini/openai时记得更改
   agent_model: "gemini-2.5-flash-lite"
 
+# --- 内建 Chatbot Agent 设置 ---
+# 仅当需要启用新的有状态 Chatbot Agent 时配置
+chatbot_agent:
+  # Agent的API服务商，支持"gemini"和"openai"
+  agent_provider: "gemini"
+  # Agent使用的模型，建议使用一个速度快、成本低的模型
+  agent_model: "gemini-1.5-flash-latest"
+  # Chatbot Agent 生成间隔（秒）
+  generation_interval_sec: 3
+  # 每次生成的消息数量
+  chats_per_batch: 2
+  # 昵称生成配置
+  nickname_generation:
+    enable_dynamic_pool: true  # 开关：是否在启动时动态生成词库
+    dynamic_pool_size: 50      # 动态生成池的大小（形容词和名词各50个）
+
 # --- Neuro 行为与节奏控制 ---
 neuro_behavior:
   # 输入聊天采样数量 - 每次生成 Neuro 回复时从观众聊天中采样的消息数量，不建议太长
@@ -64,62 +80,6 @@ neuro_behavior:
   # 初始问候语 - 直播开始时给 Neuro 的系统提示语
   initial_greeting: "The stream has just started. Greet your audience and say hello!"
 
-# --- Chatbot 配置 ---
-audience_simulation:
-  # LLM 提供商 - 选择用于生成观众聊天的 AI 服务，只能是 'gemini' 或 'openai'
-  llm_provider: "gemini"
-  
-  # Gemini 模型 - 使用 Gemini 服务时的具体模型名称
-  # 推荐使用gemma-3-27b-it，每天可免费调用14000次（15:00 GMT+8 刷新次数）
-  gemini_model: "gemma-3-27b-it"
-  
-  # OpenAI 模型 - 使用 OpenAI 服务时的具体模型名称
-  # 推荐使用SiliconFlow，9B以下模型免费不限量调用（注意TPM限制）
-  openai_model: "THUDM/GLM-4-9B-0414"
-  
-  # LLM 温度 - 控制 AI 生成内容的随机性，值越高越随机（0-2之间）
-  llm_temperature: 0.7
-  
-  # 聊天生成间隔（秒） - 调用 Chatbot 生成新观众聊天的时间间隔
-  chat_generation_interval_sec: 2
-  
-  # 每批聊天生成数量 - 每次调用 Chatbot 时生成的聊天消息数量
-  chats_per_batch: 3
-  
-  # 最大输出 Token 数 - 单次调用 Chatbot 时允许生成的最大 token 数量
-  max_output_tokens: 300
-  
-  # Chatbot 提示模板 - 用于指导 AI 生成观众聊天内容的提示词
-  # 其中 {neuro_speech} 和 {num_chats_to_generate} 会被动态替换
-  prompt_template: |
-    You are a Twitch live stream viewer. Your goal is to generate short, realistic, and relevant chat messages.
-    The streamer, Neuro-Sama, just said the following:
-    ---
-    {neuro_speech}
-    ---
-    Based on what Neuro-Sama said, generate a variety of chat messages. Your messages should be:
-    - Directly reacting to her words.
-    - Asking follow-up questions.
-    - Using relevant Twitch emotes (like LUL, Pog, Kappa, etc.).
-    - General banter related to the topic.
-    - Short and punchy, like real chat messages.
-    Do NOT act as the streamer. Do NOT generate full conversations.
-    Generate exactly {num_chats_to_generate} distinct chat messages. Each message must be prefixed with a DIFFERENT fictional username, like 'ChatterBoy: message text', 'EmoteFan: message text'.
-  
-  # 用户名黑名单 - 当检测到这些用户名时会自动替换为 username_pool 中的用户名
-  username_blocklist: ["ChatterBoy", "EmoteFan", "Username", "User"]
-  
-  # 用户名池 - 用于替换黑名单用户名或生成新用户名（有时候Chatbot LLM可能未给出用户名）的候选列表
-  username_pool:
-    - "ChatterBox"
-    - "EmoteLord"
-    - "QuestionMark"
-    - "StreamFan"
-    - "PixelPundit"
-    - "CodeSage"
-    - "DataDiver"
-    - "ByteBard"
-
 # --- 音频合成 (TTS) 配置 ---
 tts:
   # 语音名称 - 不要调整这个设置

neuro_simulator/core/application.py

@@ -18,6 +18,7 @@ from starlette.websockets import WebSocketState
 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
 
@@ -25,7 +26,6 @@ from ..services.builtin import BuiltinAgentWrapper
 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
@@ -37,6 +37,7 @@ from ..utils.queue import (
     is_neuro_input_queue_empty,
     get_all_neuro_input_chats,
     initialize_queues,
+    get_recent_audience_chats_for_chatbot,
 )
 from ..utils.state import app_state
 from ..utils.websocket import connection_manager
@@ -64,7 +65,7 @@ app.include_router(system_router)
 
 # --- Background Task Definitions ---
 
-chatbot_manager: AudienceChatbotManager = None
+chatbot_agent: ChatbotAgent = None
 
 async def broadcast_events_task():
     """Broadcasts events from the live_stream_manager's queue to all clients."""
@@ -79,48 +80,52 @@ async def broadcast_events_task():
             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:
+    """Generates a batch of audience chat messages using the new ChatbotAgent."""
+    if not chatbot_agent:
         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
+        # Get context for the chatbot
+        current_neuro_speech = app_state.neuro_last_speech
+        context_message = current_neuro_speech if current_neuro_speech else "The stream is starting! Let's say hello and get the hype going!"
+        recent_history = get_recent_audience_chats_for_chatbot(limit=10)
+
+        # Generate messages
+        generated_messages = await chatbot_agent.generate_chat_messages(
+            neuro_speech=context_message,
+            recent_history=recent_history
         )
         
-        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: 
+        if not generated_messages:
+            return
+
+        # Process and broadcast generated messages
+        for chat in generated_messages: 
             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))
+            # Stagger the messages slightly to feel more natural
+            await asyncio.sleep(random.uniform(0.2, 0.8))
+            
     except Exception as e:
-        logger.error(f"Error in fetch_and_process_audience_chats: {e}", exc_info=True)
+        logger.error(f"Error in new 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:
+            # Wait until the live phase starts
+            # await app_state.live_phase_started_event.wait() 
+            
             asyncio.create_task(fetch_and_process_audience_chats())
-            await asyncio.sleep(config_manager.settings.audience_simulation.chat_generation_interval_sec)
+            
+            # Use the interval from the new chatbot_agent config
+            await asyncio.sleep(config_manager.settings.chatbot_agent.generation_interval_sec)
         except asyncio.CancelledError:
             break
+        except Exception as e:
+            logger.error(f"Error in generate_audience_chat_task: {e}", exc_info=True)
+            await asyncio.sleep(10) # Avoid fast-looping on persistent errors
 
 async def neuro_response_cycle():
     """The core response loop for the agent."""
@@ -223,18 +228,18 @@ async def startup_event():
     # 2. Initialize queues now that config is loaded
     initialize_queues()
 
-    # 4. Initialize other managers/services that depend on config
-    global chatbot_manager
-    chatbot_manager = AudienceChatbotManager()
+    # 3. Initialize the new Chatbot Agent
+    global chatbot_agent
+    chatbot_agent = ChatbotAgent()
+    await chatbot_agent.initialize()
 
-    # 5. Register callbacks
+    # 4. Register callbacks
     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)
     
-    # 6. Initialize agent (which will load its own configs)
+    # 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}")

neuro_simulator/core/config.py

@@ -1,5 +1,6 @@
 # backend/config.py
 import shutil
+import sys
 from pathlib import Path
 import yaml
 from pydantic import BaseModel, Field
@@ -39,17 +40,7 @@ class NeuroBehaviorSettings(BaseModel):
     post_speech_cooldown_sec: float
     initial_greeting: str
 
-class AudienceSimSettings(BaseModel):
-    llm_provider: str
-    gemini_model: str
-    openai_model: str
-    llm_temperature: float
-    chat_generation_interval_sec: int
-    chats_per_batch: int
-    max_output_tokens: int
-    prompt_template: str = Field(default="")
-    username_blocklist: List[str] = Field(default_factory=list)
-    username_pool: List[str] = Field(default_factory=list)
+
 
 class TTSSettings(BaseModel):
     voice_name: str
@@ -66,13 +57,25 @@ class ServerSettings(BaseModel):
     client_origins: List[str] = Field(default_factory=list)
     panel_password: Optional[str] = None
 
+class NicknameGenerationSettings(BaseModel):
+    enable_dynamic_pool: bool
+    dynamic_pool_size: int
+
+class ChatbotAgentSettings(BaseModel):
+    """Settings for the new chatbot agent"""
+    agent_provider: str
+    agent_model: str
+    generation_interval_sec: int
+    chats_per_batch: int
+    nickname_generation: NicknameGenerationSettings
+
 class AppSettings(BaseModel):
     api_keys: ApiKeysSettings = Field(default_factory=ApiKeysSettings)
     stream_metadata: StreamMetadataSettings
     agent_type: str  # 可选 "letta" 或 "builtin"
     agent: AgentSettings
+    chatbot_agent: ChatbotAgentSettings
     neuro_behavior: NeuroBehaviorSettings
-    audience_simulation: AudienceSimSettings
     tts: TTSSettings
     performance: PerformanceSettings
     server: ServerSettings
@@ -91,24 +94,6 @@ def _deep_update(source: dict, overrides: dict) -> dict:
             source[key] = overrides[key]
     return source
 
-class ConfigManager:
-    _instance = None
-
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super(ConfigManager, cls).__new__(cls)
-            cls._instance._initialized = False
-        return cls._instance
-
-    def __init__(self):
-        if self._initialized:
-            return
-        self.settings: AppSettings = self._load_settings()
-        self._update_callbacks = []
-        self._initialized = True
-
-    import sys
-
 class ConfigManager:
     _instance = None
 

neuro_simulator/core/path_manager.py

@@ -11,33 +11,47 @@ class PathManager:
         """Initializes the PathManager and defines the directory structure."""
         self.working_dir = Path(working_dir).resolve()
 
-        # Top-level directories
+        # --- Main Agent Paths ---
         self.agents_dir = self.working_dir / "agents"
         self.assets_dir = self.working_dir / "assets"
-
-        # Agents subdirectories
         self.neuro_agent_dir = self.agents_dir / "neuro"
         self.memory_agent_dir = self.agents_dir / "memory_manager"
         self.shared_memories_dir = self.agents_dir / "memories"
         self.user_tools_dir = self.agents_dir / "tools"
         self.builtin_tools_dir = self.user_tools_dir / "builtin_tools"
 
-        # Agent-specific config files
-        self.neuro_config_path = self.neuro_agent_dir / "config.yaml"
         self.neuro_tools_path = self.neuro_agent_dir / "tools.json"
         self.neuro_history_path = self.neuro_agent_dir / "history.jsonl"
         self.neuro_prompt_path = self.neuro_agent_dir / "neuro_prompt.txt"
 
-        self.memory_agent_config_path = self.memory_agent_dir / "config.yaml"
         self.memory_agent_tools_path = self.memory_agent_dir / "tools.json"
         self.memory_agent_history_path = self.memory_agent_dir / "history.jsonl"
         self.memory_agent_prompt_path = self.memory_agent_dir / "memory_prompt.txt"
-
-        # Shared memory files
         self.init_memory_path = self.shared_memories_dir / "init_memory.json"
         self.core_memory_path = self.shared_memories_dir / "core_memory.json"
         self.temp_memory_path = self.shared_memories_dir / "temp_memory.json"
 
+        # --- Chatbot Agent Paths ---
+        self.chatbot_root_dir = self.working_dir / "chatbot"
+        self.chatbot_agent_dir = self.chatbot_root_dir / "chatbot"
+        self.chatbot_memory_agent_dir = self.chatbot_root_dir / "memory_agent"
+        self.chatbot_memories_dir = self.chatbot_root_dir / "memories"
+        self.chatbot_tools_dir = self.chatbot_root_dir / "tools"
+        self.chatbot_builtin_tools_dir = self.chatbot_tools_dir / "builtin_tools"
+        self.chatbot_nickname_data_dir = self.chatbot_root_dir / "nickname_gen" / "data"
+
+        self.chatbot_agent_prompt_path = self.chatbot_agent_dir / "chatbot_prompt.txt"
+        self.chatbot_agent_tools_path = self.chatbot_agent_dir / "tools.json"
+        self.chatbot_agent_history_path = self.chatbot_agent_dir / "history.jsonl"
+
+        self.chatbot_memory_agent_prompt_path = self.chatbot_memory_agent_dir / "memory_prompt.txt"
+        self.chatbot_memory_agent_tools_path = self.chatbot_memory_agent_dir / "tools.json"
+        self.chatbot_memory_agent_history_path = self.chatbot_memory_agent_dir / "history.jsonl"
+
+        self.chatbot_init_memory_path = self.chatbot_memories_dir / "init_memory.json"
+        self.chatbot_core_memory_path = self.chatbot_memories_dir / "core_memory.json"
+        self.chatbot_temp_memory_path = self.chatbot_memories_dir / "temp_memory.json"
+
     def initialize_directories(self):
         """Creates all necessary directories if they don't exist."""
         dirs_to_create = [
@@ -47,7 +61,14 @@ class PathManager:
             self.memory_agent_dir,
             self.shared_memories_dir,
             self.user_tools_dir,
-            self.builtin_tools_dir
+            self.builtin_tools_dir,
+            self.chatbot_root_dir,
+            self.chatbot_agent_dir,
+            self.chatbot_memory_agent_dir,
+            self.chatbot_memories_dir,
+            self.chatbot_tools_dir,
+            self.chatbot_builtin_tools_dir,
+            self.chatbot_nickname_data_dir,
         ]
         for dir_path in dirs_to_create:
             os.makedirs(dir_path, exist_ok=True)

neuro_simulator/services/stream.py

@@ -128,6 +128,10 @@ class LiveStreamManager:
             return time.time() - self._stream_start_global_time
         return 0.0
 
+    def get_current_phase(self) -> str:
+        """Gets the current stream phase."""
+        return self._current_phase
+
     def get_initial_state_for_client(self) -> dict:
         """Generates the initial state event for a newly connected client."""
         elapsed_time = self.get_elapsed_time()

neuro_simulator/utils/queue.py

@@ -64,4 +64,16 @@ def get_all_neuro_input_chats() -> list[dict]:
 
 def is_neuro_input_queue_empty() -> bool:
     """Checks if the agent's input queue is empty."""
-    return not bool(neuro_input_queue)
+    return not bool(neuro_input_queue)
+
+def get_recent_audience_chats_for_chatbot(limit: int) -> list[dict]:
+    """Returns a list of recent chats formatted for the chatbot agent."""
+    recent_chats = list(audience_chat_buffer)[-limit:]
+    formatted_chats = []
+    for chat in recent_chats:
+        role = "user" if chat.get("is_user_message") else "assistant"
+        formatted_chats.append({
+            "role": role,
+            "content": f"{chat.get('username', 'unknown')}: {chat.get('text', '')}"
+        })
+    return formatted_chats

{neuro_simulator-0.4.3.dist-info → neuro_simulator-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuro_simulator
-Version: 0.4.3
+Version: 0.5.0
 Summary: Neuro Simulator Server
 Author-email: Moha-Master <hongkongreporter@outlook.com>
 License-Expression: MIT