neuro-simulator 0.0.1__py3-none-any.whl

neuro_simulator/__init__.py

@@ -0,0 +1 @@
+# neuro_simulator/__init__.py

neuro_simulator/audio_synthesis.py

@@ -0,0 +1,66 @@
+# backend/audio_synthesis.py
+import html
+import base64
+import azure.cognitiveservices.speech as speechsdk
+import asyncio
+from .config import config_manager
+
+async def synthesize_audio_segment(text: str, voice_name: str = None, pitch: float = None) -> tuple[str, float]:
+    """
+    使用 Azure TTS 合成音频。
+    如果 voice_name 或 pitch 未提供，则使用配置中的默认值。
+    返回 Base64 编码的音频字符串和音频时长（秒）。
+    """
+    # 使用 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 未在配置中设置。")
+
+    # 如果未传入参数，则使用配置的默认值
+    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
+
+    speech_config = speechsdk.SpeechConfig(subscription=azure_key, region=azure_region)
+    speech_config.set_speech_synthesis_output_format(speechsdk.SpeechSynthesisOutputFormat.Audio16Khz32KBitRateMonoMp3)
+
+    pitch_percent = int((final_pitch - 1.0) * 100)
+    pitch_ssml_value = f"+{pitch_percent}%" if pitch_percent >= 0 else f"{pitch_percent}%"
+    
+    escaped_text = html.escape(text)
+
+    ssml_string = f"""
+    <speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xml:lang="en-US">
+        <voice name="{final_voice_name}">
+            <prosody pitch="{pitch_ssml_value}">
+                {escaped_text}
+            </prosody>
+        </voice>
+    </speak>
+    """
+    
+    synthesizer = speechsdk.SpeechSynthesizer(speech_config=speech_config, audio_config=None)
+
+    def _perform_synthesis_sync():
+        return synthesizer.speak_ssml_async(ssml_string).get()
+
+    try:
+        result = await asyncio.to_thread(_perform_synthesis_sync)
+
+        if result.reason == speechsdk.ResultReason.SynthesizingAudioCompleted:
+            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)")
+            return encoded_audio, audio_duration_sec
+        else:
+            cancellation_details = result.cancellation_details
+            error_message = f"TTS 合成失败/取消 (原因: {cancellation_details.reason})。文本: '{text}'"
+            if cancellation_details.error_details:
+                error_message += f" | 详情: {cancellation_details.error_details}"
+            print(f"错误: {error_message}")
+            raise Exception(error_message)
+    except Exception as e:
+        print(f"错误: 在调用 Azure TTS SDK 时发生异常: {e}")
+        raise

neuro_simulator/chatbot.py

@@ -0,0 +1,104 @@
+# backend/chatbot.py
+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
+
+class AudienceLLMClient:
+    async def generate_chat_messages(self, prompt: str, max_tokens: int) -> str:
+        raise NotImplementedError
+
+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}")
+
+    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,
+            config=types.GenerateContentConfig(
+                temperature=config_manager.settings.audience_simulation.llm_temperature,
+                max_output_tokens=max_tokens
+            )
+        )
+        raw_chat_text = ""
+        if hasattr(response, 'text') and response.text:
+            raw_chat_text = response.text
+        elif response.candidates and response.candidates[0].content and response.candidates[0].content.parts:
+            for part in response.candidates[0].content.parts:
+                if hasattr(part, 'text') and part.text:
+                    raw_chat_text += part.text
+        return raw_chat_text
+
+class OpenAIAudienceLLM(AudienceLLMClient):
+    def __init__(self, api_key: str, model_name: str, base_url: str | None):
+        if not api_key:
+            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}")
+
+    async def generate_chat_messages(self, prompt: str, max_tokens: int) -> str:
+        response = await self.client.chat.completions.create(
+            model=self.model_name,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=config_manager.settings.audience_simulation.llm_temperature,
+            max_tokens=max_tokens,
+        )
+        if response.choices and response.choices[0].message and response.choices[0].message.content:
+            return response.choices[0].message.content.strip()
+        return ""
+
+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 对象中的模板和变量
+    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:
+    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.")
+
+    def _create_client(self, settings: AppSettings) -> AudienceLLMClient:
+        provider = settings.audience_simulation.llm_provider
+        print(f"正在为 provider 创建新的 audience LLM client: {provider}")
+        if provider.lower() == "gemini":
+            if not settings.api_keys.gemini_api_key:
+                raise ValueError("GEMINI_API_KEY 未在配置中设置")
+            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 未在配置中设置")
+            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}")
+
+    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...")
+            try:
+                self.client = self._create_client(new_settings)
+                self._last_checked_settings = new_audience_settings
+                print("LLM client 已成功热重载。")
+            except Exception as e:
+                print(f"错误：热重载 LLM client 失败: {e}")
+        else:
+            print("观众模拟设置未更改，跳过 LLM client 重载。")

neuro_simulator/cli.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+
+import argparse
+import os
+import sys
+import shutil
+from pathlib import Path
+
+def main():
+    parser = argparse.ArgumentParser(description="Neuro-Simulator Server")
+    parser.add_argument("-D", "--dir", help="Working directory containing settings.yaml")
+    parser.add_argument("-H", "--host", help="Host to bind the server to")
+    parser.add_argument("-P", "--port", type=int, help="Port to bind the server to")
+    
+    args = parser.parse_args()
+    
+    # Set working directory
+    if args.dir:
+        work_dir = Path(args.dir).resolve()
+        # If the directory doesn't exist (and it's not the default), raise an error
+        if not work_dir.exists():
+            print(f"Error: Working directory '{work_dir}' does not exist. Please create it manually.")
+            sys.exit(1)
+    else:
+        work_dir = Path.home() / ".config" / "neuro-simulator"
+        work_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Change to working directory
+    os.chdir(work_dir)
+    
+    # Handle settings.yaml.example
+    settings_example_path = work_dir / "settings.yaml.example"
+    settings_path = work_dir / "settings.yaml"
+    
+    # Copy settings.yaml.example from package if it doesn't exist
+    if not settings_example_path.exists():
+        try:
+            # Try pkg_resources first (for installed packages)
+            try:
+                import pkg_resources
+                example_path = pkg_resources.resource_filename('neuro_simulator', 'settings.yaml.example')
+                if os.path.exists(example_path):
+                    shutil.copy(example_path, settings_example_path)
+                    print(f"Created {settings_example_path} from package example")
+                else:
+                    # Fallback to relative path (for development mode)
+                    dev_example_path = Path(__file__).parent / "settings.yaml.example"
+                    if dev_example_path.exists():
+                        shutil.copy(dev_example_path, settings_example_path)
+                        print(f"Created {settings_example_path} from development example")
+                    else:
+                        print("Warning: settings.yaml.example not found in package or development folder")
+            except Exception:
+                # Fallback to relative path (for development mode)
+                dev_example_path = Path(__file__).parent / "settings.yaml.example"
+                if dev_example_path.exists():
+                    shutil.copy(dev_example_path, settings_example_path)
+                    print(f"Created {settings_example_path} from development example")
+                else:
+                    print("Warning: settings.yaml.example not found in package or development folder")
+        except Exception as e:
+            print(f"Warning: Could not copy settings.yaml.example from package: {e}")
+    
+    # Handle media folder
+    media_dir = work_dir / "media"
+    video_path = media_dir / "neuro_start.mp4"
+    
+    # Copy media folder from package if it doesn't exist or is invalid
+    if not media_dir.exists() or not video_path.exists():
+        # If media dir exists but video doesn't, remove the incomplete media dir
+        if media_dir.exists():
+            shutil.rmtree(media_dir)
+            
+        try:
+            # Try pkg_resources first (for installed packages)
+            try:
+                import pkg_resources
+                package_media_path = pkg_resources.resource_filename('neuro_simulator', 'media')
+                if os.path.exists(package_media_path):
+                    shutil.copytree(package_media_path, media_dir)
+                    print(f"Created {media_dir} from package media")
+                else:
+                    # Fallback to relative path (for development mode)
+                    dev_media_path = Path(__file__).parent / "media"
+                    if dev_media_path.exists():
+                        shutil.copytree(dev_media_path, media_dir)
+                        print(f"Created {media_dir} from development media")
+                    else:
+                        print("Warning: media folder not found in package or development folder")
+            except Exception:
+                # Fallback to relative path (for development mode)
+                dev_media_path = Path(__file__).parent / "media"
+                if dev_media_path.exists():
+                    shutil.copytree(dev_media_path, media_dir)
+                    print(f"Created {media_dir} from development media")
+                else:
+                    print("Warning: media folder not found in package or development folder")
+        except Exception as e:
+            print(f"Warning: Could not copy media folder from package: {e}")
+    
+    # Now check for required files and handle errors appropriately
+    errors = []
+    
+    # Check for settings.yaml (required for running)
+    if not settings_path.exists():
+        if settings_example_path.exists():
+            errors.append(f"Error: {settings_path} not found. Please copy {settings_example_path} to {settings_path} and configure it.")
+        else:
+            errors.append(f"Error: Neither {settings_path} nor {settings_example_path} found. Please ensure proper configuration.")
+    
+    # Check for required media files (required for running)
+    if not media_dir.exists() or not video_path.exists():
+        errors.append(f"Error: Required media files not found in {media_dir}.")
+    
+    # If there are any errors, print them and exit
+    if errors:
+        for error in errors:
+            print(error)
+        sys.exit(1)
+    
+    # Import and run the main application
+    try:
+        from neuro_simulator.main import run_server
+        run_server(args.host, args.port)
+    except ImportError:
+        # Fallback for development mode
+        sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+        from neuro_simulator.main import run_server
+        run_server(args.host, args.port)
+
+if __name__ == "__main__":
+    main()

neuro_simulator/config.py

@@ -0,0 +1,226 @@
+# backend/config.py
+import os
+import yaml
+from pydantic import BaseModel, Field
+from typing import List, Optional, Dict, Any
+import logging
+import asyncio
+from collections.abc import Mapping
+
+# 配置日志记录器
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# --- 1. 定义配置的结构 (Schema) ---
+
+class ApiKeysSettings(BaseModel):
+    letta_token: Optional[str] = None
+    letta_base_url: Optional[str] = None
+    neuro_agent_id: Optional[str] = None
+    gemini_api_key: Optional[str] = None
+    openai_api_key: Optional[str] = None
+    openai_api_base_url: Optional[str] = None
+    azure_speech_key: Optional[str] = None
+    azure_speech_region: Optional[str] = None
+
+class StreamMetadataSettings(BaseModel):
+    streamer_nickname: str = "vedal987"
+    stream_title: str = "neuro-sama is here for u all"
+    stream_category: str = "谈天说地"
+    stream_tags: List[str] = Field(default_factory=lambda: ["Vtuber"])
+
+class NeuroBehaviorSettings(BaseModel):
+    input_chat_sample_size: int = 10
+    post_speech_cooldown_sec: float = 1.0
+    initial_greeting: str = "The stream has just started. Greet your audience and say hello!"
+
+class AudienceSimSettings(BaseModel):
+    llm_provider: str = "gemini"
+    gemini_model: str = "gemini-1.5-flash-latest"
+    openai_model: str = "gpt-3.5-turbo"
+    llm_temperature: float = 1.0
+    chat_generation_interval_sec: int = 2
+    chats_per_batch: int = 3
+    max_output_tokens: int = 300
+    prompt_template: str = Field(default="""
+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_blocklist: List[str] = Field(default_factory=lambda: ["ChatterBoy", "EmoteFan", "Username", "User"])
+    username_pool: List[str] = Field(default_factory=lambda: [
+        "ChatterBox", "EmoteLord", "QuestionMark", "StreamFan", "PixelPundit",
+        "CodeSage", "DataDiver", "ByteBard", "LogicLover", "AI_Enthusiast"
+    ])
+
+class TTSSettings(BaseModel):
+    voice_name: str = "en-US-AshleyNeural"
+    voice_pitch: float = 1.25
+
+class PerformanceSettings(BaseModel):
+    neuro_input_queue_max_size: int = 200
+    audience_chat_buffer_max_size: int = 500
+    initial_chat_backlog_limit: int = 50
+
+class ServerSettings(BaseModel):
+    host: str = "127.0.0.1"
+    port: int = 8000
+    client_origins: List[str] = Field(default_factory=lambda: ["http://localhost:5173", "http://127.0.0.1:5173"])
+    panel_password: Optional[str] = None
+
+class AppSettings(BaseModel):
+    api_keys: ApiKeysSettings = Field(default_factory=ApiKeysSettings)
+    stream_metadata: StreamMetadataSettings = Field(default_factory=StreamMetadataSettings)
+    neuro_behavior: NeuroBehaviorSettings = Field(default_factory=NeuroBehaviorSettings)
+    audience_simulation: AudienceSimSettings = Field(default_factory=AudienceSimSettings)
+    tts: TTSSettings = Field(default_factory=TTSSettings)
+    performance: PerformanceSettings = Field(default_factory=PerformanceSettings)
+    server: ServerSettings = Field(default_factory=ServerSettings)
+
+# --- 2. 加载和管理配置的逻辑 ---
+
+CONFIG_FILE_PATH = "settings.yaml"
+
+def _deep_update(source: dict, overrides: dict) -> dict:
+    """
+    Recursively update a dictionary.
+    """
+    for key, value in overrides.items():
+        if isinstance(value, Mapping) and value:
+            returned = _deep_update(source.get(key, {}), value)
+            source[key] = returned
+        else:
+            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
+
+    def _load_config_from_yaml(self) -> dict:
+        if not os.path.exists(CONFIG_FILE_PATH):
+            logging.warning(f"{CONFIG_FILE_PATH} not found. Using default settings. You can create it from settings.yaml.example.")
+            return {}
+        try:
+            with open(CONFIG_FILE_PATH, 'r', encoding='utf-8') as f:
+                return yaml.safe_load(f) or {}
+        except Exception as e:
+            logging.error(f"Error loading or parsing {CONFIG_FILE_PATH}: {e}")
+            return {}
+
+    def _load_settings(self) -> AppSettings:
+        yaml_config = self._load_config_from_yaml()
+        base_settings = AppSettings.model_validate(yaml_config)
+
+        # 检查关键配置项
+        missing_keys = []
+        if not base_settings.api_keys.letta_token:
+            missing_keys.append("api_keys.letta_token")
+        if not base_settings.api_keys.neuro_agent_id:
+            missing_keys.append("api_keys.neuro_agent_id")
+            
+        if missing_keys:
+            raise ValueError(f"Critical config missing in settings.yaml: {', '.join(missing_keys)}. "
+                           f"Please check your settings.yaml file against settings.yaml.example.")
+
+        logging.info("Configuration loaded successfully.")
+        return base_settings
+
+    def save_settings(self):
+        """Saves the current configuration to settings.yaml."""
+        try:
+            # 1. Get the current settings from memory
+            config_to_save = self.settings.model_dump(mode='json', exclude={'api_keys'})
+
+            # 2. Read the existing config on disk to get the api_keys that should be preserved.
+            existing_config = self._load_config_from_yaml()
+            if 'api_keys' in existing_config:
+                # 3. Add the preserved api_keys block back to the data to be saved.
+                config_to_save['api_keys'] = existing_config['api_keys']
+
+            # 4. Rebuild the dictionary to maintain the original order from the Pydantic model.
+            final_config = {}
+            for field_name in AppSettings.model_fields:
+                if field_name in config_to_save:
+                    final_config[field_name] = config_to_save[field_name]
+
+            # 5. Write the final, correctly ordered configuration to the file.
+            with open(CONFIG_FILE_PATH, 'w', encoding='utf-8') as f:
+                yaml.dump(final_config, f, allow_unicode=True, sort_keys=False, indent=2)
+            logging.info(f"Configuration saved to {CONFIG_FILE_PATH}")
+        except Exception as e:
+            logging.error(f"Failed to save configuration to {CONFIG_FILE_PATH}: {e}")
+
+    def register_update_callback(self, callback):
+        """Registers a callback function to be called on settings update."""
+        self._update_callbacks.append(callback)
+
+    async def update_settings(self, new_settings_data: dict):
+        """
+        Updates the settings by merging new data, re-validating the entire
+        model to ensure sub-models are correctly instantiated, and then
+        notifying callbacks.
+        """
+        # Prevent API keys from being updated from the panel
+        new_settings_data.pop('api_keys', None)
+
+        try:
+            # 1. Dump the current settings model to a dictionary.
+            current_settings_dict = self.settings.model_dump()
+
+            # 2. Recursively update the dictionary with the new data.
+            updated_settings_dict = _deep_update(current_settings_dict, new_settings_data)
+
+            # 3. Re-validate the entire dictionary back into a Pydantic model.
+            #    This is the crucial step that reconstructs the sub-models.
+            self.settings = AppSettings.model_validate(updated_settings_dict)
+            
+            # 4. Save the updated configuration to the YAML file.
+            self.save_settings()
+            
+            # 5. Call registered callbacks with the new, valid settings model.
+            for callback in self._update_callbacks:
+                try:
+                    if asyncio.iscoroutinefunction(callback):
+                        await callback(self.settings)
+                    else:
+                        callback(self.settings)
+                except Exception as e:
+                    logging.error(f"Error executing settings update callback: {e}", exc_info=True)
+
+            logging.info("Runtime configuration updated and callbacks executed.")
+        except Exception as e:
+            logging.error(f"Failed to update settings: {e}", exc_info=True)
+
+
+# --- 3. 创建全局可访问的配置实例 ---
+config_manager = ConfigManager()
+
+# --- 4. 运行时更新配置的函数 (legacy wrapper for compatibility) ---
+async def update_and_broadcast_settings(new_settings_data: dict):
+    await config_manager.update_settings(new_settings_data)
+    # Broadcast stream_metadata changes specifically for now
+    if 'stream_metadata' in new_settings_data:
+        from .stream_manager import live_stream_manager
+        await live_stream_manager.broadcast_stream_metadata()

neuro_simulator/letta.py

@@ -0,0 +1,135 @@
+# backend/letta.py
+from letta_client import Letta, MessageCreate, TextContent, LlmConfig, AssistantMessage
+from fastapi import HTTPException, status
+from .config import config_manager
+
+# 初始化 Letta 客户端
+letta_client: Letta | None = None
+try:
+    if not config_manager.settings.api_keys.letta_token:
+        raise ValueError("LETTA_API_TOKEN is not set. Cannot initialize Letta client.")
+    
+    # 使用 settings 对象进行配置
+    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 reset_neuro_agent_memory():
+    """
+    重置 Agent 的记忆，包括：
+    1. 清空所有消息历史记录。
+    2. 清空指定的 'conversation_summary' 核心内存块。
+    """
+    agent_id = config_manager.settings.api_keys.neuro_agent_id
+    if letta_client is None or not agent_id: 
+        print("Letta client 或 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:
+    if letta_client is None or not config_manager.settings.api_keys.neuro_agent_id:
+        print("警告: Letta client 或 Agent ID 未配置，无法获取响应。")
+        return "我暂时无法回应，请稍后再试。"
+
+    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:
+        response = 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 "I seem to be at a loss for words right now."
+
+        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."