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

neuro_simulator/agent/memory.py

@@ -1,137 +0,0 @@
-# agent/memory.py
-"""
-Memory management for the Neuro Simulator Agent
-"""
-
-import os
-import json
-import asyncio
-from typing import Dict, List, Any
-from datetime import datetime, timedelta
-
-class MemoryManager:
-    """Manages both immutable and mutable memory for the agent"""
-    
-    def __init__(self, memory_dir: str = "agent_memory"):
-        self.memory_dir = memory_dir
-        self.immutable_memory_file = os.path.join(memory_dir, "immutable_memory.json")
-        self.mutable_memory_file = os.path.join(memory_dir, "mutable_memory.json")
-        self.conversation_history_file = os.path.join(memory_dir, "conversation_history.json")
-        
-        # In-memory storage for faster access
-        self.immutable_memory: Dict[str, Any] = {}
-        self.mutable_memory: Dict[str, Any] = {}
-        self.conversation_history: List[Dict[str, Any]] = []
-        
-        # Create memory directory if it doesn't exist
-        os.makedirs(self.memory_dir, exist_ok=True)
-        
-    async def initialize(self):
-        """Load memory from files"""
-        # Load immutable memory
-        if os.path.exists(self.immutable_memory_file):
-            with open(self.immutable_memory_file, 'r') as f:
-                self.immutable_memory = json.load(f)
-        else:
-            # Initialize with default immutable data
-            self.immutable_memory = {
-                "name": "Neuro-Sama",
-                "personality": "Friendly, curious, and entertaining AI VTuber",
-                "capabilities": ["chat", "answer questions", "entertain viewers"]
-            }
-            await self._save_immutable_memory()
-            
-        # Load mutable memory
-        if os.path.exists(self.mutable_memory_file):
-            with open(self.mutable_memory_file, 'r') as f:
-                self.mutable_memory = json.load(f)
-        else:
-            # Initialize with default mutable data
-            self.mutable_memory = {
-                "mood": "happy",
-                "current_topic": "streaming",
-                "viewer_count": 0
-            }
-            await self._save_mutable_memory()
-            
-        # Load conversation history
-        if os.path.exists(self.conversation_history_file):
-            with open(self.conversation_history_file, 'r') as f:
-                self.conversation_history = json.load(f)
-                
-        print("Memory manager initialized")
-        
-    async def _save_immutable_memory(self):
-        """Save immutable memory to file"""
-        with open(self.immutable_memory_file, 'w') as f:
-            json.dump(self.immutable_memory, f, indent=2)
-            
-    async def _save_mutable_memory(self):
-        """Save mutable memory to file"""
-        with open(self.mutable_memory_file, 'w') as f:
-            json.dump(self.mutable_memory, f, indent=2)
-            
-    async def _save_conversation_history(self):
-        """Save conversation history to file"""
-        with open(self.conversation_history_file, 'w') as f:
-            json.dump(self.conversation_history, f, indent=2)
-            
-    async def reset(self):
-        """Reset all memory"""
-        self.immutable_memory = {
-            "name": "Neuro-Sama",
-            "personality": "Friendly, curious, and entertaining AI VTuber",
-            "capabilities": ["chat", "answer questions", "entertain viewers"]
-        }
-        self.mutable_memory = {
-            "mood": "happy",
-            "current_topic": "streaming",
-            "viewer_count": 0
-        }
-        self.conversation_history = []
-        
-        await self._save_immutable_memory()
-        await self._save_mutable_memory()
-        await self._save_conversation_history()
-        
-        print("Memory reset completed")
-        
-    async def add_message(self, message: Dict[str, Any]):
-        """Add a message to conversation history"""
-        self.conversation_history.append(message)
-        # Keep only the last 50 messages
-        if len(self.conversation_history) > 50:
-            self.conversation_history = self.conversation_history[-50:]
-        await self._save_conversation_history()
-        
-    async def get_context(self, max_messages: int = 10) -> str:
-        """Get context from conversation history"""
-        # Get recent messages
-        recent_messages = self.conversation_history[-max_messages:] if self.conversation_history else []
-        
-        # Format context
-        context_parts = []
-        
-        # Add immutable memory as context
-        context_parts.append("Character Information:")
-        for key, value in self.immutable_memory.items():
-            context_parts.append(f"- {key}: {value}")
-            
-        # Add mutable memory as context
-        context_parts.append("\nCurrent State:")
-        for key, value in self.mutable_memory.items():
-            context_parts.append(f"- {key}: {value}")
-            
-        # Add conversation history
-        if recent_messages:
-            context_parts.append("\nRecent Conversation:")
-            for msg in recent_messages:
-                context_parts.append(f"{msg['role']}: {msg['content']}")
-                
-        return "\n".join(context_parts)
-        
-    async def update_mutable_memory(self, updates: Dict[str, Any]):
-        """Update mutable memory with new values"""
-        self.mutable_memory.update(updates)
-        await self._save_mutable_memory()
-        print(f"Mutable memory updated: {updates}")

neuro_simulator/agent/tools.py

@@ -1,69 +0,0 @@
-# agent/tools.py
-"""
-Tools that the Neuro Simulator Agent can use
-"""
-
-import json
-import asyncio
-from typing import Dict, Any
-from .memory import MemoryManager
-
-class ToolManager:
-    """Manages tools that the agent can use to interact with its memory"""
-    
-    def __init__(self, memory_manager: MemoryManager):
-        self.memory_manager = memory_manager
-        self.tools = {}
-        self._register_default_tools()
-        
-    def _register_default_tools(self):
-        """Register default tools for memory management"""
-        self.tools["update_mood"] = self._update_mood
-        self.tools["update_topic"] = self._update_topic
-        self.tools["update_viewer_count"] = self._update_viewer_count
-        self.tools["get_memory_state"] = self._get_memory_state
-        
-    async def _update_mood(self, mood: str) -> str:
-        """Update the agent's mood"""
-        await self.memory_manager.update_mutable_memory({"mood": mood})
-        return f"Mood updated to: {mood}"
-        
-    async def _update_topic(self, topic: str) -> str:
-        """Update the current topic"""
-        await self.memory_manager.update_mutable_memory({"current_topic": topic})
-        return f"Topic updated to: {topic}"
-        
-    async def _update_viewer_count(self, count: int) -> str:
-        """Update the viewer count"""
-        await self.memory_manager.update_mutable_memory({"viewer_count": count})
-        return f"Viewer count updated to: {count}"
-        
-    async def _get_memory_state(self) -> Dict[str, Any]:
-        """Get the current state of all memory"""
-        return {
-            "immutable": self.memory_manager.immutable_memory,
-            "mutable": self.memory_manager.mutable_memory,
-            "conversation_history_length": len(self.memory_manager.conversation_history)
-        }
-        
-    def get_tool_descriptions(self) -> str:
-        """Get descriptions of all available tools"""
-        descriptions = [
-            "Available tools:",
-            "1. update_mood(mood: string) - Update the agent's mood",
-            "2. update_topic(topic: string) - Update the current topic of conversation",
-            "3. update_viewer_count(count: integer) - Update the viewer count",
-            "4. get_memory_state() - Get the current state of all memory"
-        ]
-        return "\n".join(descriptions)
-        
-    async def execute_tool(self, tool_name: str, params: Dict[str, Any]) -> Any:
-        """Execute a tool by name with given parameters"""
-        if tool_name in self.tools:
-            try:
-                result = await self.tools[tool_name](**params)
-                return result
-            except Exception as e:
-                return f"Error executing tool '{tool_name}': {str(e)}"
-        else:
-            return f"Tool '{tool_name}' not found"

neuro_simulator/builtin_agent.py

@@ -1,83 +0,0 @@
-# backend/builtin_agent.py
-"""Builtin agent module for Neuro Simulator"""
-
-import asyncio
-from typing import List, Dict, Union
-from .config import config_manager
-import time
-from datetime import datetime
-
-# Global variables
-local_agent = None
-
-async def initialize_builtin_agent():
-    """Initialize the builtin agent"""
-    global local_agent
-    
-    try:
-        from .agent.core import Agent as LocalAgentImport
-        from .stream_manager import live_stream_manager
-        
-        local_agent = LocalAgentImport(working_dir=live_stream_manager._working_dir)
-        await local_agent.initialize()
-    except Exception as e:
-        print(f"初始化本地 Agent 失败: {e}")
-        import traceback
-        traceback.print_exc()
-        local_agent = None
-
-async def reset_builtin_agent_memory():
-    """Reset the builtin agent's memory"""
-    global local_agent
-    
-    if local_agent is not None:
-        await local_agent.reset_all_memory()
-    else:
-        print("错误: 本地 Agent 未初始化，无法重置记忆。")
-
-async def clear_builtin_agent_temp_memory():
-    """Clear the builtin agent's temp memory"""
-    global local_agent
-    
-    if local_agent is not None:
-        # Reset only temp memory
-        await local_agent.memory_manager.reset_temp_memory()
-    else:
-        print("错误: 本地 Agent 未初始化，无法清空临时记忆。")
-
-async def clear_builtin_agent_context():
-    """Clear the builtin agent's context (dialog history)"""
-    global local_agent
-    
-    if local_agent is not None:
-        # Reset only context
-        await local_agent.memory_manager.reset_context()
-        
-        # Send context update via WebSocket to notify frontend
-        from .websocket_manager import connection_manager
-        await connection_manager.broadcast({
-            "type": "agent_context",
-            "action": "update",
-            "messages": []
-        })
-    else:
-        print("错误: 本地 Agent 未初始化，无法清空上下文。")
-
-async def get_builtin_response(chat_messages: list[dict]) -> dict:
-    """Get response from the builtin agent with detailed processing information"""
-    global local_agent
-    
-    if local_agent is not None:
-        response = await local_agent.process_messages(chat_messages)
-        
-        # Return the response directly without adding processing details to temp memory
-        return response
-    else:
-        print("错误: 本地 Agent 未初始化，无法获取响应。")
-        return {
-            "input_messages": chat_messages,
-            "llm_response": "",
-            "tool_executions": [],
-            "final_response": "Someone tell Vedal there is a problem with my AI.",
-            "error": "Agent not initialized"
-        }

neuro_simulator/config.yaml.example

@@ -1,157 +0,0 @@
-# --- API密钥配置（无法通过外部控制面板修改） ---
-api_keys:
-  # Letta API Token - 用于与 Letta 服务进行身份验证
-  # 如果你自建 Letta Server 且没有设置 token，可以留空
-  letta_token: "YOUR_LETTA_TOKEN_HERE"
-  
-  # Letta Server 基础 URL - 如果你自建 Letta Server 请填写完整地址，否则留空以使用Letta Cloud
-  letta_base_url: ""
-  
-  # Neuro Agent ID - 在 Letta 中创建的 Agent 的唯一标识符
-  neuro_agent_id: "YOUR_AGENT_ID_HERE"
-  
-  # Gemini API Key - 用于调用 Google Gemini API 生成观众聊天内容
-  gemini_api_key: "YOUR_GEMINI_KEY_HERE"
-  
-  # OpenAI API Key - 用于调用兼容 OpenAI 的 API 生成观众聊天内容
-  openai_api_key: "YOUR_OPENAI_KEY_HERE"
-  
-  # OpenAI API 基础 URL - 如果使用第三方兼容 OpenAI API 服务（如 SiliconFlow）请填写对应地址
-  openai_api_base_url: "YOUR_OPENAI_BASE_URL_HERE"
-  
-  # Azure 语音服务密钥 - 用于调用微软 Azure TTS 服务合成语音
-  azure_speech_key: "YOUR_AZURE_KEY_HERE"
-  
-  # Azure 语音服务区域 - Azure 服务所在的区域，如 "eastus" 或 "westus"
-  azure_speech_region: "YOUR_AZURE_REGION_HERE"
-
-# --- 直播元数据配置 ---
-stream_metadata:
-  # 主播昵称 - 显示在直播中的主播名称（此设置无法通过外部控制面板修改）
-  streamer_nickname: "vedal987"
-  
-  # 直播标题 - 显示在直播页面的标题
-  stream_title: "neuro-sama is here for u all"
-  
-  # 直播分类 - 直播内容的分类标签
-  stream_category: "谈天说地"
-  
-  # 直播标签 - 用于描述直播内容的标签列表
-  stream_tags: ["Vtuber", "AI", "Cute", "English", "Gremlin", "catgirl"]
-
-# --- Agent 类型设置 ---
-# 选择一个用来模拟Neuro的Agent提供方
-# - "letta": 使用Letta作为Agent，需要在上方配置Letta API相关信息
-# - "builtin": 使用内建Agent，请在下方填写配置
-agent_type: "builtin"
-
-# --- 内建Agent设置 ---
-# 仅当agent_type设置为"builtin"时生效
-agent:
-  # Agent的API服务商，支持"gemini"和"openai"，API Key配置使用顶部填写的值
-  agent_provider: "gemini"
-  # Agent使用的模型，切换gemini/openai时记得更改
-  agent_model: "gemini-2.5-flash-lite"
-
-# --- Neuro 行为与节奏控制 ---
-neuro_behavior:
-  # 输入聊天采样数量 - 每次生成 Neuro 回复时从观众聊天中采样的消息数量，不建议太长
-  input_chat_sample_size: 10
-  
-  # 说话后冷却时间（秒） - Neuro 每次说完话后的等待时间
-  post_speech_cooldown_sec: 1.0
-  
-  # 初始问候语 - 直播开始时给 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:
-  # 语音名称 - 不要调整这个设置
-  voice_name: "en-US-AshleyNeural"
-  
-  # 语音音调 - 除非你不想听Neuro的声音
-  voice_pitch: 1.25
-
-# --- 数据流与性能配置 ---
-performance:
-  # 输入队列最大大小 - 可能被提供给 Neuro 作为输入的聊天消息最大数量
-  # 具体逻辑是在 neuro_input_queue_max_size 中抽取 input_chat_sample_size 条消息发送
-  neuro_input_queue_max_size: 200
-  
-  # 观众聊天缓冲区最大大小 - 后端存储的聊天记录总量
-  audience_chat_buffer_max_size: 1000
-  
-  # 客户端初始聊天数 - 向新客户端发送的历史聊天消息数量，主要用来应对中途加入的客户端
-  initial_chat_backlog_limit: 50
-
-# --- 服务器配置 ---
-server:
-  # 服务器主机地址 - 服务器监听的主机地址（使用 uvicorn 命令启动时此设置无效）
-  host: "127.0.0.1"
-  
-  # 服务器端口 - 服务器监听的端口号（使用 uvicorn 命令启动时此设置无效）
-  port: 8000
-  
-  # 面板密码 - 设置 API token 用于外部控制面板的身份验证，在公网持续部署时强烈建议开启
-  panel_password: "your-secret-api-token-here"
-  
-  # 客户端来源 - 允许跨域访问的客户端地址列表，非本机访问时记得添加一下
-  client_origins:
-    - "http://localhost:5173"
-    - "http://127.0.0.1:5173"

neuro_simulator/letta.py

@@ -1,164 +0,0 @@
-# backend/letta.py
-from letta_client import Letta, MessageCreate, TextContent, LlmConfig, AssistantMessage
-from fastapi import HTTPException, status
-from .config import config_manager
-import asyncio
-from typing import Union
-
-# Global variables
-letta_client: Union[Letta, None] = None
-
-def initialize_letta_client():
-    """Initializes the Letta client if not already initialized."""
-    global letta_client
-    if letta_client:
-        return
-
-    try:
-        if not config_manager.settings.api_keys.letta_token:
-            raise ValueError("LETTA_API_TOKEN is not set. Cannot initialize Letta client.")
-        
-        client_args = {'token': config_manager.settings.api_keys.letta_token}
-        if config_manager.settings.api_keys.letta_base_url:
-            client_args['base_url'] = config_manager.settings.api_keys.letta_base_url
-            print(f"Letta client is being initialized for self-hosted URL: {config_manager.settings.api_keys.letta_base_url}")
-        else:
-            print("Letta client is being initialized for Letta Cloud.")
-
-        letta_client = Letta(**client_args)
-
-        if config_manager.settings.api_keys.neuro_agent_id:
-            try:
-                agent_data = letta_client.agents.retrieve(agent_id=config_manager.settings.api_keys.neuro_agent_id)
-                print(f"成功获取 Letta Agent 详情，ID: {agent_data.id}")
-                llm_model_info = "N/A"
-                if hasattr(agent_data, 'model') and agent_data.model:
-                    llm_model_info = agent_data.model
-                elif agent_data.llm_config:
-                    if isinstance(agent_data.llm_config, LlmConfig):
-                        llm_config_dict = agent_data.llm_config.model_dump() if hasattr(agent_data.llm_config, 'model_dump') else agent_data.llm_config.__dict__
-                        llm_model_info = llm_config_dict.get('model_name') or llm_config_dict.get('name') or llm_config_dict.get('model')
-                    if not llm_model_info:
-                        llm_model_info = str(agent_data.llm_config)
-                print(f"  -> Agent 名称: {agent_data.name}")
-                print(f"  -> LLM 模型: {llm_model_info}")
-            except Exception as e:
-                error_msg = f"错误: 无法获取 Neuro Letta Agent (ID: {config_manager.settings.api_keys.neuro_agent_id})。请确保 ID 正确，且服务可访问。详情: {e}"
-                print(error_msg)
-                raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=error_msg)
-    except Exception as e:
-        print(f"初始化 Letta 客户端失败: {e}")
-        letta_client = None
-
-def get_letta_client():
-    if letta_client is None: raise ValueError("Letta client is not initialized.")
-    return letta_client
-
-async def initialize_agent():
-    """Initialize the appropriate agent based on configuration"""
-    agent_type = config_manager.settings.agent_type
-    
-    if agent_type == "letta":
-        initialize_letta_client()
-        print("Using Letta as the agent")
-    else:
-        print(f"Unknown agent type: {agent_type}. Defaulting to Letta.")
-        initialize_letta_client()
-        
-    return agent_type
-
-async def reset_neuro_agent_memory():
-    """
-    重置 Agent 的记忆，包括：
-    1. 清空所有消息历史记录。
-    2. 清空指定的 'conversation_summary' 核心内存块。
-    """
-    # Ensure letta client is initialized before using it
-    initialize_letta_client()
-    if letta_client is None:
-        print("Letta client 未初始化，跳过重置。")
-        return
-        
-    agent_id = config_manager.settings.api_keys.neuro_agent_id
-    if not agent_id: 
-        print("Letta Agent ID 未配置，跳过重置。")
-        return
-
-    # --- 步骤 1: 重置消息历史记录 (上下文) ---
-    try:
-        letta_client.agents.messages.reset(agent_id=agent_id)
-        print(f"Neuro Agent (ID: {agent_id}) 的消息历史已成功重置。")
-    except Exception as e:
-        print(f"警告: 重置 Agent 消息历史失败: {e}。")
-
-    # --- 步骤 2: 清空 'conversation_summary' 核心内存块 ---
-    block_label_to_clear = "conversation_summary"
-    try:
-        print(f"正在尝试清空核心记忆块: '{block_label_to_clear}'...")
-        
-        # 调用 modify 方法，将 value 设置为空字符串
-        letta_client.agents.blocks.modify(
-            agent_id=agent_id,
-            block_label=block_label_to_clear,
-            value="" 
-        )
-        
-        print(f"核心记忆块 '{block_label_to_clear}' 已成功清空。")
-    except Exception as e:
-        # 优雅地处理块不存在的情况
-        # API 在找不到块时通常会返回包含 404 或 "not found" 的错误
-        error_str = str(e).lower()
-        if "not found" in error_str or "404" in error_str:
-             print(f"信息: 核心记忆块 '{block_label_to_clear}' 不存在，无需清空。")
-        else:
-             print(f"警告: 清空核心记忆块 '{block_label_to_clear}' 失败: {e}。")
-
-async def get_neuro_response(chat_messages: list[dict]) -> str:
-    # Ensure letta client is initialized before using it
-    initialize_letta_client()
-    if letta_client is None or not config_manager.settings.api_keys.neuro_agent_id:
-        print("错误: Letta client 或 Agent ID 未配置，无法获取响应。")
-        return "Someone tell Vedal there is a problem with my AI."
-
-    if chat_messages:
-        injected_chat_lines = [f"{chat['username']}: {chat['text']}" for chat in chat_messages]
-        injected_chat_text = (
-            "Here are some recent messages from my Twitch chat:\n---\n" + 
-            "\n".join(injected_chat_lines) + 
-            "\n---\nNow, as the streamer Neuro-Sama, please continue the conversation naturally."
-        )
-    else:
-        injected_chat_text = "My chat is quiet right now. As Neuro-Sama, what should I say to engage them?"
-
-    print(f"正在向 Neuro Agent 发送输入 (包含 {len(chat_messages)} 条消息)..." )
-
-    try:
-        # 使用 asyncio.to_thread 在线程池中执行阻塞调用，避免阻塞事件循环
-        response = await asyncio.to_thread(
-            letta_client.agents.messages.create,
-            agent_id=config_manager.settings.api_keys.neuro_agent_id,
-            messages=[MessageCreate(role="user", content=injected_chat_text)]
-        )
-
-        ai_full_response_text = ""
-        if response and response.messages:
-            last_message = response.messages[-1]
-            if isinstance(last_message, AssistantMessage) and hasattr(last_message, 'content'):
-                content = last_message.content
-                if isinstance(content, str):
-                    ai_full_response_text = content.strip()
-                elif isinstance(content, list) and content:
-                    first_part = content[0]
-                    if isinstance(first_part, TextContent) and hasattr(first_part, 'text'):
-                        ai_full_response_text = first_part.text.strip()
-        
-        if not ai_full_response_text:
-            print(f"警告: 未能从 Letta 响应中解析出有效的文本。响应对象: {response}")
-            return "Someone tell Vedal there is a problem with my AI."
-
-        print(f"成功从 Letta 解析到响应: '{ai_full_response_text[:70]}...'")
-        return ai_full_response_text
-
-    except Exception as e:
-        print(f"错误: 调用 Letta Agent ({config_manager.settings.api_keys.neuro_agent_id}) 失败: {e}")
-        return "Someone tell Vedal there is a problem with my AI."

neuro_simulator/log_handler.py

@@ -1,43 +0,0 @@
-# backend/log_handler.py
-import logging
-from collections import deque
-from typing import Deque
-
-# 创建两个独立的、有界限的队列，用于不同来源的日志
-server_log_queue: Deque[str] = deque(maxlen=1000)
-agent_log_queue: Deque[str] = deque(maxlen=1000)
-
-class QueueLogHandler(logging.Handler):
-    """一个将日志记录发送到指定队列的处理器。"""
-    def __init__(self, queue: Deque[str]):
-        super().__init__()
-        self.queue = queue
-
-    def emit(self, record: logging.LogRecord):
-        log_entry = self.format(record)
-        self.queue.append(log_entry)
-
-def configure_server_logging():
-    """配置服务器（根）日志记录器，将其日志发送到 server_log_queue。"""
-    # 为服务器日志创建一个处理器实例
-    server_queue_handler = QueueLogHandler(server_log_queue)
-    formatter = logging.Formatter('%(asctime)s - [SERVER] - %(levelname)s - %(message)s', datefmt='%H:%M:%S')
-    server_queue_handler.setFormatter(formatter)
-    
-    # 获取根 logger 并添加 handler
-    # 这将捕获所有未被专门处理的日志（来自fastapi, uvicorn等）
-    root_logger = logging.getLogger()
-    # 清除可能存在的旧handler，以防万一
-    if root_logger.hasHandlers():
-        root_logger.handlers.clear()
-        
-    root_logger.addHandler(server_queue_handler)
-    root_logger.setLevel(logging.INFO)
-
-    # 将 uvicorn 的日志也引导到我们的 handler
-    logging.getLogger("uvicorn.access").handlers = [server_queue_handler]
-    logging.getLogger("uvicorn.error").handlers = [server_queue_handler]
-
-    print("服务器日志系统已配置，将日志输出到 server_log_queue。")
-
-# Agent 的日志配置将会在 agent 模块内部完成，以保持解耦