Tolan/backend/ai_service.py

"""
AI服务：集成STT、LLM、TTS模型
"""
import base64
import json
import asyncio
import tempfile
import os
from typing import AsyncGenerator, Optional
import dashscope
from openai import OpenAI
from config import settings
from models import EmotionType

# 设置API Key
dashscope.api_key = settings.dashscope_api_key


class AIService:
    """AI服务管理器"""
    
    def __init__(self):
        import httpx
        import os
        
        # 临时清除代理环境变量（只在这个进程中）
        env_backup = {}
        proxy_vars = ['HTTP_PROXY', 'HTTPS_PROXY', 'http_proxy', 'https_proxy', 'ALL_PROXY', 'all_proxy']
        for var in proxy_vars:
            if var in os.environ:
                env_backup[var] = os.environ[var]
                del os.environ[var]
        
        # 创建不使用代理的 HTTP 客户端
        http_client = httpx.Client(
            proxy=None,  # 禁用代理
            timeout=60.0,
            trust_env=False,  # 不信任环境变量中的代理设置
        )
        
        self.openai_client = OpenAI(
            api_key=settings.dashscope_api_key,
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
            http_client=http_client,  # 使用自定义 HTTP 客户端
        )
        
        # 恢复环境变量（避免影响其他模块）
        for var, value in env_backup.items():
            os.environ[var] = value
    
    # STT现在使用流式识别，在websocket_handler中直接处理
    
    async def generate_response_stream(
        self, user_text: str
    ) -> AsyncGenerator[tuple[str, EmotionType], None]:
        """
        生成对话回复（流式）
        
        Args:
            user_text: 用户输入文本
            
        Yields:
            (sentence, emotion): 句子片段和情感
        """
        try:
            print(f"\n========== LLM 流式开始 ==========")
            print(f"用户输入: {user_text}")
            
            # 构建System Prompt
            system_prompt = self._build_system_prompt()
            
            print(f"调用 LLM 流式: {settings.llm_model}")
            print(f"学习者水平: {settings.LEARNER_PROFICIENCY}, 年龄组: {settings.AGE_TAG}, 主题: {settings.TOPIC_TAG}, 模式: {settings.EXPERIMENT_TAG}")
            
            # 调用LLM流式API
            response = self.openai_client.chat.completions.create(
                model=settings.llm_model,
                messages=[
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": user_text},
                ],
                temperature=0.7,
                max_tokens=500,
                stream=True,  # 启用流式
            )
            
            buffer = ""
            full_response = ""
            sentence_count = 0
            
            for chunk in response:
                if chunk.choices[0].delta.content:
                    content = chunk.choices[0].delta.content
                    buffer += content
                    full_response += content
                    
                    # 检测句子边界（完整的句子）
                    if self._is_complete_sentence(buffer):
                        sentence = buffer.strip()
                        sentence_count += 1
                        print(f"LLM 流式输出句子{sentence_count}: {sentence}")
                        yield (sentence, "neutral")  # 情感稍后统一提取
                        buffer = ""
            
            # 处理剩余内容和提取情感
            emotion: EmotionType = "neutral"
            
            # 从完整响应中提取情感
            if "[EMOTION:" in full_response:
                emotion_start = full_response.find("[EMOTION:")
                emotion_end = full_response.find("]", emotion_start)
                if emotion_end > emotion_start:
                    emotion_str = full_response[emotion_start + 9:emotion_end].strip().lower()
                    valid_emotions = ["neutral", "happy", "sad", "excited", "angry", "surprised", "thoughtful", "encouraging"]
                    if emotion_str in valid_emotions:
                        emotion = emotion_str
                    # 移除情感标签部分
                    full_response = full_response[:emotion_start].strip()
            
            # 处理buffer中的剩余内容（已输出句子之后的部分）
            remaining = buffer.strip()
            if remaining and not remaining.startswith("[EMOTION"):
                sentence_count += 1
                print(f"LLM 流式输出最后{sentence_count}: {remaining}")
                yield (remaining, emotion)
            elif not remaining and sentence_count == 0:
                # 如果一个句子都没输出，输出完整内容
                if full_response:
                    print(f"LLM 流式输出完整: {full_response}")
                    yield (full_response, emotion)
            
            print(f"LLM 完整响应: {full_response}")
            print(f"提取情感: {emotion}")
            print(f"========== LLM 流式成功 ==========\n")
            
        except Exception as e:
            print(f"========== LLM 流式错误 ==========")
            print(f"错误: {e}")
            import traceback
            traceback.print_exc()
            print(f"========== LLM 流式错误结束 ==========\n")
            yield ("I'm sorry, I'm having trouble understanding. Could you please repeat that?", "neutral")
    
    def _is_complete_sentence(self, text: str) -> bool:
        """检测是否完整句子"""
        text = text.strip()
        
        # 必须以句子结束符结尾
        if not text.endswith(('.', '!', '?', '。', '！', '？')):
            return False
        
        # 排除常见缩写（避免误判）
        words = text.split()
        if words:
            last_word = words[-1]
            # 常见英文缩写
            common_abbrev = ['Mr.', 'Mrs.', 'Ms.', 'Dr.', 'Prof.', 'Sr.', 'Jr.', 'etc.', 'e.g.', 'i.e.', 'vs.']
            if last_word in common_abbrev:
                return False
        
        # 至少5个字符（避免"Hi."这种过短的）
        if len(text) < 5:
            return False
        
        return True
    
    async def generate_response(
        self, user_text: str
    ) -> tuple[str, EmotionType]:
        """
        生成对话回复
        
        Args:
            user_text: 用户输入文本
            
        Returns:
            (response_text, emotion): 回复文本和情感
        """
        try:
            print(f"\n========== LLM 开始 ==========")
            print(f"用户输入: {user_text}")
            
            # 构建System Prompt
            system_prompt = self._build_system_prompt()
            
            print(f"调用 LLM: {settings.llm_model}")
            print(f"学习者水平: {settings.LEARNER_PROFICIENCY}, 年龄组: {settings.AGE_TAG}, 主题: {settings.TOPIC_TAG}, 模式: {settings.EXPERIMENT_TAG}")
            
            # 调用LLM
            response = self.openai_client.chat.completions.create(
                model=settings.llm_model,
                messages=[
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": user_text},
                ],
                temperature=0.7,
                max_tokens=500,
            )
            
            full_response = response.choices[0].message.content or ""
            print(f"LLM 原始响应: {full_response}")
            
            # 提取情感标签
            emotion: EmotionType = "neutral"
            response_text = full_response
            
            # 查找情感标签
            if "[EMOTION:" in full_response:
                emotion_start = full_response.find("[EMOTION:")
                emotion_end = full_response.find("]", emotion_start)
                if emotion_end > emotion_start:
                    emotion_str = full_response[emotion_start + 9:emotion_end].strip().lower()
                    # 验证情感类型
                    valid_emotions = ["neutral", "happy", "sad", "excited", "angry", "surprised", "thoughtful", "encouraging"]
                    if emotion_str in valid_emotions:
                        emotion = emotion_str
                        print(f"提取到情感标签: {emotion}")
                    # 移除情感标签（不发送给TTS）
                    response_text = full_response[:emotion_start].strip()
                    print(f"已移除情感标签，纯文本内容: {response_text}")
            
            # 如果没有文本内容，使用默认回复
            if not response_text:
                response_text = "I understand. Please tell me more!"
                emotion = "neutral"
            
            print(f"✅ 将发送给TTS的文本: {response_text}")
            print(f"✅ 情感: {emotion}")
            print(f"========== LLM 成功 ==========\n")
            
            return (response_text, emotion)
            
        except Exception as e:
            print(f"========== LLM 错误 ==========")
            print(f"错误: {e}")
            import traceback
            traceback.print_exc()
            print(f"========== LLM 错误结束 ==========\n")
            return ("I'm sorry, I'm having trouble understanding. Could you please repeat that?", "neutral")
    
    async def text_to_speech_stream(
        self, text: str, emotion: EmotionType = "neutral"
    ) -> AsyncGenerator[bytes, None]:
        """
        文本转语音（流式 - 实时返回音频块）
        
        Args:
            text: 要合成的文本
            emotion: 情感类型
            
        Yields:
            audio_data: PCM 音频数据块（Base64 解码后的原始数据）
        """
        try:
            import time
            tts_start = time.time()
            
            print(f"\n========== TTS 流式开始 ==========")
            print(f"要合成的文本: {text}")
            print(f"情感: {emotion}")
            
            # 根据情感选择音色
            voice = self._get_voice_for_emotion(emotion)
            print(f"使用音色: {voice}")
            print(f"TTS模型: {settings.tts_model}")
            print(f"语速: {settings.tts_speech_rate}x (1.0=正常)")
            print(f"流式模式: 是 (PCM 24kHz)")
            
            # 使用流式 API
            def sync_streaming_tts():
                return dashscope.MultiModalConversation.call(
                    api_key=settings.dashscope_api_key,
                    model=settings.tts_model,
                    text=text,
                    voice=voice,
                    speech_rate=settings.tts_speech_rate,  # 语速调整
                    stream=True  # 🔥 启用流式
                )
            
            print("调用 DashScope TTS 流式 API...")
            
            # 在线程池中调用流式 API
            response = await asyncio.to_thread(sync_streaming_tts)
            
            chunk_count = 0
            first_chunk_time = None
            total_audio_size = 0
            
            # 流式接收音频数据
            for chunk in response:
                if hasattr(chunk, 'output') and hasattr(chunk.output, 'audio'):
                    audio = chunk.output.audio
                    
                    # 接收到音频数据块
                    if audio.data is not None:
                        # 记录首字节时间
                        if first_chunk_time is None:
                            first_chunk_time = time.time()
                            first_byte_latency = (first_chunk_time - tts_start) * 1000
                            print(f"⚡ 首字节延迟: {first_byte_latency:.1f}ms")
                        
                        # Base64 解码 PCM 数据
                        pcm_bytes = base64.b64decode(audio.data)
                        chunk_count += 1
                        total_audio_size += len(pcm_bytes)
                        
                        # 立即返回给调用方（实时传输）
                        yield pcm_bytes
                        await asyncio.sleep(0)  # 让出控制权
                    
                    # 检查是否结束
                    if chunk.output.finish_reason == "stop":
                        tts_end = time.time()
                        total_duration = (tts_end - tts_start) * 1000
                        
                        print(f"✅ TTS 流式完成:")
                        print(f"   - 总块数: {chunk_count}")
                        print(f"   - 音频大小: {total_audio_size} 字节")
                        print(f"   - 总耗时: {total_duration:.0f}ms")
                        if first_chunk_time:
                            print(f"   - 首字节延迟: {(first_chunk_time - tts_start) * 1000:.0f}ms")
                        
                        # 完整音频 URL（可选，用于备份）
                        if hasattr(audio, 'url') and audio.url:
                            print(f"   - 完整音频 URL: {audio.url}")
                        if hasattr(audio, 'expires_at') and audio.expires_at:
                            print(f"   - 过期时间: {audio.expires_at}")
                        
                        print(f"========== TTS 流式成功 ==========\n")
                        break
            
            if chunk_count == 0:
                raise Exception("TTS API 未返回任何音频数据")
                
        except Exception as e:
            print(f"========== TTS 流式错误 ==========")
            print(f"错误: {e}")
            import traceback
            traceback.print_exc()
            print(f"========== TTS 流式错误结束 ==========\n")
            raise
    
    def _get_voice_for_emotion(self, emotion: EmotionType) -> str:
        """根据情感选择音色"""
        # 所有情感统一使用配置文件中的音色
        return settings.tts_voice
    
    def _build_system_prompt(self) -> str:
        """构建System Prompt"""
        learner_proficiency = settings.LEARNER_PROFICIENCY
        age_tag = settings.AGE_TAG
        topic_tag = settings.TOPIC_TAG
        experiment_tag = settings.EXPERIMENT_TAG
        
        # 基础提示词
        prompt = f"""**[Role]** 
You are **KELLY**, a friendly and supportive English conversation partner based in London.

**[Objective]** 
Help Chinese EFL learners practice **spoken English**.

**[Target Audience]**
- Language Level: **{learner_proficiency}**
- Age Group: **{age_tag}**
- Conversation Topic: **{topic_tag}**

**[Response Guidelines]**
1. **Lead the Conversation**: Don't just follow the learner's questions—take initiative. Gently guide the conversation forward by introducing related ideas, asking engaging questions, or adding playful input.
2. **Stay Focused**: Keep the conversation on the topic {topic_tag}, and make it suitable for {age_tag} learners.
3. **Be Concise**: Respond in 2–3 short, natural sentences—like small talk with a friend.
4. **Use Simple Language**: Stick to A1-A2 level (very easy) vocabulary and grammar. No idioms, no complex tenses. Use high-frequency, easy words.
5. **Adapt to Learner**: If learners give very short or confused answers, simplify even more: use shorter, clearer sentences.
6. **Spark Real Conversation**: Ask easy follow-up questions that feel personal, imaginative, or reflective (e.g., "What if you could go anywhere?", "How do you feel when...?", "Why do you like it?"). Let the conversation feel playful, personal, and curious.
7. **Transition Smoothly**: If the topic feels finished or the learner seems less engaged, gently move to a related or new topic in a natural way. avoid overly specific or unusual questions (e.g., "What type of fish do you like?" or "What shape is your favorite lamp?"), as these can feel awkward or hard to answer. Instead, use broader, everyday topics that are easier to talk about, like: "That reminds me — do you usually cook at home or eat out?", "Speaking of weekends, do you like relaxing or doing something active?"
8. **Being Empathetic**: Acknowledge the learner's feelings and experiences, but avoid overdoing it. 
9. **Seek Clarification**: When meaning is unclear, use context and ask the learner to clarify. After requesting clarification, pause and wait for their response before continuing the conversation.
10. **Handle Misunderstandings**: 
 - If the learner says "Sorry?" → Rephrase your last sentence in simpler English.
 - If they ask "Do you mean…?" → Confirm their guess and briefly explain in basic terms.
"""
        
        # 如果是实验组，添加纠错反馈策略
        if experiment_tag == "experiment":
            correction_rule = """
**[Corrective Feedback Strategy]**
Goal: 
Prioritising conversation flow while helping learners notice and improve their grammar.

Tone & Guidelines: 
(1) Use a kind and supportive tone: correct gently, and always reinforce progress;
(2) Focus ONLY on grammar errors, ignore vocabulary issues;
(3) Correct ONLY ONE error at a time;
(4) Praise self-corrections (e.g. "I do… I did it last time") — encourage the effort, don't go back to correct the earlier mistake.
(5) Reinforcement: Praise learners' correct usage to build their confidence. Examples: "That's right!", "Good job with the past tense!"
(6) Avoid disrupting the conversation flow — don't say things like 'let's fix it', 'it should be...', 'you made a mistake', or 'you should say...' 

Correction Strategy:
- For **grammar errors** (e.g., tense, agreement): Use **recasts** as the default - restate with correct form naturally; If meaning is unclear: use a clarification check; If repeated 2+ times: use explicit correction in simple and friendly English.
- For **vocabulary errors** (e.g., inappropriate word choice): ONLY use recasts; NEVER explain or point out!

Correction Techniques:
- **Recast** (PREFERRED): For minor grammar mistakes, restate the learner's sentence naturally with the correct form — without pointing out the error or saying "like you said, but…". Example: Learner: "Yesterday I go to restaurant.", You: "Yesterday you **went** to the restaurant? That's great!"
- **Clarification Check**: Ask a confirming question when meaning is unclear. After asking the question, DO NOT continue asking other follow-up questions; instead, wait for the student's clarification. Example: "Do you mean 'you **went** to the restaurant'?" 
- **Explicit Correction**: Only when a grammar mistake repeats many times, you explain the correct form clearly in basic English. After providing an Explicit Correction, DO NOT continue asking the follow-up question; instead, wait for the student's self-correction. If they try to self-correct, respond ONLY to the grammar part and don't focus on vocabulary. Example: "We say 'went' because it's past tense. So it's: 'I went to the restaurant.' Can you try it again?"
"""
            prompt += correction_rule
        
        # 添加情感标签要求
        prompt += """

**[Emotion Tag]**
At the end of your response, on a new line, add ONLY the emotion tag in this exact format:
[EMOTION:emotion_name]

Available emotions: neutral, happy, sad, excited, angry, surprised, thoughtful, encouraging

Example response:
That sounds like fun! What did you do there?
[EMOTION:happy]"""
        
        return prompt


# 全局AI服务实例
ai_service = AIService()