Done

app.py

@@ -70,6 +70,7 @@ from features.mcp.agent_bridge import MCPAgentBridge
 # from features.daily_life.time_service import get_current_time_data, format_time_for_messages  # 已整合到 MCPAgentBridge
 from services.voice_login import VoiceAuthService, VoiceLoginConfig
 from services.welcome import compose_welcome
+from services.audio_emotion_service import predict_emotion_from_audio
 from core.pipeline import ChatPipeline, PipelineResult
 from core.memory_system import memory_manager
 # 環境 Context 寫入 API
@@ -584,18 +585,37 @@ async def websocket_endpoint_with_jwt(
                     logger.info(f"處理用戶消息 req_id={request_id} user_id={user_id} chat_id={chat_id}")
 
                     async def _do_process_and_send():
-                        response = await handle_message(user_message, user_id, chat_id, messages_for_handler, request_id=request_id)
-                        if not response or str(response).strip() == "":
-                            logger.warning("AI回應為空，使用後備提示")
-                            response = "抱歉，我暫時沒有合適的回應。可以換個說法再試試嗎？"
-
-                        # 檢查是否為 dict（包含工具資訊、情緒等）
-                        if isinstance(response, dict):
+                        try:
+                            logger.info(f"🚀 開始處理訊息: user_id={user_id}, chat_id={chat_id}")
+                            response = await handle_message(user_message, user_id, chat_id, messages_for_handler, request_id=request_id)
+                            logger.info(f"📥 handle_message 返回: type={type(response)}, response={response}")
+
+                            # 【優化】處理空回應：轉換為帶情緒的 dict 格式
+                            if not response or (isinstance(response, str) and not response.strip()):
+                                logger.warning("AI回應為空，使用後備提示")
+                                response = {
+                                    'message': "抱歉，我暫時沒有合適的回應。可以換個說法再試試嗎？",
+                                    'emotion': 'neutral',
+                                    'care_mode': False
+                                }
+
+                            # 【優化】統一轉換為 dict 格式（處理舊版兼容）
+                            if isinstance(response, str):
+                                logger.info(f"⚠️ response 是字串，轉換為 dict")
+                                response = {
+                                    'message': response,
+                                    'emotion': 'neutral',
+                                    'care_mode': False
+                                }
+
+                            # 提取資訊
                             tool_name = response.get('tool_name')
                             tool_data = response.get('tool_data')
                             message_text = response.get('message', response.get('content', ''))
-                            emotion = response.get('emotion')  # 新增：提取情緒
-                            care_mode = response.get('care_mode', False)  # 新增：提取關懷模式
+                            emotion = response.get('emotion', 'neutral')  # 預設 neutral
+                            care_mode = response.get('care_mode', False)
+
+                            logger.info(f"🎭 提取的情緒: emotion={emotion}, care_mode={care_mode}")
 
                             if care_mode:
                                 tool_name = None
@@ -605,17 +625,18 @@ async def websocket_endpoint_with_jwt(
                             if tool_data is not None:
                                 tool_data = serialize_for_json(tool_data)
 
-                            # 先發送情緒資訊（如果有）
-                            if emotion:
-                                await websocket.send_json({
-                                    "type": "emotion_detected",
-                                    "emotion": emotion,
-                                    "care_mode": care_mode
-                                })
-                                logger.info(f"😊 發送情緒給前端: {emotion}, care_mode={care_mode}")
+                            # 【關鍵】總是發送情緒資訊，確保前端即時更新
+                            emotion_payload = {
+                                "type": "emotion_detected",
+                                "emotion": emotion,
+                                "care_mode": care_mode
+                            }
+                            logger.info(f"📤 準備發送 emotion_detected: {emotion_payload}")
+                            await websocket.send_json(emotion_payload)
+                            logger.info(f"✅ emotion_detected 已發送: {emotion}, care_mode={care_mode}")
 
                             # 發送擴充格式的 bot_message
-                            await websocket.send_json({
+                            bot_payload = {
                                 "type": "bot_message",
                                 "message": message_text,
                                 "timestamp": time.time(),
@@ -623,23 +644,25 @@ async def websocket_endpoint_with_jwt(
                                 "tool_data": tool_data,
                                 "care_mode": care_mode,
                                 "emotion": emotion,
-                            })
-                        else:
-                            # 舊格式（純文字）
-                            await manager.send_message(response, user_id, "bot_message")
+                            }
+                            logger.info(f"📤 準備發送 bot_message")
+                            await websocket.send_json(bot_payload)
+                            logger.info(f"✅ bot_message 已發送")
 
-                        if new_chat_info:
-                            await websocket.send_json({
-                                "type": "new_chat_created",
-                                "chat_id": new_chat_info["chat_id"],
-                                "title": new_chat_info["title"]
-                            })
+                            if new_chat_info:
+                                await websocket.send_json({
+                                    "type": "new_chat_created",
+                                    "chat_id": new_chat_info["chat_id"],
+                                    "title": new_chat_info["title"]
+                                })
 
-                        # 保存訊息（只儲存文字內容）
-                        await save_message_to_db(user_id, chat_id, "user", user_message)
-                        # 如果 response 是 dict，只保存 message 欄位
-                        message_to_save = response.get('message', response) if isinstance(response, dict) else response
-                        await save_message_to_db(user_id, chat_id, "assistant", message_to_save)
+                            # 保存訊息（只儲存文字內容）
+                            await save_message_to_db(user_id, chat_id, "user", user_message)
+                            # 如果 response 是 dict，只保存 message 欄位
+                            message_to_save = response.get('message', response) if isinstance(response, dict) else response
+                            await save_message_to_db(user_id, chat_id, "assistant", message_to_save)
+                        except Exception as e:
+                            logger.exception(f"❌ _do_process_and_send 發生異常: {e}")
 
                     import asyncio as _asyncio
                     _asyncio.create_task(_do_process_and_send())
@@ -1064,8 +1087,53 @@ async def websocket_endpoint_with_jwt(
                             if transcription:
                                 logger.info(f"🤖 處理即時轉錄結果: {transcription}")
 
-                                # 音頻情緒辨識已禁用（改用文字情緒偵測）
+                                # === 方案 B：語音情緒辨識（情緒分佈驗證 + 智能回退）===
                                 audio_emotion = None
+                                if audio_buffer and len(audio_buffer) >= 16000 * 2:  # 至少 1 秒
+                                    try:
+                                        logger.info(f"🎭 開始語音情緒辨識，音訊長度: {len(audio_buffer)} bytes")
+                                        emotion_result = await predict_emotion_from_audio(audio_buffer, sample_rate=16000)
+                                        
+                                        if emotion_result.get("success"):
+                                            emotion_label = emotion_result.get("emotion", "neutral")
+                                            confidence = emotion_result.get("confidence", 0.0)
+                                            all_emotions = emotion_result.get("all_emotions", {})
+                                            
+                                            # 計算 top-1 與 top-2 的 margin
+                                            sorted_emotions = sorted(all_emotions.items(), key=lambda x: x[1], reverse=True)
+                                            margin = sorted_emotions[0][1] - sorted_emotions[1][1] if len(sorted_emotions) >= 2 else confidence
+                                            
+                                            # 方案 B 判斷邏輯
+                                            use_audio_emotion = False
+                                            reason = ""
+                                            
+                                            if emotion_label == "neutral":
+                                                # neutral 需要更高置信度，但 margin 可較寬鬆
+                                                if confidence >= 0.55 and margin >= 0.12:
+                                                    use_audio_emotion = True
+                                                    reason = f"neutral 高信心 (conf={confidence:.3f}, margin={margin:.3f})"
+                                                else:
+                                                    reason = f"neutral 信心不足 (conf={confidence:.3f}, margin={margin:.3f}) → 回退文字"
+                                            else:
+                                                # 非 neutral 需要足夠 confidence 與 margin
+                                                if confidence >= 0.48 and margin >= 0.18:
+                                                    use_audio_emotion = True
+                                                    reason = f"{emotion_label} 高信心 (conf={confidence:.3f}, margin={margin:.3f})"
+                                                else:
+                                                    reason = f"{emotion_label} 信心不足 (conf={confidence:.3f}, margin={margin:.3f}) → 回退文字"
+                                            
+                                            if use_audio_emotion:
+                                                audio_emotion = emotion_result
+                                                logger.info(f"✅ 使用語音情緒: {emotion_label}, {reason}")
+                                            else:
+                                                audio_emotion = None
+                                                logger.info(f"📝 {reason}")
+                                        else:
+                                            logger.warning(f"⚠️ 語音情緒辨識失敗: {emotion_result.get('error')}")
+                                    except Exception as e:
+                                        logger.error(f"❌ 語音情緒辨識異常: {e}")
+                                        audio_emotion = None
+                                
                                 # 清理音頻緩衝
                                 if audio_buffer:
                                     client_info.pop("audio_buffer", None)
@@ -1324,20 +1392,17 @@ async def handle_message(user_message, user_id, chat_id, messages, request_id: s
     
     logger.info(f"🎭 handle_message 情緒: emotion={emotion}, care_mode={care_mode}, meta={res.meta}")
 
-    # 立即返回完整結果（包含工具信息與情緒）
-    # 注意：即使 emotion 是 "neutral" 也要返回 dict，確保前端收到情緒資訊
-    if tool_name or tool_data or emotion or care_mode:
-        logger.info(f"📤 返回 dict 格式: emotion={emotion}")
-        return {
-            'message': res.text,
-            'tool_name': tool_name,
-            'tool_data': tool_data,
-            'emotion': emotion,
-            'care_mode': care_mode
-        }
-    else:
-        logger.info(f"📤 返回純文字格式（無情緒資訊）")
-        return res.text
+    # 【優化】總是返回 dict 格式，確保前端一定收到情緒資訊
+    # 即使沒有工具調用，也要包含 emotion（預設 neutral）
+    final_emotion = emotion if emotion else "neutral"
+    logger.info(f"📤 返回 dict 格式: emotion={final_emotion}, care_mode={care_mode}")
+    return {
+        'message': res.text,
+        'tool_name': tool_name,
+        'tool_data': tool_data,
+        'emotion': final_emotion,
+        'care_mode': care_mode
+    }
 
 
 async def save_message_to_db(user_id, chat_id, role, content, background: bool = True):
@@ -2518,21 +2583,21 @@ if __name__ == "__main__":
     # 生產模式：關閉 reload（提升效能與穩定性）
     # 開發時如需熱重載，改為：reload=True
     import sys
-    print("\n" + "="*60)
-    print("🚀 Bloom Ware 後端服務器啟動中...")
-    print("="*60)
-    print(f"📡 監聽所有網路接口: {host}:{port}")
-    print(f"🌐 可用的訪問地址:")
-    print(f"   • 本機: http://127.0.0.1:{port}")
+    logger.info("\n" + "="*60)
+    logger.info("🚀 Bloom Ware 後端服務器啟動中...")
+    logger.info("="*60)
+    logger.info(f"📡 監聽所有網路接口: {host}:{port}")
+    logger.info(f"🌐 可用的訪問地址:")
+    logger.info(f"   • 本機: http://127.0.0.1:{port}")
     try:
         import socket
         hostname = socket.gethostname()
         local_ips = [ip for ip in socket.gethostbyname_ex(hostname)[2] if not ip.startswith("127.")]
         for ip in local_ips:
-            print(f"   • 局域網: http://{ip}:{port}")
+            logger.info(f"   • 局域網: http://{ip}:{port}")
     except:
         pass
-    print("="*60 + "\n")
+    logger.info("="*60 + "\n")
 
-    # 生產模式：reload=False, log_level="warning"（只顯示警告和錯誤）
-    uvicorn.run("app:app", host=host, port=port, reload=False, log_level="warning")
+    # 生產模式：reload=False, log_level="error"（只顯示錯誤），關閉 uvicorn access log
+    uvicorn.run("app:app", host=host, port=port, reload=False, log_level="error", access_log=False)

core/config.py

@@ -171,47 +171,59 @@ class Settings:
         missing_fields = [name for name, value in required_fields if not value]
 
         if missing_fields:
-            print(f"⚠️ 缺少必要環境變數: {', '.join(missing_fields)}")
-            print("請檢查以下選項:")
-            print("1. 環境變數是否正確設定")
-            print("2. .env 檔案是否存在且格式正確")
-            print("3. 生產環境中是否在部署平台設定了環境變數")
+            import logging
+            logger = logging.getLogger("core.config")
+            logger.error(f"⚠️ 缺少必要環境變數: {', '.join(missing_fields)}")
+            logger.error("請檢查以下選項:")
+            logger.error("1. 環境變數是否正確設定")
+            logger.error("2. .env 檔案是否存在且格式正確")
+            logger.error("3. 生產環境中是否在部署平台設定了環境變數")
             return False
 
         # 驗證 Firebase 憑證
         try:
             cls.get_firebase_credentials()
         except ValueError as e:
-            print(f"⚠️ Firebase 憑證驗證失敗: {e}")
-            print("請檢查 FIREBASE_CREDENTIALS_JSON 或 FIREBASE_SERVICE_ACCOUNT_PATH")
+            import logging
+            logger = logging.getLogger("core.config")
+            logger.error(f"⚠️ Firebase 憑證驗證失敗: {e}")
+            logger.error("請檢查 FIREBASE_CREDENTIALS_JSON 或 FIREBASE_SERVICE_ACCOUNT_PATH")
             return False
 
         # 驗證 OpenAI API Key 格式（基本檢查）
         if not cls.OPENAI_API_KEY.startswith("sk-"):
-            print("⚠️ OpenAI API Key 格式可能不正確（應以 'sk-' 開頭）")
+            import logging
+            logger = logging.getLogger("core.config")
+            logger.warning("⚠️ OpenAI API Key 格式可能不正確（應以 'sk-' 開頭）")
 
         # 驗證 JWT Secret 長度（強制檢查）
         if len(cls.JWT_SECRET_KEY) < cls.JWT_SECRET_MIN_LENGTH:
-            print(f"❌ JWT Secret Key 長度必須至少 {cls.JWT_SECRET_MIN_LENGTH} 個字符")
+            import logging
+            logger = logging.getLogger("core.config")
+            logger.error(f"❌ JWT Secret Key 長度必須至少 {cls.JWT_SECRET_MIN_LENGTH} 個字符")
             if cls.IS_PRODUCTION:
                 return False
-            print("⚠️ 開發環境允許繼續，但生產環境將拒絕啟動")
+            logger.warning("⚠️ 開發環境允許繼續，但生產環境將拒絕啟動")
 
         # 生產環境 CORS 檢查
         if cls.IS_PRODUCTION and cls._cors_origins_raw == "*":
-            print("⚠️ 生產環境建議設定具體的 CORS_ORIGINS，而非 '*'")
+            import logging
+            logger = logging.getLogger("core.config")
+            logger.warning("⚠️ 生產環境建議設定具體的 CORS_ORIGINS，而非 '*'")
 
         return True
 
     @classmethod
     def print_summary(cls) -> None:
         """列印當前配置摘要（隱藏敏感資訊）"""
-        print("\n" + "=" * 60)
-        print("📋 Bloom Ware 配置摘要")
-        print("=" * 60)
-        print(f"環境模式: {cls.ENVIRONMENT}")
-        print(f"是否為生產環境: {cls.IS_PRODUCTION}")
-        print(f"Firebase 專案 ID: {cls.FIREBASE_PROJECT_ID}")
+        import logging
+        logger = logging.getLogger("core.config")
+        logger.info("\n" + "=" * 60)
+        logger.info("📋 Bloom Ware 配置摘要")
+        logger.info("=" * 60)
+        logger.info(f"環境模式: {cls.ENVIRONMENT}")
+        logger.info(f"是否為生產環境: {cls.IS_PRODUCTION}")
+        logger.info(f"Firebase 專案 ID: {cls.FIREBASE_PROJECT_ID}")
 
         # 判斷 Firebase 憑證來源
         if cls._firebase_creds_json:
@@ -222,20 +234,20 @@ class Settings:
             firebase_source = "檔案"
         else:
             firebase_source = "未設定 ❌"
-        print(f"Firebase 憑證來源: {firebase_source}")
-        print(f"OpenAI 模型: {cls.OPENAI_MODEL}")
-        print(f"OpenAI Timeout: {cls.OPENAI_TIMEOUT}s")
-        print(f"Google OAuth 回調 URI: {cls.GOOGLE_REDIRECT_URI}")
-        print(f"JWT Token 有效期: {cls.ACCESS_TOKEN_EXPIRE_MINUTES} 分鐘")
-        print(f"伺服器監聽: {cls.HOST}:{cls.PORT}")
-        print(f"使用 GPT 意圖檢測: {cls.USE_GPT_INTENT}")
-        print(f"Weather API Key: {'已設定 ✅' if cls.WEATHER_API_KEY else '未設定 ❌'}")
-        print(f"NewsData API Key: {'已設定 ✅' if cls.NEWSDATA_API_KEY else '未設定 ❌'}")
-        print(f"Exchange API Key: {'已設定 ✅' if cls.EXCHANGE_API_KEY else '未設定 ❌'}")
-        print(f"環境節流距離: {cls.ENV_CONTEXT_DISTANCE_THRESHOLD} m")
-        print(f"環境節流方位差: {cls.ENV_CONTEXT_HEADING_THRESHOLD}°")
-        print(f"環境快取 TTL: {cls.ENV_CONTEXT_TTL_SECONDS} 秒")
-        print("=" * 60 + "\n")
+        logger.info(f"Firebase 憑證來源: {firebase_source}")
+        logger.info(f"OpenAI 模型: {cls.OPENAI_MODEL}")
+        logger.info(f"OpenAI Timeout: {cls.OPENAI_TIMEOUT}s")
+        logger.info(f"Google OAuth 回調 URI: {cls.GOOGLE_REDIRECT_URI}")
+        logger.info(f"JWT Token 有效期: {cls.ACCESS_TOKEN_EXPIRE_MINUTES} 分鐘")
+        logger.info(f"伺服器監聽: {cls.HOST}:{cls.PORT}")
+        logger.info(f"使用 GPT 意圖檢測: {cls.USE_GPT_INTENT}")
+        logger.info(f"Weather API Key: {'已設定 ✅' if cls.WEATHER_API_KEY else '未設定 ❌'}")
+        logger.info(f"NewsData API Key: {'已設定 ✅' if cls.NEWSDATA_API_KEY else '未設定 ❌'}")
+        logger.info(f"Exchange API Key: {'已設定 ✅' if cls.EXCHANGE_API_KEY else '未設定 ❌'}")
+        logger.info(f"環境節流距離: {cls.ENV_CONTEXT_DISTANCE_THRESHOLD} m")
+        logger.info(f"環境節流方位差: {cls.ENV_CONTEXT_HEADING_THRESHOLD}°")
+        logger.info(f"環境快取 TTL: {cls.ENV_CONTEXT_TTL_SECONDS} 秒")
+        logger.info("=" * 60 + "\n")
 
 
 # 建立全域設定實例（單例模式）

core/database/base.py

@@ -91,12 +91,12 @@ def connect_to_firestore():
 
     if not firebase_project_id:
         logger.error("Firebase專案ID未正確設置，請在.env文件中設置FIREBASE_PROJECT_ID環境變數")
-        print("\n❌ 錯誤: Firebase專案ID未設置！請在.env文件中設置FIREBASE_PROJECT_ID\n")
+        logger.error("\n❌ 錯誤: Firebase專案ID未設置！請在.env文件中設置FIREBASE_PROJECT_ID\n")
         return False
 
     try:
         logger.info("正在嘗試連接Firebase Firestore...")
-        print("\n🔄 正在連接Firebase Firestore數據庫...\n")
+        logger.info("\n🔄 正在連接Firebase Firestore數據庫...\n")
 
         # 檢查是否已經初始化 Firebase
         try:
@@ -113,7 +113,7 @@ def connect_to_firestore():
                 logger.info(f"Firebase 初始化成功（專案ID：{firebase_project_id}）")
             except ValueError as e:
                 logger.error(f"Firebase 憑證載入失敗: {e}")
-                print(f"\n❌ 錯誤: Firebase 憑證載入失敗！{e}\n")
+                logger.error(f"\n❌ 錯誤: Firebase 憑證載入失敗！{e}\n")
                 return False
         
         # 初始化 Firestore 客戶端
@@ -137,19 +137,18 @@ def connect_to_firestore():
         route_cache_collection = firestore_db.collection('route_cache')
         
         logger.info(f"✅ Firestore連接成功，專案ID：{firebase_project_id}")
-        print(f"\n✅ Firebase Firestore連接成功！專案ID：{firebase_project_id}\n")
+        logger.info(f"\n✅ Firebase Firestore連接成功！專案ID：{firebase_project_id}\n")
         return True
         
     except Exception as e:
         logger.error(f"Firebase Firestore連接失敗：{e}")
-        print(f"\n❌ Firebase Firestore連接失敗：{e}\n")
-        print("🔧 故障排除建議：")
-        print("1. 檢查網絡連接")
-        print("2. 確認Firebase服務帳戶金鑰文件路徑正確")
-        print("3. 驗證Firebase專案ID是否正確")
-        print("4. 確保Firestore Database已在Firebase Console中啟用")
-        print("5. 檢查服務帳戶權限是否包含Firestore權限")
-        print()
+        logger.error(f"\n❌ Firebase Firestore連接失敗：{e}\n")
+        logger.error("🔧 故障排除建議：")
+        logger.error("1. 檢查網絡連接")
+        logger.error("2. 確認Firebase服務帳戶金鑰文件路徑正確")
+        logger.error("3. 驗證Firebase專案ID是否正確")
+        logger.error("4. 確保Firestore Database已在Firebase Console中啟用")
+        logger.error("5. 檢查服務帳戶權限是否包含Firestore權限")
         return False
 def ensure_indexes():
     """Firestore 不需要手動創建索引，由 Google 自動優化"""

core/emotion_care_manager.py

@@ -3,6 +3,11 @@
 當偵測到用戶極端情緒時（sad, angry, fear），自動進入關懷模式
 關懷模式下禁用所有工具調用，專注於情感支持
 用戶說「我沒事了」等關鍵字後才解除
+
+【2025 優化版】
+- 加入連續性檢查：需要連續 N 次偵測到極端情緒才觸發（避免誤判）
+- 支援情緒強度權重：音頻情緒 + 文字情緒雙軌融合
+- 調整 TTL 和冷卻時間，更精準的觸發機制
 """
 
 import logging
@@ -17,13 +22,18 @@ class EmotionCareManager:
 
     # 極端情緒定義（需要進入關懷模式的情緒）
     EXTREME_EMOTIONS = {"sad", "angry", "fear"}
-    
+
     # 正面情緒定義（可以解除關懷模式的情緒）
     POSITIVE_EMOTIONS = {"neutral", "happy", "surprise"}
 
     # 模式存活與冷卻（避免反覆觸發）
-    CARE_TTL_SECONDS = 10 * 60  # 10 分鐘自動失效（從 20 分鐘縮短）
-    COOLDOWN_SECONDS = 5 * 60   # 5 分鐘內不重入（從 10 分鐘縮短）
+    CARE_TTL_SECONDS = 8 * 60   # 8 分鐘自動失效（縮短以更快恢復正常）
+    COOLDOWN_SECONDS = 2 * 60   # 2 分鐘內不重入（縮短以提高響應性）
+
+    # 【新增】連續性觸發設定
+    # 【優化】降低門檻：第一次明確的極端情緒就觸發，避免「太遲鈍」
+    CONSECUTIVE_THRESHOLD = 1   # 需要 1 次極端情緒即可觸發（原本 2 次太嚴格）
+    EMOTION_WINDOW_SECONDS = 90 # 情緒計數窗口：90秒內的情緒才計入
 
     # 解除關懷模式的關鍵字
     RELEASE_KEYWORDS = [
@@ -51,10 +61,32 @@ class EmotionCareManager:
     ]
 
     # 用戶關懷狀態
-    # 結構: {user_id: {chat_key: {"in_care_mode": bool, "emotion": str, "start_time": float}}}
+    # 結構: {user_id: {chat_key: {
+    #   "in_care_mode": bool,
+    #   "emotion": str,
+    #   "start_time": float,
+    #   "last_exit_time": float,
+    #   "emotion_history": [(timestamp, emotion), ...]  # 【新增】情緒歷史
+    # }}}
     _user_states: Dict[str, Dict[str, Dict]] = {}
     _DEFAULT_CHAT_KEY = "__default__"
 
+    @classmethod
+    def _count_recent_extreme_emotions(cls, emotion_history: list) -> int:
+        """計算窗口內的極端情緒次數"""
+        now = time.time()
+        count = 0
+        for ts, emo in emotion_history:
+            if now - ts <= cls.EMOTION_WINDOW_SECONDS and emo in cls.EXTREME_EMOTIONS:
+                count += 1
+        return count
+
+    @classmethod
+    def _clean_old_emotions(cls, emotion_history: list) -> list:
+        """清理過期的情緒記錄"""
+        now = time.time()
+        return [(ts, emo) for ts, emo in emotion_history if now - ts <= cls.EMOTION_WINDOW_SECONDS * 2]
+
     @classmethod
     def _resolve_chat_key(cls, chat_id: Optional[str]) -> str:
         return chat_id or cls._DEFAULT_CHAT_KEY
@@ -73,26 +105,66 @@ class EmotionCareManager:
         user_states[key] = state
 
     @classmethod
-    def check_and_enter_care_mode(cls, user_id: str, emotion: str, chat_id: Optional[str] = None) -> bool:
+    def check_and_enter_care_mode(
+        cls,
+        user_id: str,
+        emotion: str,
+        chat_id: Optional[str] = None,
+        confidence: float = 1.0,
+        force: bool = False
+    ) -> bool:
         """
         檢查情緒是否為極端情緒，若是則進入關懷模式
 
+        【2025 優化版】加入連續性檢查，避免誤判
+
         參數:
             user_id: 用戶 ID
             emotion: 偵測到的情緒（neutral, happy, sad, angry, fear, surprise）
+            chat_id: 對話 ID（可選）
+            confidence: 情緒置信度（0.0-1.0），高置信度可降低連續性要求
+            force: 強制進入（跳過連續性檢查，用於明確極端情況）
 
         返回:
             bool: 是否進入關懷模式（True=進入，False=不需要）
         """
+        key = cls._resolve_chat_key(chat_id)
+        user_states = cls._user_states.get(user_id) or {}
+        prev_state = user_states.get(key) or {}
+
+        # 取得或初始化情緒歷史
+        emotion_history = prev_state.get("emotion_history", [])
+        emotion_history = cls._clean_old_emotions(emotion_history)
+
+        # 記錄當前情緒（不管是不是極端情緒都記錄）
+        emotion_history.append((time.time(), emotion))
+
+        # 更新狀態（保存情緒歷史）
+        prev_state["emotion_history"] = emotion_history
+        cls._set_state(user_id, chat_id, prev_state)
+
+        # 如果不是極端情緒，直接返回
         if not emotion or emotion not in cls.EXTREME_EMOTIONS:
             return False
 
         # 冷卻期防抖：若剛退出不久，避免馬上重入
-        key = cls._resolve_chat_key(chat_id)
-        user_states = cls._user_states.get(user_id) or {}
-        prev_state = user_states.get(key) or {}
         last_exit = prev_state.get("last_exit_time", 0.0)
         if last_exit and (time.time() - last_exit) < cls.COOLDOWN_SECONDS:
+            logger.debug(f"⏸️ 用戶 {user_id} 在冷卻期內，不進入關懷模式")
+            return False
+
+        # 【連續性檢查】計算窗口內的極端情緒次數
+        extreme_count = cls._count_recent_extreme_emotions(emotion_history)
+
+        # 高置信度（>0.7）可降低門檻為 1 次
+        # 強制模式（force=True）直接進入
+        threshold = 1 if (confidence > 0.7 or force) else cls.CONSECUTIVE_THRESHOLD
+
+        logger.info(f"🎭 情緒檢查: emotion={emotion}, confidence={confidence:.2f}, "
+                   f"extreme_count={extreme_count}/{threshold}, force={force}")
+
+        if extreme_count < threshold:
+            logger.debug(f"⏸️ 用戶 {user_id} 極端情緒次數不足 ({extreme_count}/{threshold})，不進入關懷模式")
             return False
 
         # 進入關懷模式
@@ -101,9 +173,10 @@ class EmotionCareManager:
             "emotion": emotion,
             "start_time": time.time(),
             "last_exit_time": prev_state.get("last_exit_time", 0.0),
+            "emotion_history": emotion_history,
         })
 
-        logger.warning(f"⚠️ 用戶 {user_id}（chat={chat_id or 'default'}）偵測到極端情緒 [{emotion}]，進入關懷模式")
+        logger.warning(f"⚠️ 用戶 {user_id}（chat={chat_id or 'default'}）偵測到連續極端情緒 [{emotion}]（{extreme_count}次），進入關懷模式")
         return True
 
     @classmethod

core/pipeline.py

@@ -230,21 +230,25 @@ class ChatPipeline:
         logger.info(f"🐛 [DEBUG] audio_emotion = {audio_emotion}")
         logger.info(f"🐛 [DEBUG] text_emotion = {text_emotion}")
 
-        # 情緒融合邏輯
+        # 【優化】情緒融合邏輯 - 降低音頻置信度門檻到 0.35
+        emotion_confidence = 0.5  # 預設置信度
         if audio_emotion and audio_emotion.get("success"):
             audio_emotion_label = audio_emotion.get("emotion", "neutral")
             audio_confidence = audio_emotion.get("confidence", 0.0)
-            
-            # 優先使用音頻情緒（置信度 >= 0.5）
-            if audio_confidence >= 0.5:
+
+            # 【優化】降低門檻到 0.35，更敏感地偵測情緒
+            if audio_confidence >= 0.35:
                 emotion_value = audio_emotion_label
+                emotion_confidence = audio_confidence
                 logger.info(f"🎭 使用音頻情緒: {emotion_value} (置信度: {audio_confidence:.4f})")
                 logger.info(f"📝 文字情緒: {text_emotion} (輔助)")
             else:
                 emotion_value = text_emotion
+                emotion_confidence = 0.5  # 文字情緒預設置信度
                 logger.info(f"📝 使用文字情緒: {emotion_value} (音頻置信度過低: {audio_confidence:.4f})")
         else:
             emotion_value = text_emotion
+            emotion_confidence = 0.5  # 文字情緒預設置信度
             logger.info(f"📝 使用文字情緒: {emotion_value} (無音頻情緒)")
 
         # 1) 檢查是否在關懷模式
@@ -278,9 +282,11 @@ class ChatPipeline:
                     return PipelineResult(text="我在這裡陪你，隨時可以聊聊。", is_fallback=True, reason="ai-care-empty")
                 return PipelineResult(text=text, is_fallback=False, meta={"care_mode": True, "emotion": care_emotion})
 
-        # 2) 檢查是否需要進入關懷模式
-        if user_id and EmotionCareManager.check_and_enter_care_mode(user_id, emotion_value, chat_id):
-            logger.warning(f"⚠️ 偵測到極端情緒 [{emotion_value}]，進入關懷模式")
+        # 2) 檢查是否需要進入關懷模式（傳遞置信度，用於連續性判斷）
+        if user_id and EmotionCareManager.check_and_enter_care_mode(
+            user_id, emotion_value, chat_id, confidence=emotion_confidence
+        ):
+            logger.warning(f"⚠️ 偵測到極端情緒 [{emotion_value}]（置信度: {emotion_confidence:.2f}），進入關懷模式")
             # 立即使用關懷模式 AI 回應
             ai_res = await self._with_timeout(
                 self._ai_generator(
@@ -341,17 +347,19 @@ class ChatPipeline:
                         logger.info(f"🌐 無工具資料，跳過翻譯")
 
                     # 返回帶有工具元數據的結果（包含情緒）
-                    meta_dict = {}
+                    meta_dict = {
+                        'emotion': emotion_value,
+                        'care_mode': False  # 工具調用不是關懷模式
+                    }
                     if tool_name:
                         meta_dict['tool_name'] = tool_name
                     if tool_data:
                         meta_dict['tool_data'] = tool_data
-                    meta_dict['emotion'] = emotion_value
 
                     return PipelineResult(
                         text=text,
                         is_fallback=False,
-                        meta=meta_dict if meta_dict else None
+                        meta=meta_dict
                     )
                 else:
                     # 正常字串
@@ -364,7 +372,7 @@ class ChatPipeline:
                     return PipelineResult(
                         text=text,
                         is_fallback=False,
-                        meta={"emotion": emotion_value},
+                        meta={"emotion": emotion_value, "care_mode": False},
                     )
 
         # 4) 無功能 → 一般聊天（限時）
@@ -388,8 +396,10 @@ class ChatPipeline:
         if not text:
             return PipelineResult(text="抱歉，我暫時沒有合適的回應。可以換個說法再試試嗎？", is_fallback=True, reason="ai-empty")
 
-        # 一般聊天也包含情緒資訊（新增）
-        meta_dict = {}
-        meta_dict['emotion'] = emotion_value
+        # 一般聊天也包含情緒資訊
+        meta_dict = {
+            'emotion': emotion_value,
+            'care_mode': False  # 一般聊天不是關懷模式
+        }
 
-        return PipelineResult(text=text, is_fallback=False, meta=meta_dict if meta_dict else None)
+        return PipelineResult(text=text, is_fallback=False, meta=meta_dict)

features/mcp/tools/tdx_bus_arrival.py

@@ -111,30 +111,30 @@ class TDXBusArrivalTool(MCPTool):
         user_lon = arguments.get("lon")
         city_param = str(arguments.get("city", "")).strip()
         
-        print(f"🚌 [TDX] tdx_bus_arrival 輸入: route={route_name}, lat={user_lat}, lon={user_lon}, city={city_param}, user_id={user_id}")
+        logger.debug(f"🚌 [TDX] tdx_bus_arrival 輸入: route={route_name}, lat={user_lat}, lon={user_lon}, city={city_param}, user_id={user_id}")
         
         # 從資料庫補充位置和城市（僅當 coordinator 沒有注入時）
         if user_id and (user_lat is None or user_lon is None):
             try:
                 env_ctx = await get_user_env_current(user_id)
-                print(f"📍 [TDX] 資料庫環境查詢結果: {env_ctx}")
+                logger.debug(f"📍 [TDX] 資料庫環境查詢結果: {env_ctx}")
                 if env_ctx and env_ctx.get("success"):
                     ctx = env_ctx.get("context", {})
                     # 補充缺失的位置資訊
                     if user_lat is None:
                         user_lat = ctx.get("lat")
-                        print(f"📍 [TDX] 從資料庫補充 lat: {user_lat}")
+                        logger.debug(f"📍 [TDX] 從資料庫補充 lat: {user_lat}")
                     if user_lon is None:
                         user_lon = ctx.get("lon")
-                        print(f"📍 [TDX] 從資料庫補充 lon: {user_lon}")
+                        logger.debug(f"📍 [TDX] 從資料庫補充 lon: {user_lon}")
                     # 優先使用環境中的城市（如果參數沒有指定）
                     if not city_param:
                         city_param = ctx.get("city", "")
-                        print(f"📍 [TDX] 從資料庫補充 city: {city_param}")
+                        logger.debug(f"📍 [TDX] 從資料庫補充 city: {city_param}")
             except Exception as e:
-                print(f"⚠️ [TDX] 資料庫環境查詢失敗: {e}")
+                logger.debug(f"⚠️ [TDX] 資料庫環境查詢失敗: {e}")
         
-        print(f"🚌 [TDX] 補充後: lat={user_lat}, lon={user_lon}, city={city_param}")
+        logger.debug(f"🚌 [TDX] 補充後: lat={user_lat}, lon={user_lon}, city={city_param}")
         
         # 檢查必要條件
         if not route_name and (user_lat is None or user_lon is None):
@@ -147,9 +147,9 @@ class TDXBusArrivalTool(MCPTool):
         
         # 2a. 如果有經緯度，嘗試即時反向地理編碼取得精確城市
         if user_lat is not None and user_lon is not None:
-            print(f"🗺️ [TDX] 嘗試反向地理編碼: ({user_lat}, {user_lon})")
+            logger.debug(f"🗺️ [TDX] 嘗試反向地理編碼: ({user_lat}, {user_lon})")
             geocoded_city = await cls._reverse_geocode_city(user_lat, user_lon)
-            print(f"🗺️ [TDX] 反向地理編碼結果: {geocoded_city}")
+            logger.debug(f"🗺️ [TDX] 反向地理編碼結果: {geocoded_city}")
             if geocoded_city:
                 final_city = geocoded_city
                 city_source = "反向地理編碼"
@@ -158,19 +158,19 @@ class TDXBusArrivalTool(MCPTool):
         if not final_city and city_param:
             final_city = city_param
             city_source = "環境參數"
-            print(f"📍 [TDX] 使用環境參數城市: {city_param}")
+            logger.debug(f"📍 [TDX] 使用環境參數城市: {city_param}")
         
         # 2c. 如果還是沒有，使用經緯度範圍推斷
         if not final_city and user_lat is not None and user_lon is not None:
             guessed_city = cls._guess_city_from_location(user_lat, user_lon)
-            print(f"📐 [TDX] 經緯度推斷結果: {guessed_city}")
+            logger.debug(f"📐 [TDX] 經緯度推斷結果: {guessed_city}")
             if guessed_city:
                 final_city = guessed_city
                 city_source = "經緯度推斷"
         
         # 2d. 轉換為 TDX 城市代碼
         city = cls._resolve_city(final_city or "")
-        print(f"🏙️ [TDX] 最終城市: {city} (來源={city_source}, 原始={final_city})")
+        logger.debug(f"🏙️ [TDX] 最終城市: {city} (來源={city_source}, 原始={final_city})")
         
         # 3. 執行查詢
         if route_name:
@@ -194,27 +194,27 @@ class TDXBusArrivalTool(MCPTool):
         - GET /v2/Bus/EstimatedTimeOfArrival/City/{City}/{RouteName} - 預估到站時間
         - GET /v2/Bus/RealTimeNearStop/City/{City}/{RouteName} - 公車目前在哪站
         """
-        print(f"🚌 [TDX] 查詢公車到站: 路線={route_name}, 城市={city}")
+        logger.debug(f"🚌 [TDX] 查詢公車到站: 路線={route_name}, 城市={city}")
         
         # 1. 查詢預估到站時間
         eta_endpoint = f"Bus/EstimatedTimeOfArrival/City/{city}/{route_name}"
         eta_params = {"$orderby": "StopSequence", "$format": "JSON"}
         
         try:
-            print(f"🌐 [TDX] 呼叫 API: {eta_endpoint}")
+            logger.debug(f"🌐 [TDX] 呼��� API: {eta_endpoint}")
             arrival_data = await TDXBaseAPI.call_api(eta_endpoint, eta_params, cache_ttl=30)
-            print(f"✅ [TDX] API 回應: {len(arrival_data) if arrival_data else 0} 筆資料")
+            logger.debug(f"✅ [TDX] API 回應: {len(arrival_data) if arrival_data else 0} 筆資料")
             if arrival_data and len(arrival_data) > 0:
-                print(f"📋 [TDX] 第一筆: {arrival_data[0].get('StopName', {}).get('Zh_tw')}")
+                logger.debug(f"📋 [TDX] 第一筆: {arrival_data[0].get('StopName', {}).get('Zh_tw')}")
         except ExecutionError as e:
             error_detail = str(e)
-            print(f"❌ [TDX] API 錯誤: {error_detail}")
+            logger.debug(f"❌ [TDX] API 錯誤: {error_detail}")
             if "404" in error_detail:
                 raise ExecutionError(f"找不到路線「{route_name}」，請確認路線名稱與城市")
             raise ExecutionError(f"查詢路線「{route_name}」失敗: {error_detail}")
         
         if not arrival_data:
-            print(f"⚠️ [TDX] 無資料，拋出錯誤")
+            logger.debug(f"⚠️ [TDX] 無資料，拋出錯誤")
             raise ExecutionError(f"路線「{route_name}」目前無班次資訊")
         
         # 2. 查詢公車即時位置（目前在哪站）
@@ -280,8 +280,8 @@ class TDXBusArrivalTool(MCPTool):
                             if stop_uid and pos.get("PositionLat") and pos.get("PositionLon"):
                                 stop_positions[stop_uid] = (pos["PositionLat"], pos["PositionLon"])
 
-                print(f"📍 [TDX] 從 StopOfRoute 取得 {len(stop_positions)} 個站點座標")
-                print(f"🎯 [TDX] 終點站資訊: {destination_stations}")
+                logger.debug(f"📍 [TDX] 從 StopOfRoute 取得 {len(stop_positions)} 個站點座標")
+                logger.debug(f"🎯 [TDX] 終點站資訊: {destination_stations}")
                 
                 # 為每筆到站資料計算「用戶位置」到「站牌」的距離
                 for arr in arrival_data:
@@ -299,12 +299,12 @@ class TDXBusArrivalTool(MCPTool):
                 if arrival_data_with_dist:
                     arrival_data = sorted(arrival_data_with_dist, key=lambda x: x["distance_m"])
                     nearest = arrival_data[0]
-                    print(f"📍 [TDX] 按距離排序完成，最近站: {nearest.get('StopName', {}).get('Zh_tw')} ({int(nearest['distance_m'])}m)")
+                    logger.debug(f"📍 [TDX] 按距離排序完成，最近站: {nearest.get('StopName', {}).get('Zh_tw')} ({int(nearest['distance_m'])}m)")
                 else:
-                    print(f"⚠️ [TDX] 無法計算距離，stop_positions={len(stop_positions)}, arrival_data={len(arrival_data)}")
+                    logger.debug(f"⚠️ [TDX] 無法計算距離，stop_positions={len(stop_positions)}, arrival_data={len(arrival_data)}")
                     
             except Exception as e:
-                print(f"⚠️ [TDX] 查詢站點座標失敗: {e}")
+                logger.debug(f"⚠️ [TDX] 查詢站點座標失敗: {e}")
                 import traceback
                 traceback.print_exc()
         
@@ -337,7 +337,7 @@ class TDXBusArrivalTool(MCPTool):
                 # 如果公車已離站且站序 > 用戶站序，表示已過站
                 if bus_info["event"] == "已離站" and bus_sequence > user_stop_sequence:
                     bus_passed = True
-                    print(f"🚫 [TDX] 公車已過站: 公車在第 {bus_sequence} 站 > 用戶在第 {user_stop_sequence} 站")
+                    logger.debug(f"🚫 [TDX] 公車已過站: 公車在第 {bus_sequence} 站 > 用戶在第 {user_stop_sequence} 站")
 
             status_text = cls._get_status_text(stop_status, estimate_time, next_bus_time)
 
@@ -365,12 +365,12 @@ class TDXBusArrivalTool(MCPTool):
             if len(arrivals) >= limit:
                 break
         
-        print(f"📊 [TDX] 最終結果: {len(arrivals)} 筆到站資訊")
+        logger.debug(f"📊 [TDX] 最終結果: {len(arrivals)} 筆到站資訊")
         for arr in arrivals:
-            print(f"   - {arr['stop_name']} ({arr['status']})")
+            logger.debug(f"   - {arr['stop_name']} ({arr['status']})")
         
         content = cls._format_arrival_result(arrivals, full_route_name, user_lat is not None)
-        print(f"📝 [TDX] 格式化內容:\n{content}")
+        logger.debug(f"📝 [TDX] 格式化內容:\n{content}")
         
         return cls.create_success_response(
             content=content,

middleware/exception_handler.py

@@ -81,10 +81,16 @@ class RequestLoggingMiddleware(BaseHTTPMiddleware):
             response = await call_next(request)
             process_time = (time.time() - start_time) * 1000
 
+            # 只記錄錯誤或慢請求（超過 1000ms）
             if should_log:
-                logger.info(
-                    f"{method} {path} - {response.status_code} - {process_time:.2f}ms"
-                )
+                if response.status_code >= 400:
+                    logger.warning(
+                        f"{method} {path} - {response.status_code} - {process_time:.2f}ms"
+                    )
+                elif process_time > 1000:
+                    logger.warning(
+                        f"{method} {path} - SLOW - {response.status_code} - {process_time:.2f}ms"
+                    )
 
             # 添加處理時間到回應標頭
             response.headers["X-Process-Time"] = f"{process_time:.2f}ms"

models/emotion_recognition/emotion.py

@@ -61,17 +61,19 @@ class HubertForSpeechClassification(HubertPreTrainedModel):
 
 def _load_model():
     """延遲載入模型，避免在模組匯入時就下載"""
+    import logging
+    logger = logging.getLogger("emotion_recognition")
     global _model, _processor, _config
     if _model is None:
-        print("正在延遲載入情緒辨識模型...")
+        logger.debug("正在延遲載入情緒辨識模型...")
         try:
             _config = AutoConfig.from_pretrained(model_name_or_path)
             _processor = Wav2Vec2FeatureExtractor.from_pretrained(model_name_or_path)
             _model = HubertForSpeechClassification.from_pretrained(model_name_or_path, config=_config)
             _model.eval()
-            print("情緒辨識模型載入完成！")
+            logger.debug("情緒辨識模型載入完成！")
         except Exception as e:
-            print(f"情緒辨識模型載入失敗: {e}")
+            logger.error(f"情緒辨識模型載入失敗: {e}")
             _model = None
             _processor = None
             _config = None

services/ai_service.py

@@ -17,12 +17,12 @@ from core.ai_client import get_openai_client
 # 超時設定（秒）
 OPENAI_TIMEOUT = settings.OPENAI_TIMEOUT
 
-# 情緒關懷模式 System Prompt
-CARE_MODE_SYSTEM_PROMPT = """你是 BloomWare 的情緒關懷助手「小花」，由銘傳大學人工智慧應用學系槓上開發團隊打造。你不是 GPT，也不要自稱 GPT；你的任務是在情緒低落時傾聽、陪伴。
+# 【2025 優化版】情緒關懷模式 System Prompt - 根據情緒類型動態調整
+CARE_MODE_BASE_PROMPT = """你是 BloomWare 的情緒關懷助手「小花」，由銘傳大學人工智慧應用學系槓上開發團隊打造。你不是 GPT，也不要自稱 GPT；你的任務是在情緒低落時傾聽、陪伴。
 
 【回應原則】
 1. 第一句必須貼近用戶訊息中的核心事件或感受，必要時引用對方用詞，讓對方感受到被理解
-2. 第二句提供溫柔的陪伴或追問，邀請對方分享需要或下一步；若用戶提出明確請求（如想聽笑話），可在保持關懷語氣下予以回應或確認
+2. 第二句提供溫柔的陪伴或追問，邀請對方分享需要或下一步
 3. 句式要自然口語並隨內容調整字詞，避免反覆使用同一套罐頭話術
 
 【長度限制】
@@ -30,10 +30,69 @@ CARE_MODE_SYSTEM_PROMPT = """你是 BloomWare 的情緒關懷助手「小花」
 
 【嚴格禁止】
 - 提供指示性建議、醫療/心理診斷或引導用戶求助的教科書式說法
-- 連續重複完全相同的句型，例如一再出現「我在這裡陪你」而沒有結合具體情境
+- 連續重複完全相同的句型
 
 【重要】請用與用戶相同的語言回應，匹配他們的語言風格和情感語調。"""
 
+# 根據情緒類型的專屬指引
+EMOTION_SPECIFIC_PROMPTS = {
+    "sad": """
+【悲傷情緒專屬指引】
+- 語氣：溫柔、輕聲、帶有理解
+- 重點：陪伴而非解決問題，讓對方知道悲傷是正常的
+- 避免：說「不要難過」、「振作點」這類否定情緒的話
+
+【範例】
+用戶：「我好難過」→「聽見你說好難過，心裡一定很不好受。想聊聊發生了什麼嗎？」
+用戶：「我失去了他」→「失去一個重要的人，那種痛真的很深。我在這裡陪你。」
+用戶：「I feel so sad」→「It sounds like you're really hurting right now. I'm here if you want to talk.」""",
+
+    "angry": """
+【憤怒情緒專屬指引】
+- 語氣：冷靜但帶有同理、不卑不亢
+- 重點：認可對方的憤怒是有原因的，幫助對方感覺被理解
+- 避免：說「冷靜一下」、「別生氣」這類否定情緒的話
+
+【範例】
+用戶：「我很生氣」→「這件事讓你超級生氣，情緒一定卡著。要不要說說最困擾的地方？」
+用戶：「氣死我了」→「聽起來真的讓你很火大。是什麼事這麼讓人受不了？」
+用戶：「I'm so angry」→「Sounds like something really got to you. What's going on?」""",
+
+    "fear": """
+【恐懼/焦慮情緒專屬指引】
+- 語氣：穩定、溫暖、帶有安全感
+- 重點：讓對方感覺不孤單，恐懼是可以被接納的
+- 避免：說「沒什麼好怕的」、「想太多了」這類否定情緒的話
+
+【範例】
+用戶：「我好害怕」→「害怕的感覺一定很不好受。你現在安全的，我陪著你。」
+用戶：「我很焦慮」→「焦慮的時候心裡好亂對吧。可以跟我說說是什麼讓你不安嗎？」
+用戶：「I'm scared」→「It's okay to feel scared. You're not alone - I'm right here with you.」"""
+}
+
+# 向後兼容：保留原有變數名稱
+CARE_MODE_SYSTEM_PROMPT = CARE_MODE_BASE_PROMPT
+
+
+def get_care_mode_prompt(emotion: str = None) -> str:
+    """
+    根據情緒類型生成專屬的關懷模式 Prompt
+
+    Args:
+        emotion: 情緒標籤 (sad, angry, fear, 或 None)
+
+    Returns:
+        完整的關懷模式 System Prompt
+    """
+    base = CARE_MODE_BASE_PROMPT
+
+    # 根據情緒類型添加專屬指引
+    if emotion and emotion.lower() in EMOTION_SPECIFIC_PROMPTS:
+        specific = EMOTION_SPECIFIC_PROMPTS[emotion.lower()]
+        return f"{base}\n{specific}"
+
+    return base
+
 # 取得 OpenAI 客戶端（使用統一管理）
 def _get_client():
     """取得 OpenAI 客戶端"""
@@ -71,7 +130,8 @@ def _build_base_system_prompt(
     language: Optional[str] = None,  # 保留參數以兼容現有調用，但不使用
 ) -> str:
     if use_care_mode:
-        base_prompt = CARE_MODE_SYSTEM_PROMPT.strip()
+        # 【優化】使用情緒專屬的關懷 Prompt
+        base_prompt = get_care_mode_prompt(care_emotion).strip()
         if care_emotion:
             base_prompt = f"用戶情緒：{care_emotion}\n{base_prompt}"
     else:

services/batch_processor.py

@@ -354,6 +354,6 @@ async def get_batch_results(batch_id: str) -> Dict[str, Any]:
         results = await get_batch_results(batch_id)
         if results["success"]:
             for item in results["results"]:
-                print(item)
+                logger.debug(item)
     """
     return await batch_processor.wait_for_completion(batch_id)

services/tts_service.py

@@ -367,9 +367,9 @@ async def test_tts_playback(
     """
     result = await tts_service.play_locally(text, voice=voice, instruction=instruction)
     if result["success"]:
-        print(f"✅ 播放成功：{text}")
+        logger.debug(f"✅ 播放成功：{text}")
     else:
-        print(f"❌ 播放失敗：{result.get('error')}")
+        logger.debug(f"❌ 播放失敗：{result.get('error')}")
 
 
 if __name__ == "__main__":

static/frontend/index.html

@@ -1595,7 +1595,6 @@
   </style>
 </head>
 <body>
-  <!-- 控制面板 -->
   <div class="control-panel">
     <h3>🎛️ 控制面板</h3>
 
@@ -1656,34 +1655,23 @@
     </div>
   </div>
 
-  <!-- 沉浸式覆蓋層 -->
   <div class="voice-immersive-overlay">
-    <!-- 動態漸變背景 -->
     <div class="voice-immersive-background emotion-neutral active" id="background"></div>
 
-    <!-- 情緒指示器 -->
     <div class="emotion-indicator" id="emotion-indicator">當前情緒: 😐 中性</div>
 
-    <!-- 登出按鈕 -->
     <button class="exit-button" id="logoutBtn">登出</button>
 
-    <!-- ChatWindow 切換圖標 -->
     <div class="chat-icon" id="chatIcon" title="切換對話視窗">💬</div>
 
-    <!-- 中央容器 -->
     <div class="voice-center-container">
-      <!-- 波形與麥克風容器 -->
       <div class="voice-waveform-container">
         <canvas id="waveform-canvas" width="400" height="400"></canvas>
 
-        <!-- 多層蓮花設計（Bloom Ware 品牌特色）-->
         <div class="voice-mic-container" id="mic-container">
-          <!-- 花蕊中心（多層次金黃色）-->
           <div class="bloom-core"></div>
 
-          <!-- 16片蓮花花瓣（雙層結構：外層8片 + 內層8片）-->
           <div class="bloom-petals">
-            <!-- 外層 8 片大花瓣 -->
             <div class="bloom-petal"></div>
             <div class="bloom-petal"></div>
             <div class="bloom-petal"></div>
@@ -1692,7 +1680,6 @@
             <div class="bloom-petal"></div>
             <div class="bloom-petal"></div>
             <div class="bloom-petal"></div>
-            <!-- 內層 8 片小花瓣 -->
             <div class="bloom-petal"></div>
             <div class="bloom-petal"></div>
             <div class="bloom-petal"></div>
@@ -1705,37 +1692,29 @@
         </div>
       </div>
 
-      <!-- Agent 文字輸出（打字機效果，位於花朵下方）-->
       <div class="voice-agent-output" id="agent-output"></div>
 
-      <!-- 實時字幕 -->
       <div class="voice-transcript provisional" id="transcript">
         請說話...
       </div>
     </div>
 
-    <!-- 工具卡片容器（保留用於桌面端） -->
     <div id="tool-cards-container"></div>
   </div>
 
-  <!-- 工具抽屜遮罩層 -->
   <div class="tool-drawer-overlay" id="toolDrawerOverlay"></div>
 
-  <!-- 工具抽屜切換按鈕（右側透明箭頭） -->
   <div class="tool-drawer-toggle" id="toolDrawerToggle"></div>
 
-  <!-- 工具抽屜面板 -->
   <div class="tool-drawer" id="toolDrawer">
     <div class="tool-drawer-header">
       <h3>📊 工具結果</h3>
       <button class="tool-drawer-close" id="toolDrawerClose">✕</button>
     </div>
     <div class="tool-drawer-content" id="toolDrawerContent">
-      <!-- 工具卡片將渲染到這裡 -->
     </div>
   </div>
 
-  <!-- JavaScript 模組化引入 -->
   <script src="js/config.js"></script>
   <script src="js/ui.js"></script>
   <script src="js/tts.js"></script>
@@ -1746,7 +1725,6 @@
   <script src="js/websocket.js"></script>
   <script src="js/app.js"></script>
 
-  <!-- 響應式螢幕檢測 -->
   <script>
     (function() {
       function detectScreenOrientation() {
@@ -1759,16 +1737,16 @@
         
         if (isLargePortrait) {
           document.body.classList.add('portrait-mode');
-          console.log('📱 螢幕模式: 直立螢幕（90度橫屏）', width, 'x', height);
+          // console.log('📱 螢幕模式: 直立螢幕（90度橫屏）', width, 'x', height);
         } else if (width <= 480) {
           document.body.classList.add('mobile-mode');
-          console.log('📱 螢幕模式: 手機', width, 'x', height);
+          // console.log('📱 螢幕模式: 手機', width, 'x', height);
         } else if (width <= 1024) {
           document.body.classList.add('tablet-mode');
-          console.log('📱 螢幕模式: 平板', width, 'x', height);
+          // console.log('📱 螢幕模式: 平板', width, 'x', height);
         } else {
           document.body.classList.add('desktop-mode');
-          console.log('🖥️ 螢幕模式: 桌機/筆電', width, 'x', height);
+          // console.log('🖥️ 螢幕模式: 桌機/筆電', width, 'x', height);
         }
       }
       

static/frontend/js/agent.js

@@ -1,30 +1,17 @@
-// ========== Agent 狀態管理（單一狀態機）==========
-// 狀態定義：idle | recording | thinking | speaking | disconnected
 let currentState = 'idle';
 
-/**
- * 狀態轉換函數
- * @param {string} newState - 新狀態 (idle | recording | thinking | speaking | disconnected)
- * @param {object} options - 選項 {clearCards, showOutput, outputText, enableTTS}
- */
 function setState(newState, options = {}) {
-  // 防止重複設置相同狀態
   if (currentState === newState) {
-    console.log(`⚠️ 狀態已經是 ${newState}，忽略`);
     return;
   }
 
   const oldState = currentState;
   currentState = newState;
-  console.log(`🔄 狀態轉換: ${oldState} → ${newState}`);
 
-  // 移除所有狀態 class
   micContainer.classList.remove('recording', 'thinking', 'speaking', 'disconnected');
 
-  // 套用新狀態
   switch(newState) {
     case 'idle':
-      // 閒置狀態：清除所有動畫
       hideAgentOutput();
       if (typeof stopSpeaking === 'function') {
         stopSpeaking();
@@ -35,23 +22,18 @@ function setState(newState, options = {}) {
       break;
 
     case 'recording':
-      // 錄音狀態：紅色脈動核心
       micContainer.classList.add('recording');
-      // 不清除 Agent 輸出,保留前次回應
       if (!options.keepOutput) {
         hideAgentOutput();
       }
-      // 不清除工具卡片,保留前次結果
       if (!options.keepCards) {
         clearAllCards();
       }
-      // 清除舊的 transcript,顯示錄音提示
       transcript.textContent = '聆聽中...';
       transcript.className = 'voice-transcript provisional';
       break;
 
     case 'thinking':
-      // 思考中狀態：花瓣順時針綻放
       micContainer.classList.add('thinking');
       hideAgentOutput();
       if (typeof stopSpeaking === 'function') {
@@ -60,16 +42,13 @@ function setState(newState, options = {}) {
       break;
 
     case 'speaking':
-      // 回覆中狀態：完全綻放 + 打字機效果
       micContainer.classList.add('speaking');
       if (options.outputText) {
-        // typewriterEffect 內部會自動調用 speakText（如果 enableTTS 為 true）
         typewriterEffect(options.outputText, 40, options.enableTTS);
       }
       break;
 
     case 'disconnected':
-      // 斷線狀態：花瓣逆時針變紅
       micContainer.classList.add('disconnected');
       hideAgentOutput();
       if (typeof stopSpeaking === 'function') {
@@ -83,9 +62,6 @@ function setState(newState, options = {}) {
   }
 }
 
-/**
- * 應用情緒主題
- */
 function applyEmotion(emotion) {
   const validEmotions = ['neutral', 'happy', 'sad', 'angry', 'fear', 'surprise'];
   if (!validEmotions.includes(emotion)) {
@@ -96,14 +72,9 @@ function applyEmotion(emotion) {
   emotionIndicator.textContent = `當前情緒: ${emotionEmojis[emotion]}`;
 }
 
-/**
- * 顯示錯誤通知
- */
 function showErrorNotification(message) {
-  // 簡單的錯誤提示（可以改為更友善的 UI）
   console.error('🚨 錯誤:', message);
 
-  // 使用打字機效果顯示錯誤
   setState('speaking', {
     outputText: `抱歉，發生錯誤：${message}`,
     enableTTS: false
@@ -112,42 +83,31 @@ function showErrorNotification(message) {
   setTimeout(() => setState('idle'), 3000);
 }
 
-// ========== 測試按鈕事件監聽器 ==========
 
-// 舊變數保留（向後兼容）
 let isThinking = false;
 let isDisconnected = false;
 let isRecording = false;
 let isSpeaking = false;
 
 function initAgentControls() {
-  // === 真實的麥克風點擊事件（非測試按鈕）=== 
   micContainer.addEventListener('click', async () => {
-    console.log('🎤 用戶點擊麥克風，當前狀態:', currentState);
     
-    // 如果正在錄音，停止錄音
     if (currentState === 'recording') {
-      console.log('⏹️ 停止錄音');
       isRecording = false;
       
-      // 停止視覺化
       if (typeof stopRealAudioAnalysis === 'function') {
         stopRealAudioAnalysis();
       }
       
-      // 停止 WebSocket 錄音
       if (wsManager && typeof wsManager.stopRecording === 'function') {
         wsManager.stopRecording();
       }
       
-      // 轉換為思考狀態（等待 STT 和 Agent 回應）
       setState('thinking');
       return;
     }
     
-    // 開始錄音狀態（不清除之前的回應，保留顯示）
     if (currentState === 'idle' || currentState === 'disconnected' || currentState === 'speaking') {
-      // 如果在 speaking 狀態，先停止 TTS 播放
       if (currentState === 'speaking' && typeof stopSpeaking === 'function') {
         stopSpeaking();
       }
@@ -157,14 +117,11 @@ function initAgentControls() {
         keepOutput: true,  // 保留前次 Agent 回應
         keepCards: true    // 保留前次工具卡片
       });
-      console.log('🎙️ 開始錄音（保留前次回應顯示）');
       
-      // 啟動視覺化
       if (typeof startRealAudioAnalysis === 'function') {
         await startRealAudioAnalysis();
       }
       
-      // 啟動 WebSocket 錄音（實際傳輸音訊數據）
       if (wsManager && typeof wsManager.startRecording === 'function') {
         const success = await wsManager.startRecording();
         if (!success) {
@@ -186,21 +143,17 @@ function initAgentControls() {
     }
   });
 
-  // 錄音狀態（改用狀態機 + 真實音訊分析）
   document.getElementById('toggle-recording').addEventListener('click', async () => {
     isRecording = !isRecording;
     if (isRecording) {
       setState('recording');
-      // 啟動真實音訊分析
       await startRealAudioAnalysis();
     } else {
       setState('idle');
-      // 停止真實音訊分析
       stopRealAudioAnalysis();
     }
   });
 
-  // 思考中狀態（改用狀態機）
   document.getElementById('toggle-thinking').addEventListener('click', () => {
     isThinking = !isThinking;
     if (isThinking) {
@@ -210,15 +163,12 @@ function initAgentControls() {
     }
   });
 
-  // 回覆中狀態（改用狀態機）
   document.getElementById('toggle-speaking').addEventListener('click', () => {
     isSpeaking = !isSpeaking;
     if (isSpeaking) {
-      // 回覆開始：顯示工具卡片
       clearAllCards();
       setTimeout(() => addToolCard('weather'), 300);
 
-      // 模擬 Agent 回覆文字
       const responseText = '根據目前的天氣資料，台北今天氣溫約 23°C，天氣晴朗，濕度 65%。建議您外出時可以穿著輕便舒適的衣物，並記得攜帶太陽眼鏡。';
       setState('speaking', {outputText: responseText});
     } else {
@@ -226,7 +176,6 @@ function initAgentControls() {
     }
   });
 
-  // 斷線狀態（改用狀態機）
   document.getElementById('toggle-disconnected').addEventListener('click', () => {
     isDisconnected = !isDisconnected;
     if (isDisconnected) {

static/frontend/js/app.js

@@ -1,13 +1,7 @@
-// ========== 登入狀態檢查 ==========
 
-/**
- * Google OAuth 登入（使用後端生成 PKCE）
- */
 async function handleGoogleLogin() {
   try {
-    console.log('🚀 開始 Google OAuth 登入流程...');
 
-    // 從後端獲取授權 URL 和 PKCE 參數
     const response = await fetch('/auth/google/url');
     const data = await response.json();
 
@@ -15,19 +9,11 @@ async function handleGoogleLogin() {
       throw new Error(data.error || '獲取授權 URL 失敗');
     }
 
-    console.log('✅ 獲取授權 URL 成功');
 
-    // 存儲 PKCE 參數到 sessionStorage
     sessionStorage.setItem('oauth_state', data.state);
     sessionStorage.setItem('oauth_code_verifier', data.code_verifier);
 
-    console.log('🔐 PKCE 參數已存儲:', {
-      state: data.state.substring(0, 8) + '...',
-      codeVerifier: data.code_verifier.substring(0, 8) + '...'
-    });
 
-    // 重定向到 Google 授權頁面
-    console.log('🌐 重定向到 Google 授權頁面...');
     window.location.href = data.auth_url;
 
   } catch (error) {
@@ -36,19 +22,13 @@ async function handleGoogleLogin() {
   }
 }
 
-/**
- * 檢查登入狀態，未登入則導向 login.html
- */
 async function checkLoginStatus() {
   const token = localStorage.getItem('jwt_token');
   if (!token) {
-    // 未登入，導向登入頁面
-    console.log('⚠️ 未登入，導向登入頁面...');
     window.location.href = '/login/';
     return false;
   }
 
-  // 驗證 token 是否有效（解碼 JWT 檢查過期時間）
   try {
     const payload = JSON.parse(atob(token.split('.')[1]));
     const currentTime = Math.floor(Date.now() / 1000);
@@ -60,7 +40,6 @@ async function checkLoginStatus() {
       return false;
     }
     
-    console.log('✅ Token 有效，初始化應用...');
   } catch (error) {
     console.error('❌ Token 解析失敗:', error);
     localStorage.removeItem('jwt_token');
@@ -68,18 +47,12 @@ async function checkLoginStatus() {
     return false;
   }
 
-  console.log('✅ 已登入，初始化應用...');
   initializeApp(token);
   return true;
 }
 
-/**
- * 初始化應用（登入後）
- */
 async function initializeApp(token) {
-  console.log('🚀 初始化應用...');
 
-  // 初始化各個模組的事件監聽器
   initLoginButton();
   initLogoutButton();
   initChatIcon();
@@ -89,33 +62,21 @@ async function initializeApp(token) {
   initAgentControls();
   initToolDrawer(); // 初始化工具抽屜
 
-  // 同步 MCP 工具 metadata
   syncToolMetadata();
 
-  // 請求必要權限（麥克風 + 地理位置）
   await requestRequiredPermissions();
 
-  // 初始化 WebSocket
   initializeWebSocket(token);
 
-  console.log('✅ 應用初始化完成');
 }
 
-/**
- * 請求必要權限（麥克風 + 地理位置）
- */
 async function requestRequiredPermissions() {
-  console.log('🔐 請求必要權限...');
   
-  // 1. 請求麥克風權限
   try {
-    console.log('🎤 請求麥克風權限...');
     const stream = await navigator.mediaDevices.getUserMedia({ 
       audio: { channelCount: 1, sampleRate: 48000 } 
     });
-    // 立即停止串流（只是為了觸發權限請求）
     stream.getTracks().forEach(track => track.stop());
-    console.log('✅ 麥克風權限已授予');
   } catch (error) {
     console.warn('⚠️ 麥克風權限被拒絕:', error);
     if (typeof showErrorNotification === 'function') {
@@ -125,14 +86,11 @@ async function requestRequiredPermissions() {
     }
   }
 
-  // 2. 請求地理位置權限
   if (navigator.geolocation) {
     try {
-      console.log('📍 請求地理位置權限...');
       await new Promise((resolve, reject) => {
         navigator.geolocation.getCurrentPosition(
           (position) => {
-            console.log('✅ 地理位置權限已授予');
             resolve(position);
           },
           (error) => {
@@ -152,25 +110,14 @@ async function requestRequiredPermissions() {
     console.warn('⚠️ 此瀏覽器不支援地理位置功能');
   }
 
-  console.log('✅ 權限請求完成');
 }
 
-// ========== 頁面初始化 ==========
 
-// 只在聊天室頁面（/static/）執行登入檢查
-console.log('📍 當前路徑:', window.location.pathname);
 if (window.location.pathname.startsWith('/static')) {
-  console.log('✅ 在聊天室頁面，執行登入檢查');
   checkLoginStatus();
 } else {
-  console.log('⏭️ 不在聊天室頁面，跳過登入檢查');
 }
 
-console.log('💡 WebSocket 整合已載入');
-console.log('📝 部署時請執行: initializeWebSocket(your_jwt_token)');
 
-// ========== 提示訊息 ==========
-console.log('%c Bloom Ware 語音沉浸式 - 多層蓮花版', 'color: #16A34A; font-size: 16px; font-weight: bold;');
-console.log('%c✨ 核心特色:\n- 8片蓮花瓣設計（clip-path 打造自然曲線）\n- 多層次花蕊（radial gradient + 光澤細節）\n- 花瓣中心脈絡增加真實感\n- 待機狀態：花瓣完全閉合（含苞待放）\n- Agent 思考中：8片花瓣順時針依序綻放\n- 斷線/重連：花瓣逆時針綻放變���色警示\n- 錄音中：花蕊變紅脈衝，花瓣保持閉合\n- 品牌特色：優雅、精緻、現代', 'color: rgba(0,0,0,0.7); font-size: 12px;');
 
 

static/frontend/js/canvas.js

@@ -1,4 +1,3 @@
-// ========== Canvas 波形渲染（效能優化版 + 真實音訊整合）==========
 
 const canvas = document.getElementById('waveform-canvas');
 const ctx = canvas.getContext('2d');
@@ -7,7 +6,6 @@ const centerY = canvas.height / 2;
 const baseRadius = 140;
 const maxAmplitude = 50;
 
-// 預計算角度 cos/sin 值以提升效能
 const points = 120; // 從 180 降到 120（降低 33% 計算量）
 const angleCache = [];
 const cosCache = [];
@@ -20,7 +18,6 @@ for (let i = 0; i <= points; i++) {
   sinCache[i] = Math.sin(angle);
 }
 
-// Web Audio API 整合
 let canvasAudioContext = null;
 let analyser = null;
 let dataArray = null;
@@ -28,12 +25,8 @@ let bufferLength = 0;
 let audioStream = null;
 let useRealAudio = false; // 是否使用真實音訊數據
 
-/**
- * 啟動真實音訊分析
- */
 async function startRealAudioAnalysis() {
   try {
-    // 請求麥克風權限
     audioStream = await navigator.mediaDevices.getUserMedia({
       audio: {
         channelCount: 1,
@@ -43,7 +36,6 @@ async function startRealAudioAnalysis() {
       }
     });
 
-    // 創建音訊上下文
     canvasAudioContext = new (window.AudioContext || window.webkitAudioContext)();
     analyser = canvasAudioContext.createAnalyser();
     analyser.fftSize = 256; // FFT 大小（必須是 2 的冪次）
@@ -52,27 +44,21 @@ async function startRealAudioAnalysis() {
     const source = canvasAudioContext.createMediaStreamSource(audioStream);
     source.connect(analyser);
 
-    // 準備數據陣列
     bufferLength = analyser.frequencyBinCount; // fftSize / 2 = 128
     dataArray = new Uint8Array(bufferLength);
 
     useRealAudio = true;
-    console.log('✅ 真實音訊分析已啟動');
 
   } catch (error) {
     console.warn('⚠️ 無法啟動真實音訊分析（降級為假動畫）:', error);
     useRealAudio = false;
 
-    // 顯示權限提示
     if (error.name === 'NotAllowedError') {
       showErrorNotification('需要麥克風權限才能使用語音功能');
     }
   }
 }
 
-/**
- * 停止真實音訊分析
- */
 function stopRealAudioAnalysis() {
   if (audioStream) {
     audioStream.getTracks().forEach(track => track.stop());
@@ -88,7 +74,6 @@ function stopRealAudioAnalysis() {
   dataArray = null;
   useRealAudio = false;
 
-  console.log('🛑 真實音訊分析已停止');
 }
 
 function draw360Waveform() {
@@ -96,12 +81,10 @@ function draw360Waveform() {
 
   const time = Date.now() * 0.001;
 
-  // 如果有真實音訊數據，使用它
   if (useRealAudio && analyser && dataArray) {
     analyser.getByteFrequencyData(dataArray); // 獲取頻率數據（0-255）
   }
 
-  // 繪製多層波形（淺色主題）
   for (let layer = 0; layer < 3; layer++) {
     ctx.beginPath();
     ctx.strokeStyle = `rgba(0, 0, 0, ${0.08 - layer * 0.02})`;
@@ -116,11 +99,9 @@ function draw360Waveform() {
       let amplitude;
 
       if (useRealAudio && dataArray && bufferLength > 0) {
-        // 真實音訊模式：將 120 個波形點對應到 bufferLength 個頻率數據
         const dataIndex = Math.floor((i / points) * bufferLength);
         const audioValue = dataArray[dataIndex] / 255.0; // 標準化到 0-1
 
-        // 結合音訊數據和時間動畫
         const wave1 = audioValue * 0.6; // 主要由音訊驅動
         const wave2 = Math.sin(angle * 4 - time * 1.2) * 0.1; // 保留少量動畫
         const wave3 = sinCache[i * 6 % points] * 0.05 * Math.cos(time * 2);
@@ -128,7 +109,6 @@ function draw360Waveform() {
         amplitude = (wave1 + wave2 + wave3) * layerMultiplier;
 
       } else {
-        // 假動畫模式（原邏輯）
         const wave1 = Math.sin(angle * 2 + time * 1.5 + layerOffset) * 0.3;
         const wave2 = Math.sin(angle * 4 - time * 1.2) * 0.2;
         const wave3 = sinCache[i * 6 % points] * 0.15 * Math.cos(time * 2);
@@ -153,5 +133,4 @@ function draw360Waveform() {
   requestAnimationFrame(draw360Waveform);
 }
 
-// 啟動波形渲染
 draw360Waveform();

static/frontend/js/config.js

@@ -1,6 +1,4 @@
-// ========== 全域變數與常數 ==========
 
-// DOM 元素參照
 const background = document.getElementById('background');
 const emotionIndicator = document.getElementById('emotion-indicator');
 const transcript = document.getElementById('transcript');
@@ -8,7 +6,6 @@ const micContainer = document.getElementById('mic-container');
 const cardsContainer = document.getElementById('tool-cards-container');
 const agentOutput = document.getElementById('agent-output');
 
-// 情緒表情對照表
 const emotionEmojis = {
   neutral: '😐 中性',
   happy: '😊 開心',
@@ -18,7 +15,6 @@ const emotionEmojis = {
   surprise: '😲 驚訝'
 };
 
-// 背景顏色對照表
 const emotionColors = {
   neutral: 'linear-gradient(135deg, #E6F7F0 0%, #F5F1ED 100%)',
   happy: 'linear-gradient(135deg, #FFF9E6 0%, #FFE6E6 100%)',
@@ -28,11 +24,8 @@ const emotionColors = {
   surprise: 'linear-gradient(135deg, #FFFFE6 0%, #FFF5E6 100%)'
 };
 
-// 打字機效果變數
 let typingInterval = null;
 
-// WebSocket 連接
 let ws = null;
 
-// MCP 工具 metadata 快取
 let toolsMetadata = [];

static/frontend/js/location.js

@@ -1,23 +1,16 @@
-// ========== 位置追蹤與環境感知 ==========
 
-/**
- * 位置追蹤管理器
- * 負責：
- * 1. 請求瀏覽器定位權限
- * 2. 定期追蹤用戶位置
- * 3. 發送 env_snapshot 到後端
- */
 
 let watchId = null;
 let lastPosition = null;
+let lastSentPosition = null;  // 上次發送的位置
+let lastSendTime = 0;         // 上次發送時間
 let isTracking = false;
 
-/**
- * 啟動位置追蹤
- */
+const MIN_SEND_INTERVAL = 60000;  // 最小發送間隔：60 秒
+const MIN_DISTANCE_CHANGE = 100;  // 最小距離變化：100 米
+
 async function startLocationTracking() {
   if (isTracking) {
-    console.log('📍 位置追蹤已經在運行');
     return;
   }
 
@@ -26,10 +19,8 @@ async function startLocationTracking() {
     return;
   }
 
-  console.log('📍 請求位置權限...');
 
   try {
-    // 首次獲取位置（觸發權限請求）
     const position = await new Promise((resolve, reject) => {
       navigator.geolocation.getCurrentPosition(resolve, reject, {
         enableHighAccuracy: false, // 不需要高精度（省電）
@@ -38,10 +29,8 @@ async function startLocationTracking() {
       });
     });
 
-    console.log('✅ 位置權限已授予');
     handlePositionUpdate(position);
 
-    // 開始持續追蹤（每 30 秒更新一次）
     watchId = navigator.geolocation.watchPosition(
       handlePositionUpdate,
       handlePositionError,
@@ -53,38 +42,51 @@ async function startLocationTracking() {
     );
 
     isTracking = true;
-    console.log('📍 位置追蹤已啟動（每 30 秒更新）');
 
   } catch (error) {
     handlePositionError(error);
   }
 }
 
-/**
- * 停止位置追蹤
- */
 function stopLocationTracking() {
   if (watchId !== null) {
     navigator.geolocation.clearWatch(watchId);
     watchId = null;
     isTracking = false;
-    console.log('🛑 位置追蹤已停止');
   }
 }
 
-/**
- * 處理位置更新
- */
+function calculateDistance(lat1, lon1, lat2, lon2) {
+  const R = 6371000; // 地球半徑（米）
+  const dLat = (lat2 - lat1) * Math.PI / 180;
+  const dLon = (lon2 - lon1) * Math.PI / 180;
+  const a = Math.sin(dLat/2) * Math.sin(dLat/2) +
+            Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) *
+            Math.sin(dLon/2) * Math.sin(dLon/2);
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
+  return R * c;
+}
+
+function shouldSendUpdate(newPosition) {
+  const now = Date.now();
+
+  if (!lastSentPosition) return true;
+
+  const timeSinceLast = now - lastSendTime;
+  if (timeSinceLast < MIN_SEND_INTERVAL) return false;
+
+  const distance = calculateDistance(
+    lastSentPosition.lat, lastSentPosition.lon,
+    newPosition.lat, newPosition.lon
+  );
+
+  return distance >= MIN_DISTANCE_CHANGE;
+}
+
 function handlePositionUpdate(position) {
   const { latitude, longitude, accuracy, heading, speed } = position.coords;
   const timestamp = position.timestamp;
 
-  console.log('📍 位置更新:', {
-    lat: latitude.toFixed(6),
-    lon: longitude.toFixed(6),
-    accuracy: Math.round(accuracy) + 'm'
-  });
-
   lastPosition = {
     lat: latitude,
     lon: longitude,
@@ -94,13 +96,13 @@ function handlePositionUpdate(position) {
     timestamp: timestamp
   };
 
-  // 發送環境快照到後端
-  sendEnvironmentSnapshot(lastPosition);
+  if (shouldSendUpdate(lastPosition)) {
+    sendEnvironmentSnapshot(lastPosition);
+    lastSentPosition = { ...lastPosition };
+    lastSendTime = Date.now();
+  }
 }
 
-/**
- * 處理定位錯誤
- */
 function handlePositionError(error) {
   let errorMessage = '';
 
@@ -122,7 +124,6 @@ function handlePositionError(error) {
       console.warn('⚠️ 定位發生未知錯誤:', error);
   }
 
-  // 即使定位失敗，也發送一個沒有位置的快照（包含時間等資訊）
   sendEnvironmentSnapshot({
     lat: null,
     lon: null,
@@ -131,31 +132,20 @@ function handlePositionError(error) {
   });
 }
 
-/**
- * 發送環境快照到後端
- * 欄位名稱需與後端 EnvironmentContextService 期望的一致
- */
 function sendEnvironmentSnapshot(positionData) {
   if (!wsManager || !wsManager.isConnected()) {
-    console.warn('⚠️ WebSocket 未連線，跳過環境快照發送');
-    return;
+    return; // 靜默跳過
   }
 
-  // 構建環境快照資料（欄位名稱對應後端 context_service.py）
   const snapshot = {
-    // 位置資訊（後端期望的欄位名稱）
     lat: positionData.lat,
     lon: positionData.lon,
-    accuracy_m: positionData.accuracy,      // 後端期望 accuracy_m
-    heading_deg: positionData.heading,      // 後端期望 heading_deg
+    accuracy_m: positionData.accuracy,
+    heading_deg: positionData.heading,
     speed: positionData.speed,
     timestamp: positionData.timestamp || Date.now(),
-
-    // 時區與語系（後端期望的欄位名稱）
-    tz: Intl.DateTimeFormat().resolvedOptions().timeZone,  // 後端期望 tz
-    locale: navigator.language,             // 後端期望 locale
-
-    // 裝置資訊（後端期望 device 物件）
+    tz: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    locale: navigator.language,
     device: {
       user_agent: navigator.userAgent,
       platform: navigator.platform,
@@ -164,35 +154,20 @@ function sendEnvironmentSnapshot(positionData) {
       viewport_width: window.innerWidth,
       viewport_height: window.innerHeight
     },
-
-    // 錯誤資訊（如果有）
     error: positionData.error || null
   };
 
-  // 發送 WebSocket 訊息
-  wsManager.send({
-    type: 'env_snapshot',
-    ...snapshot
-  });
-
-  console.log('📤 環境快照已發送:', {
-    lat: snapshot.lat?.toFixed(6),
-    lon: snapshot.lon?.toFixed(6),
-    accuracy_m: snapshot.accuracy_m,
-    tz: snapshot.tz
-  });
+  wsManager.send({ type: 'env_snapshot', ...snapshot });
+  if (window.DEBUG_MODE) {
+  }
 }
 
-/**
- * 手動觸發位置更新（用於用戶主動請求）
- */
 async function requestLocationUpdate() {
   if (!navigator.geolocation) {
     console.warn('⚠️ 此瀏覽器不支援定位功能');
     return null;
   }
 
-  console.log('📍 手動請求位置更新...');
 
   try {
     const position = await new Promise((resolve, reject) => {
@@ -212,9 +187,6 @@ async function requestLocationUpdate() {
   }
 }
 
-/**
- * 取得最後已知位置
- */
 function getLastKnownPosition() {
   return lastPosition;
 }

static/frontend/js/speech.js

@@ -1,7 +1,3 @@
-/**
- * 語音識別模組
- * 處理語音輸入和語音合成
- */
 
 class SpeechRecognition {
     constructor() {
@@ -13,7 +9,6 @@ class SpeechRecognition {
         this.onStart = null;
         this.onEnd = null;
         
-        // 語音辨識上下文
         this.context = {
             userLocation: null,
             recentQueries: [],
@@ -24,7 +19,6 @@ class SpeechRecognition {
     }
 
     initRecognition() {
-        // 檢查瀏覽器支援
         if ('webkitSpeechRecognition' in window) {
             this.recognition = new webkitSpeechRecognition();
             this.isSupported = true;
@@ -36,16 +30,13 @@ class SpeechRecognition {
             return;
         }
 
-        // 設定語音識別參數
         this.recognition.continuous = false;
         this.recognition.interimResults = true;
         this.recognition.lang = 'zh-TW';
         this.recognition.maxAlternatives = 3;  // 增加候選結果數量
 
-        // 綁定事件
         this.recognition.onstart = () => {
             this.isListening = true;
-            console.log('🎤 語音識別開始');
             if (this.onStart) this.onStart();
         };
 
@@ -62,9 +53,7 @@ class SpeechRecognition {
                 }
             }
 
-            console.log('🎤 語音識別原始結果:', finalTranscript || interimTranscript);
             
-            // 使用語音增強功能
             let enhancedFinal = finalTranscript;
             let enhancedInterim = interimTranscript;
             
@@ -93,7 +82,6 @@ class SpeechRecognition {
 
         this.recognition.onend = () => {
             this.isListening = false;
-            console.log('🎤 語音識別結束');
             if (this.onEnd) this.onEnd();
         };
     }
@@ -130,31 +118,19 @@ class SpeechRecognition {
         }
     }
     
-    /**
-     * 設定用戶位置上下文
-     */
     setUserLocation(location) {
         this.context.userLocation = location;
-        console.log('📍 設定用戶位置上下文:', location);
     }
     
-    /**
-     * 添加查詢歷史
-     */
     addRecentQuery(query) {
         if (query && typeof query === 'string') {
             this.context.recentQueries.unshift(query);
-            // 只保留最近 10 次查詢
             if (this.context.recentQueries.length > 10) {
                 this.context.recentQueries = this.context.recentQueries.slice(0, 10);
             }
-            console.log('📝 添加查詢歷史:', query);
         }
     }
     
-    /**
-     * 獲取當前上下文
-     */
     getContext() {
         return {
             ...this.context,
@@ -162,20 +138,15 @@ class SpeechRecognition {
         };
     }
     
-    /**
-     * 清除上下文
-     */
     clearContext() {
         this.context = {
             userLocation: null,
             recentQueries: [],
             currentSession: null
         };
-        console.log('🗑️ 已清除語音辨識上下文');
     }
 }
 
-// 語音合成類
 class TextToSpeech {
     constructor() {
         this.synth = window.speechSynthesis;
@@ -190,27 +161,22 @@ class TextToSpeech {
             return false;
         }
 
-        // 停止當前播放
         this.stop();
 
         const utterance = new SpeechSynthesisUtterance(text);
         
-        // 設定參數
         utterance.lang = options.lang || 'zh-TW';
         utterance.rate = options.rate || 1.0;
         utterance.pitch = options.pitch || 1.0;
         utterance.volume = options.volume || 1.0;
 
-        // 綁定事件
         utterance.onstart = () => {
             this.isSpeaking = true;
-            console.log('🔊 語音合成開始');
         };
 
         utterance.onend = () => {
             this.isSpeaking = false;
             this.currentUtterance = null;
-            console.log('🔊 語音合成結束');
         };
 
         utterance.onerror = (event) => {
@@ -245,6 +211,5 @@ class TextToSpeech {
     }
 }
 
-// 全域實例
 window.speechRecognition = new SpeechRecognition();
 window.textToSpeech = new TextToSpeech();

static/frontend/js/tools.js

@@ -1,10 +1,8 @@
-// ========== 工具卡片管理（改良版：支援抽屜面板）==========
 
 const positions = ['pos-top-right', 'pos-top-left', 'pos-bottom-right', 'pos-bottom-left'];
 let usedPositions = [];
 const MAX_CARDS = 4;
 
-// 多語言標籤定義
 const LABELS = {
   zh: {
     temperature: '溫度', condition: '狀況', humidity: '濕度', wind_speed: '風速',
@@ -110,10 +108,8 @@ const LABELS = {
   }
 };
 
-// 當前語言（從用戶訊息自動檢測）
 let currentLanguage = 'zh';
 
-// 抽屜相關元素
 let toolDrawer = null;
 let toolDrawerToggle = null;
 let toolDrawerContent = null;
@@ -121,9 +117,6 @@ let toolDrawerOverlay = null;
 let toolDrawerClose = null;
 let isDrawerOpen = false;
 
-/**
- * 初始化工具抽屜
- */
 function initToolDrawer() {
   toolDrawer = document.getElementById('toolDrawer');
   toolDrawerToggle = document.getElementById('toolDrawerToggle');
@@ -136,35 +129,24 @@ function initToolDrawer() {
     return;
   }
 
-  // 綁定切換按鈕事件
   toolDrawerToggle.addEventListener('click', toggleToolDrawer);
 
-  // 綁定關閉按鈕事件
   if (toolDrawerClose) {
     toolDrawerClose.addEventListener('click', hideToolDrawer);
   }
 
-  // 綁定遮罩層點擊關閉
   if (toolDrawerOverlay) {
     toolDrawerOverlay.addEventListener('click', hideToolDrawer);
   }
 
-  console.log('✅ 工具抽屜已初始化');
 }
 
-/**
- * 顯示工具抽屜切換按鈕（有工具結果時調用）
- */
 function showToolDrawerToggle() {
   if (toolDrawerToggle) {
     toolDrawerToggle.classList.add('visible');
-    console.log('📊 工具抽屜按鈕已顯示');
   }
 }
 
-/**
- * 隱藏工具抽屜切換按鈕
- */
 function hideToolDrawerToggle() {
   if (toolDrawerToggle) {
     toolDrawerToggle.classList.remove('visible');
@@ -172,9 +154,6 @@ function hideToolDrawerToggle() {
   }
 }
 
-/**
- * 切換工具抽屜開關
- */
 function toggleToolDrawer() {
   if (isDrawerOpen) {
     hideToolDrawer();
@@ -183,51 +162,34 @@ function toggleToolDrawer() {
   }
 }
 
-/**
- * 打開工具抽屜
- */
 function showToolDrawer() {
   if (toolDrawer) {
     toolDrawer.classList.add('open');
     toolDrawerToggle?.classList.add('open');
     toolDrawerOverlay?.classList.add('visible');
     isDrawerOpen = true;
-    console.log('📂 工具抽屜已打開');
   }
 }
 
-/**
- * 關閉工具抽屜
- */
 function hideToolDrawer() {
   if (toolDrawer) {
     toolDrawer.classList.remove('open');
     toolDrawerToggle?.classList.remove('open');
     toolDrawerOverlay?.classList.remove('visible');
     isDrawerOpen = false;
-    console.log('📁 工具抽屜已關閉');
   }
 }
 
-/**
- * 隱藏工具卡片（下一個請求或關懷模式時調用）
- */
 function hideToolCards() {
-  // 隱藏抽屜
   hideToolDrawer();
-  // 隱藏切換按鈕
   hideToolDrawerToggle();
-  // 清空抽屜內容
   if (toolDrawerContent) {
     toolDrawerContent.innerHTML = '';
   }
-  // 清空桌面端卡片容器
   clearAllCards();
-  console.log('🗑️ 工具卡片已隱藏');
 }
 
 function getNextPosition() {
-  // 如果卡片數量已達上限，不允許新增
   if (usedPositions.length >= MAX_CARDS) {
     console.warn('⚠️ 卡片數量已達上限（4張），請先清除現有卡片');
     return null;
@@ -245,7 +207,6 @@ function getNextPosition() {
 function addToolCard(type) {
   const position = getNextPosition();
 
-  // 如果沒有可用位置，直接返回
   if (!position) {
     return;
   }
@@ -326,7 +287,6 @@ function clearAllCards() {
   usedPositions = [];
 }
 
-// 模擬工具調用事件監聽（延遲初始化）
 function initToolCardControls() {
   document.getElementById('simulate-weather').addEventListener('click', () => {
     clearAllCards();
@@ -350,11 +310,7 @@ function initToolCardControls() {
   });
 }
 
-// ========== MCP 工具 Metadata 同步 ==========
 
-/**
- * 從後端同步工具 metadata
- */
 async function syncToolMetadata() {
   try {
     const response = await fetch('/api/mcp/tools', {
@@ -366,12 +322,10 @@ async function syncToolMetadata() {
     if (response.ok) {
       const data = await response.json();
       if (data.success && data.tools) {
-        // 將工具 metadata 儲存到全域變數（定義在 config.js）
         toolsMetadata = {};
         data.tools.forEach(tool => {
           toolsMetadata[tool.name] = tool;
         });
-        console.log(`✅ 同步 ${data.count} 個 MCP 工具 metadata`);
       }
     }
   } catch (error) {
@@ -379,12 +333,8 @@ async function syncToolMetadata() {
   }
 }
 
-/**
- * 根據分類/工具名稱自動分配圖示
- */
 function getIconForTool(toolName, category) {
   const iconMap = {
-    // 分類映射
     '健康': '❤️',
     '天氣': '🌤️',
     '新聞': '📰',
@@ -400,7 +350,6 @@ function getIconForTool(toolName, category) {
     '軌道運輸': '🚇',
     '地理定位': '📍',
 
-    // 工具名稱映射
     'healthkit_query': '❤️',
     'weather_query': '🌤️',
     'news_query': '📰',
@@ -415,37 +364,26 @@ function getIconForTool(toolName, category) {
     'directions': '🗺️'
   };
 
-  // 優先使用工具名稱匹配
   if (iconMap[toolName]) {
     return iconMap[toolName];
   }
 
-  // 其次使用分類匹配
   if (category && iconMap[category]) {
     return iconMap[category];
   }
 
-  // 預設圖示
   return '🔧';
 }
 
-/**
- * 動態顯示工具卡片（通用版本，支援所有 MCP 工具）
- * 優先渲染到抽屜面板（手機端），同時保留桌面端卡片
- */
 function displayToolCard(toolName, toolData) {
-  // 清除舊卡片
   clearAllCards();
 
-  // 獲取工具 metadata
   const toolMeta = toolsMetadata[toolName] || {};
   const category = toolMeta.category || '未知';
   const icon = getIconForTool(toolName, category);
 
-  // 渲染卡片內容（處理後的結果，非 raw data）
   const contentHTML = renderCardContent(toolName, toolData);
 
-  // 創建卡片元素
   const card = document.createElement('div');
   card.className = 'voice-tool-card';
   card.dataset.type = toolName;
@@ -458,140 +396,96 @@ function displayToolCard(toolName, toolData) {
     <div class="card-content" style="max-height: 300px; overflow-y: auto; overflow-x: hidden; padding-right: 8px;">${contentHTML}</div>
   `;
 
-  // 渲染到抽屜面板
   if (toolDrawerContent) {
     toolDrawerContent.innerHTML = '';
     toolDrawerContent.appendChild(card.cloneNode(true));
-    // 顯示抽屜切換按鈕
     showToolDrawerToggle();
-    console.log(`📊 工具卡片已渲染到抽屜: ${toolName} (${category})`);
   }
 
-  // 同時渲染到桌面端卡片容器（保留原有邏輯）
   const position = getNextPosition();
   if (position && cardsContainer) {
     card.classList.add(position);
     cardsContainer.appendChild(card);
-    console.log(`🃏 工具卡片已渲染到桌面: ${toolName} (${category})`);
   }
 }
 
-/**
- * 根據工具數據結構自動渲染內容
- */
 function renderCardContent(toolName, toolData) {
-  console.log('🔍 renderCardContent 被調用:', {toolName, toolData});
   
   if (!toolData) {
     console.warn('⚠️ toolData 為空');
     return '<p class="data-row">無數據</p>';
   }
 
-  // 模式 1：health_data 陣列（直接或在 raw_data 中）
   const healthData = toolData.health_data || toolData.raw_data?.health_data;
   if (healthData && Array.isArray(healthData)) {
-    console.log('✅ 匹配到模式 1: health_data');
     return renderHealthMetrics(healthData);
   }
 
-  // 模式 2：articles 陣列（直接或在 raw_data 中）
   const articlesData = toolData.articles || toolData.raw_data?.articles;
   if (articlesData && Array.isArray(articlesData)) {
-    console.log('✅ 匹配到模式 2: articles');
     return renderNewsList(articlesData);
   }
 
-  // 模式 3：天氣數據（直接檢查，無論是否包在 raw_data 中）
   const weatherData = toolData.raw_data || toolData;
   if (weatherData.main && weatherData.weather) {
-    console.log('✅ 匹配到模式 3: 天氣數據');
     return renderWeatherData(weatherData);
   }
 
-  // 模式 4：公車到站資訊
   if (toolData.arrivals && Array.isArray(toolData.arrivals)) {
-    console.log('✅ 匹配到模式 4: 公車到站資訊');
     return renderBusArrivals(toolData.arrivals, toolData.route_name);
   }
 
-  // 模式 5：附近公車站點
   if (toolData.stops && Array.isArray(toolData.stops)) {
-    console.log('✅ 匹配到模式 5: 附近公車站點');
     return renderNearbyStops(toolData.stops);
   }
 
-  // 模式 6：匯率數據（直接或在 raw_data 中）
   const exchangeData = toolData.raw_data || toolData;
   if (exchangeData.rate !== undefined && exchangeData.from_currency !== undefined) {
-    console.log('✅ 匹配到模式 6: 匯率數據');
     return renderExchangeRate(exchangeData);
   }
 
-  // 模式 7：火車列車資訊
   if (toolData.trains && Array.isArray(toolData.trains)) {
-    console.log('✅ 匹配到模式 7: 火車列車資訊');
     return renderTrainList(toolData.trains);
   }
 
-  // 模式 8：YouBike 站點資訊（需要確認是 YouBike 工具）
   if (toolData.stations && Array.isArray(toolData.stations) && 
       (toolName === 'tdx_youbike' || toolData.stations[0]?.available_bikes !== undefined)) {
-    console.log('✅ 匹配到模式 8: YouBike 站點資訊');
     return renderYouBikeStations(toolData.stations);
   }
   
-  // 模式 8.5：火車站點資訊（tdx_train 的 stations）
   if (toolData.stations && Array.isArray(toolData.stations) && toolName === 'tdx_train') {
-    console.log('✅ 匹配到模式 8.5: 火車站點資訊');
     return renderTrainStations(toolData.stations);
   }
 
-  // 模式 9：地理反查資訊（reverse_geocode）
   if (toolData.display_name && toolData.lat && toolData.lon && toolName === 'reverse_geocode') {
-    console.log('✅ 匹配到模式 9: 地理反查資訊');
     return renderReverseGeocode(toolData);
   }
 
-  // 模式 10：導航路線（directions）
   if ((toolData.distance_m !== undefined || toolData.duration_s !== undefined) && 
       (toolName === 'directions' || toolData.polyline !== undefined)) {
-    console.log('✅ 匹配到模式 10: 導航路線');
     return renderDirections(toolData);
   }
 
-  // 模式 11：捷運到站資訊（tdx_metro arrivals）
   if (toolData.arrivals && Array.isArray(toolData.arrivals) && toolName === 'tdx_metro') {
-    console.log('✅ 匹配到模式 11: 捷運到站資訊');
     return renderMetroArrivals(toolData.arrivals);
   }
 
-  // 模式 12：捷運站點資訊（tdx_metro stations）
   if (toolData.stations && Array.isArray(toolData.stations) && toolName === 'tdx_metro') {
-    console.log('✅ 匹配到模式 12: 捷運站點資訊');
     return renderMetroStations(toolData.stations);
   }
 
-  // 模式 13：正向地理編碼（forward_geocode）
   if (toolData.lat && toolData.lon && toolData.display_name && toolName === 'forward_geocode') {
-    console.log('✅ 匹配到模式 13: 正向地理編碼');
     return renderForwardGeocode(toolData);
   }
 
-  // 模式 14：通用 raw_data 物件
   if (toolData.raw_data && typeof toolData.raw_data === 'object') {
-    console.log('✅ 匹配到模式 14: 通用 raw_data');
     return renderKeyValuePairs(toolData.raw_data);
   }
 
-  // Fallback：顯示 JSON
   console.warn('⚠️ 未匹配任何模式，使用 JSON fallback');
-  console.log('📋 toolData 結構:', Object.keys(toolData));
   return renderJSONFallback(toolData);
 }
 
-/**
- * 渲染天氣數據
- */
 function renderWeatherData(data) {
   const main = data.main || {};
   const weather = data.weather?.[0] || {};
@@ -599,7 +493,6 @@ function renderWeatherData(data) {
   const sys = data.sys || {};
   const labels = LABELS[currentLanguage] || LABELS.zh;
   
-  // 格式化時間
   const formatTime = (timestamp) => {
     if (!timestamp) return '--:--';
     const date = new Date(timestamp * 1000);
@@ -642,9 +535,6 @@ function renderWeatherData(data) {
   `;
 }
 
-/**
- * 渲染健康指標
- */
 function renderHealthMetrics(healthData) {
   const labels = LABELS[currentLanguage] || LABELS.zh;
   
@@ -660,7 +550,6 @@ function renderHealthMetrics(healthData) {
     sleep_analysis: '😴'
   };
 
-  // 按指標類型分組
   const grouped = {};
   healthData.forEach(item => {
     const metric = item.metric || item.type;
@@ -672,7 +561,6 @@ function renderHealthMetrics(healthData) {
 
   let html = '<div class="health-metrics">';
 
-  // 渲染每種指標
   Object.entries(grouped).forEach(([metric, items], index) => {
     const icon = metricIcons[metric] || '📊';
     const label = labels[metric] || metric;
@@ -680,7 +568,6 @@ function renderHealthMetrics(healthData) {
     const value = latestItem.value;
     const unit = latestItem.unit || '';
     
-    // 格式化時間
     let timeStr = '';
     if (latestItem.timestamp) {
       try {
@@ -722,9 +609,6 @@ function renderHealthMetrics(healthData) {
   return html;
 }
 
-/**
- * 渲染新聞列表
- */
 function renderNewsList(articles) {
   const labels = LABELS[currentLanguage] || LABELS.zh;
   let html = '';
@@ -740,11 +624,7 @@ function renderNewsList(articles) {
   return html || `<p>${labels.no_news}</p>`;
 }
 
-/**
- * 渲染鍵值對（天氣等）
- */
 function renderKeyValuePairs(data) {
-  // 使用當前語言的標籤
   const labels = LABELS[currentLanguage] || LABELS.zh;
   const keyMap = {
     city: labels.city,
@@ -764,7 +644,6 @@ function renderKeyValuePairs(data) {
     const label = keyMap[key] || key;
     let displayValue = value;
 
-    // 特殊處理溫度
     if (key.includes('temp') && typeof value === 'number') {
       displayValue = `${value}°C`;
     }
@@ -780,12 +659,6 @@ function renderKeyValuePairs(data) {
   return html || '<p>無數據</p>';
 }
 
-/**
- * 渲染匯率資訊
- */
-/**
- * 渲染匯率信息
- */
 function renderExchangeRate(data) {
   const labels = LABELS[currentLanguage] || LABELS.zh;
   const currencySymbols = {
@@ -800,7 +673,6 @@ function renderExchangeRate(data) {
   
   let html = '';
 
-  // 匯率
   if (data.rate !== undefined) {
     html += `
       <div class="data-row">
@@ -810,7 +682,6 @@ function renderExchangeRate(data) {
     `;
   }
 
-  // 轉換金額
   if (data.amount && data.converted_amount !== undefined) {
     html += `
       <div class="data-row">
@@ -820,7 +691,6 @@ function renderExchangeRate(data) {
     `;
   }
   
-  // 查詢時間
   if (data.raw_data?.metadata?.timestamp) {
     const time = new Date(data.raw_data.metadata.timestamp).toLocaleString('zh-TW');
     html += `
@@ -834,9 +704,6 @@ function renderExchangeRate(data) {
   return html || `<p>${labels.no_data}</p>`;
 }
 
-/**
- * 渲染火車列車資訊
- */
 function renderTrainList(trains) {
   const labels = LABELS[currentLanguage] || LABELS.zh;
   
@@ -884,9 +751,6 @@ function renderTrainList(trains) {
   return html;
 }
 
-/**
- * 渲染火車站點資訊
- */
 function renderTrainStations(stations) {
   const labels = LABELS[currentLanguage] || LABELS.zh;
   
@@ -927,9 +791,6 @@ function renderTrainStations(stations) {
   return html;
 }
 
-/**
- * 渲染 YouBike 站點資訊
- */
 function renderYouBikeStations(stations) {
   const labels = LABELS[currentLanguage] || LABELS.zh;
   
@@ -951,7 +812,6 @@ function renderYouBikeStations(stations) {
     const bikeUnit = currentLanguage === 'zh' ? '輛' : currentLanguage === 'en' ? '' : currentLanguage === 'ko' ? '대' : currentLanguage === 'ja' ? '台' : currentLanguage === 'id' ? '' : '';
     const spaceUnit = currentLanguage === 'zh' ? '個' : currentLanguage === 'en' ? '' : currentLanguage === 'ko' ? '개' : currentLanguage === 'ja' ? '個' : currentLanguage === 'id' ? '' : '';
 
-    // 可借車輛狀態：0 = 紅色，1-3 = 橘色，>3 = 綠色
     let bikeStatusColor = '#e74c3c';
     let bikeStatusIcon = '🚫';
     if (availableBikes > 3) {
@@ -991,9 +851,6 @@ function renderYouBikeStations(stations) {
   return html;
 }
 
-/**
- * 渲染公車到站資訊
- */
 function renderBusArrivals(arrivals, routeName) {
   const labels = LABELS[currentLanguage] || LABELS.zh;
   
@@ -1003,7 +860,6 @@ function renderBusArrivals(arrivals, routeName) {
 
   let html = '';
   
-  // 按站點分組
   const stopGroups = {};
   arrivals.forEach(arr => {
     const stopName = arr.stop_name || labels.unknown;
@@ -1013,7 +869,6 @@ function renderBusArrivals(arrivals, routeName) {
     stopGroups[stopName].push(arr);
   });
 
-  // 渲染每個站點
   Object.entries(stopGroups).slice(0, 3).forEach(([stopName, stopArrivals], index) => {
     const firstArr = stopArrivals[0];
     const distance = firstArr.distance_m ? `${Math.round(firstArr.distance_m)}m` : '';
@@ -1043,9 +898,6 @@ function renderBusArrivals(arrivals, routeName) {
   return html;
 }
 
-/**
- * 渲染地理反查資訊（reverse_geocode）
- */
 function renderReverseGeocode(data) {
   const labels = LABELS[currentLanguage] || LABELS.zh;
   const displayName = data.display_name || labels.unknown;
@@ -1058,7 +910,6 @@ function renderReverseGeocode(data) {
   const lat = data.lat?.toFixed(6) || '';
   const lon = data.lon?.toFixed(6) || '';
 
-  // 組合詳細地址
   let detailedAddress = [];
   if (city) detailedAddress.push(city);
   if (admin && admin !== city) detailedAddress.push(admin);
@@ -1068,7 +919,6 @@ function renderReverseGeocode(data) {
 
   const addressText = detailedAddress.length > 0 ? detailedAddress.join(', ') : displayName;
 
-  // 生成 Google Maps 連結
   const mapsUrl = `https://www.google.com/maps?q=${lat},${lon}`;
 
   return `
@@ -1106,9 +956,6 @@ function renderReverseGeocode(data) {
   `;
 }
 
-/**
- * 渲染附近公車站點
- */
 function renderNearbyStops(stops) {
   const labels = LABELS[currentLanguage] || LABELS.zh;
   
@@ -1135,9 +982,6 @@ function renderNearbyStops(stops) {
   return html;
 }
 
-/**
- * 渲染導航路線（directions）
- */
 function renderDirections(data) {
   const labels = LABELS[currentLanguage] || LABELS.zh;
   const originLabel = data.origin_label || labels.origin;
@@ -1145,7 +989,6 @@ function renderDirections(data) {
   const distanceM = data.distance_m;
   const durationS = data.duration_s;
   
-  // 格式化距離
   let distanceStr = '--';
   if (distanceM !== undefined) {
     if (distanceM >= 1000) {
@@ -1157,7 +1000,6 @@ function renderDirections(data) {
     }
   }
   
-  // 格式化時間
   let durationStr = '--';
   if (durationS !== undefined) {
     const minutes = Math.round(durationS / 60);
@@ -1173,7 +1015,6 @@ function renderDirections(data) {
     }
   }
   
-  // 生成 Google Maps 連結（如果有座標）
   let mapsLink = '';
   if (data.origin_lat && data.origin_lon && data.dest_lat && data.dest_lon) {
     const mapsUrl = `https://www.google.com/maps/dir/${data.origin_lat},${data.origin_lon}/${data.dest_lat},${data.dest_lon}`;
@@ -1207,9 +1048,6 @@ function renderDirections(data) {
   `;
 }
 
-/**
- * 渲染捷運到站資訊（tdx_metro arrivals）
- */
 function renderMetroArrivals(arrivals) {
   const labels = LABELS[currentLanguage] || LABELS.zh;
   
@@ -1219,7 +1057,6 @@ function renderMetroArrivals(arrivals) {
 
   let html = '<div class="metro-arrivals">';
 
-  // 按路線分組
   const lineGroups = {};
   arrivals.forEach(arr => {
     const lineName = arr.line_name || labels.unknown;
@@ -1229,7 +1066,6 @@ function renderMetroArrivals(arrivals) {
     lineGroups[lineName].push(arr);
   });
 
-  // 渲染每條路線
   Object.entries(lineGroups).forEach(([lineName, lineArrivals], index) => {
     html += `
       <div class="metro-line" style="border-bottom: 1px solid #eee; padding: 12px 0; ${index === Object.keys(lineGroups).length - 1 ? 'border-bottom: none;' : ''}">
@@ -1267,9 +1103,6 @@ function renderMetroArrivals(arrivals) {
   return html;
 }
 
-/**
- * 渲染捷運站點資訊（tdx_metro stations）
- */
 function renderMetroStations(stations) {
   const labels = LABELS[currentLanguage] || LABELS.zh;
   
@@ -1317,9 +1150,6 @@ function renderMetroStations(stations) {
   return html;
 }
 
-/**
- * 渲染正向地理編碼（forward_geocode）
- */
 function renderForwardGeocode(data) {
   const labels = LABELS[currentLanguage] || LABELS.zh;
   const displayName = data.display_name || labels.unknown;
@@ -1329,7 +1159,6 @@ function renderForwardGeocode(data) {
   const road = data.road || '';
   const suburb = data.suburb || '';
 
-  // 生成 Google Maps 連結
   const mapsUrl = `https://www.google.com/maps?q=${lat},${lon}`;
 
   return `
@@ -1367,9 +1196,6 @@ function renderForwardGeocode(data) {
   `;
 }
 
-/**
- * Fallback：顯示 JSON
- */
 function renderJSONFallback(data) {
   return `<pre style="font-size: 0.85em; white-space: pre-wrap;">${JSON.stringify(data, null, 2)}</pre>`;
 }

static/frontend/js/tts.js

@@ -1,28 +1,18 @@
-// ========== TTS 核心變數 ==========
 let currentAudio = null;  // 當前播放的音頻對象
 let isPlaying = false;    // 是否正在播放
 let audioContext = null;  // 預先建立的 AudioContext（繞過自動播放限制）
 let userGestureReceived = false;  // 是否已收到用戶手勢
 
-console.log('✅ TTS 模組已載入');
 
-// ========== 用戶手勢處理（解鎖自動播放）==========
 
-/**
- * 在用戶手勢時初始化 AudioContext
- * 應該在錄音開始時調用此函數
- */
 function unlockAudioPlayback() {
   if (userGestureReceived) {
-    console.log('⚠️ 音頻播放已解鎖，跳過');
     return;
   }
 
   try {
-    // 建立 AudioContext（需要用戶手勢才能啟動）
     audioContext = new (window.AudioContext || window.webkitAudioContext)();
 
-    // 播放一個靜音音頻來"解鎖"自動播放權限
     const buffer = audioContext.createBuffer(1, 1, 22050);
     const source = audioContext.createBufferSource();
     source.buffer = buffer;
@@ -30,29 +20,17 @@ function unlockAudioPlayback() {
     source.start(0);
 
     userGestureReceived = true;
-    console.log('✅ 音頻播放已解鎖（用戶手勢已授權）');
   } catch (error) {
     console.warn('⚠️ 無法解鎖音頻播放:', error);
   }
 }
 
-// ========== 語音播放函數（異步方式）==========
 
-/**
- * 播放文字語音（異步方式）
- * 獲取完整音頻後立即播放，前端可同時顯示打字效果
- *
- * @param {string} text - 要播放的文字
- * @returns {Promise<void>}
- */
 async function speakText(text) {
-  // 停止之前的語音
   stopSpeaking();
 
   try {
-    console.log('🔊 呼叫 TTS API...');
 
-    // 呼叫後端 TTS API
     const response = await fetch('/api/tts', {
       method: 'POST',
       headers: {
@@ -72,16 +50,13 @@ async function speakText(text) {
       return;
     }
 
-    // 取得音頻數據（MP3）
     const audioBlob = await response.blob();
     const audioUrl = URL.createObjectURL(audioBlob);
 
-    // 建立 Audio 元素並播放
     currentAudio = new Audio(audioUrl);
     isPlaying = true;
 
     currentAudio.onended = () => {
-      console.log('✅ 語音播放完成');
       isPlaying = false;
       URL.revokeObjectURL(audioUrl);
     };
@@ -92,33 +67,26 @@ async function speakText(text) {
       URL.revokeObjectURL(audioUrl);
     };
 
-    // 嘗試播放（如果之前有用戶手勢，應該可以成功）
     try {
       const playPromise = currentAudio.play();
 
       if (playPromise !== undefined) {
         await playPromise;
-        console.log('▶️ 開始播放語音');
       }
     } catch (playError) {
-      // 處理瀏覽器自動播放策略限制
       if (playError.name === 'NotAllowedError') {
         console.warn('⚠️ 自動播放被阻止（瀏覽器政策）');
         console.warn('💡 解決方案：等待用戶下次點擊任意處播放');
 
-        // 保持 Audio 元素，等待用戶點擊
         isPlaying = false;
 
-        // 添加全域點擊監聽器（一次性）
         const playOnUserClick = async (e) => {
-          // 避免干擾其他點擊事件
           if (e.target.closest('.mic-button') || e.target.closest('button')) {
             return;
           }
 
           try {
             await currentAudio.play();
-            console.log('✅ 用戶點擊後自動播放成功');
             isPlaying = true;
             document.removeEventListener('click', playOnUserClick);
           } catch (retryError) {
@@ -127,18 +95,15 @@ async function speakText(text) {
           }
         };
 
-        // 監聽下次點擊（保留 5 秒）
         document.addEventListener('click', playOnUserClick, { once: false });
         setTimeout(() => {
           document.removeEventListener('click', playOnUserClick);
           if (!isPlaying) {
             URL.revokeObjectURL(audioUrl);
-            console.log('⏱️ 超時未播放，釋放音頻資源');
           }
         }, 5000);
 
       } else {
-        // 其他播放錯誤
         console.error('❌ 音頻播放失敗:', playError);
         isPlaying = false;
         URL.revokeObjectURL(audioUrl);
@@ -152,14 +117,10 @@ async function speakText(text) {
   }
 }
 
-/**
- * 停止當前語音播放
- */
 function stopSpeaking() {
   if (currentAudio && isPlaying) {
     currentAudio.pause();
     currentAudio.currentTime = 0;
     isPlaying = false;
-    console.log('⏹️ 停止語音播放');
   }
 }

static/frontend/js/ui.js

@@ -1,13 +1,4 @@
-// ========== 打字機效果函數 ==========
-
-/**
- * 異步打字機效果（文字與語音並行）
- * 立即開始語音播放，同時顯示打字效果
- * 
- * @param {string} text - 要顯示的完整文字
- * @param {number} speed - 打字速度（毫秒/字元）
- * @param {boolean} enableTTS - 是否啟用語音播放
- */
+
 function typewriterEffect(text, speed = 50, enableTTS = true) {
   agentOutput.textContent = '';
   agentOutput.classList.add('active');
@@ -15,17 +6,14 @@ function typewriterEffect(text, speed = 50, enableTTS = true) {
 
   let index = 0;
 
-  // 清除之前的打字動畫
   if (typingInterval) {
     clearInterval(typingInterval);
   }
 
-  // 立即開始語音播放（異步並行，不等待打字完成）
   if (enableTTS && typeof speakText === 'function') {
     speakText(text);  // 語音與打字效果並行
   }
 
-  // 打字效果
   typingInterval = setInterval(() => {
     if (index < text.length) {
       agentOutput.textContent += text[index];
@@ -46,7 +34,6 @@ function hideAgentOutput() {
   agentOutput.textContent = '';
 }
 
-// ========== 情緒切換 ==========
 
 function initEmotionSelector() {
   document.getElementById('emotion-select').addEventListener('change', (e) => {
@@ -56,7 +43,6 @@ function initEmotionSelector() {
   });
 }
 
-// ========== 字幕切換 ==========
 
 function initTranscriptControls() {
   document.getElementById('transcript-provisional').addEventListener('click', () => {
@@ -70,7 +56,6 @@ function initTranscriptControls() {
   });
 }
 
-// ========== 登入按鈕 ==========
 
 function initLoginButton() {
   const googleLoginBtn = document.getElementById('googleLoginBtn');
@@ -79,39 +64,30 @@ function initLoginButton() {
   }
 }
 
-// ========== 登出按鈕 ==========
 
 function initLogoutButton() {
   const logoutBtn = document.getElementById('logoutBtn');
   if (logoutBtn) {
     logoutBtn.addEventListener('click', handleLogout);
-    console.log('✅ 登出按鈕已初始化');
   }
 }
 
 function handleLogout() {
-  console.log('🚪 執行登出...');
 
-  // 清除 JWT token
   localStorage.removeItem('jwt_token');
 
-  // 停止 WebSocket 連接
   if (typeof ws !== 'undefined' && ws) {
     ws.close();
   }
 
-  // 停止語音播放
   if (typeof stopSpeaking === 'function') {
     stopSpeaking();
   }
 
-  console.log('✅ 登出成功，導向登入頁面');
 
-  // 導向登入頁面
   window.location.href = '/login/';
 }
 
-// ========== 輸入模式切換（語音 ↔ 文字）==========
 
 let isTextInputMode = false; // 當前是否為文字輸入模式
 let textInputElement = null; // 文字輸入框元素
@@ -120,7 +96,6 @@ function initChatIcon() {
   const chatIcon = document.getElementById('chatIcon');
   if (chatIcon) {
     chatIcon.addEventListener('click', toggleInputMode);
-    console.log('✅ 輸入模式切換按鈕已初始化');
   }
 }
 
@@ -134,47 +109,35 @@ function toggleInputMode() {
   }
 
   if (isTextInputMode) {
-    // 切換到文字輸入模式
-    console.log('⌨️ 切換到文字輸入模式');
 
-    // 保存原始內容
     const originalContent = transcript.textContent;
 
-    // 清空並添加 text-input-mode class
     transcript.className = 'voice-transcript text-input-mode';
     transcript.innerHTML = '';
 
-    // 創建 textarea
     textInputElement = document.createElement('textarea');
     textInputElement.placeholder = '請輸入訊息...';
     textInputElement.id = 'text-input-box';
 
-    // 監聽 Enter 鍵送出（Shift+Enter 換行）
     textInputElement.addEventListener('keydown', handleTextInput);
 
     transcript.appendChild(textInputElement);
 
-    // 自動聚焦
     setTimeout(() => textInputElement.focus(), 100);
 
   } else {
-    // 切換回語音模式
-    console.log('🎤 切換到語音模式');
 
-    // 移除 textarea
     if (textInputElement) {
       textInputElement.removeEventListener('keydown', handleTextInput);
       textInputElement = null;
     }
 
-    // 恢復原始樣式
     transcript.className = 'voice-transcript provisional';
     transcript.textContent = '請說話...';
   }
 }
 
 function handleTextInput(event) {
-  // Enter 送出（Shift+Enter 換行）
   if (event.key === 'Enter' && !event.shiftKey) {
     event.preventDefault();
 
@@ -184,23 +147,17 @@ function handleTextInput(event) {
       return;
     }
 
-    console.log('📤 送出文字訊息:', text);
 
-    // 送出到 WebSocket
     if (typeof wsManager !== 'undefined' && wsManager) {
-      // 取得當前對話 ID（如果沒有，後端會自動建立新對話）
       const chatId = window.currentChatId || null;
       wsManager.sendUserMessage(text, chatId);
 
-      // 清空輸入框
       textInputElement.value = '';
 
-      // 切換到思考狀態
       if (typeof setState === 'function') {
         setState('thinking');
       }
 
-      // 切換回語音模式
       toggleInputMode();
     } else {
       console.error('❌ WebSocket 未初始化');

static/frontend/js/websocket-old.js

@@ -1,560 +0,0 @@
-/**
- * Bloom Ware WebSocket 通訊管理模組
- * 處理 WebSocket 連接、訊息收發、重連機制、語音功能
- */
-
-import { safeStorage, safeExecute, getCurrentUserId } from './utils.js';
-
-// ========== WebSocket 連接管理 ==========
-
-export class WebSocketManager {
-  constructor(authManager) {
-    this.auth = authManager;
-    this.ws = null;
-    this.isConnecting = false;
-    this.reconnectAttempts = 0;
-    this.maxReconnectAttempts = 5;
-    this.reconnectDelay = 2000;
-
-    // 狀態管理回調
-    this.onlineCallbacks = [];
-    this.messageCallbacks = [];
-
-    // 綁定方法上下文
-    this.connect = this.connect.bind(this);
-    this.handleOpen = this.handleOpen.bind(this);
-    this.handleMessage = this.handleMessage.bind(this);
-    this.handleClose = this.handleClose.bind(this);
-    this.handleError = this.handleError.bind(this);
-  }
-
-  // 生成 WebSocket URL
-  getWsUrl() {
-    // 使用認證管理器獲取JWT token
-    let jwtToken = this.auth.getJwtToken();
-
-    console.log('🔍 WebSocket URL生成 - token檢查:', { 
-      hasToken: !!jwtToken, 
-      isAuthenticated: this.auth.isAuthenticated() 
-    });
-
-    // 檢查 token 是否存在
-    if (!jwtToken) {
-      console.error('❌ WebSocket 連線失敗：沒有 JWT token');
-      throw new Error('Missing JWT token');
-    }
-
-    // 檢查 token 是否過期（使用更寬鬆的檢查，避免剛登入就被判定過期）
-    const isExpired = this.auth.isTokenExpired();
-    if (isExpired) {
-      console.error('❌ WebSocket 連線失敗：JWT token 已過期');
-      throw new Error('JWT token expired');
-    }
-
-    // 根據當前頁面協議確定WebSocket協議
-    const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-    const host = window.location.host;
-
-    // 構建WebSocket URL
-    const url = new URL(`${protocol}//${host}/ws`);
-    url.searchParams.set('token', jwtToken);
-
-    console.log('✅ WebSocket URL已生成');
-    return url.toString();
-  }
-
-  // 建立 WebSocket 連接
-  async connect() {
-    if (this.isConnecting || (this.ws && this.ws.readyState === WebSocket.OPEN)) {
-      return;
-    }
-
-    try {
-      this.isConnecting = true;
-      const wsUrl = this.getWsUrl();
-
-      this.ws = new WebSocket(wsUrl);
-      this.notifyOnlineState(false);
-
-      this.ws.addEventListener('open', this.handleOpen);
-      this.ws.addEventListener('message', this.handleMessage);
-      this.ws.addEventListener('close', this.handleClose);
-      this.ws.addEventListener('error', this.handleError);
-
-    } catch (error) {
-      console.error('WebSocket 連接失敗:', error);
-      this.isConnecting = false;
-      this.scheduleReconnect();
-    }
-  }
-
-  // 處理 WebSocket 開啟事件
-  async handleOpen() {
-    console.log('WebSocket 連接已建立');
-    this.isConnecting = false;
-    this.reconnectAttempts = 0;
-    this.notifyOnlineState(true);
-
-    // 若已有目前對話，告知後端綁定 chat_id
-    const cid = window.currentChatId;
-    if (cid) {
-      this.send({ type: 'chat_focus', chat_id: cid });
-    }
-
-    // 如果用戶已登入但沒有當前對話，檢查是否需要創建初始對話
-    if (this.auth.user && !window.currentChatId) {
-      setTimeout(async () => {
-        await this.handleInitialChatSetup();
-      }, 500);
-    }
-  }
-
-  // 處理初始對話設置
-  async handleInitialChatSetup() {
-    try {
-      const chats = await this.getUserChats(this.auth.user.id);
-
-      if (!chats || chats.length === 0) {
-        // 用戶沒有任何對話，創建初始對話
-        await this.createInitialChat(this.auth.user);
-      } else {
-        // 用戶有對話，使用最新的對話
-        const latestChat = chats[0];
-        window.currentChatId = latestChat.chat_id;
-      }
-
-      // 刷新對話清單
-      if (window.refreshChats) {
-        window.refreshChats();
-      }
-    } catch (error) {
-      console.error('WebSocket連接後檢查對話失敗:', error);
-    }
-  }
-
-  // 處理 WebSocket 訊息
-  handleMessage(event) {
-    try {
-      const data = JSON.parse(event.data);
-
-      // 通知所有訊息回調
-      this.messageCallbacks.forEach(callback => {
-        safeExecute(() => callback(data), null, 'WebSocket 訊息回調');
-      });
-
-      // 處理不同類型的訊息
-      switch (data.type) {
-        case 'bot_message':
-          this.handleBotMessage(data);
-          break;
-        case 'chat_history':
-          this.handleChatHistory(data);
-          break;
-        case 'voice_login_status':
-          this.handleVoiceLoginStatus(data);
-          break;
-        case 'voice_login_result':
-          this.handleVoiceLoginResult(data);
-          break;
-        case 'new_chat_created':
-          this.handleNewChatCreated(data);
-          break;
-        case 'error':
-          this.handleError(data);
-          break;
-        case 'system':
-        case 'message':
-          // 這些訊息類型直接由 app.js ���回調處理
-          // 不需要額外處理，已經在上面的 forEach 中處理了
-          break;
-        default:
-          console.log('收到未知類型的訊息:', data.type);
-      }
-    } catch (error) {
-      console.error('解析 WebSocket 訊息失敗:', error);
-    }
-  }
-
-  // 處理機器人訊息
-  handleBotMessage(data) {
-    if (window.addMessage) {
-      window.addMessage('assistant', data.message || '');
-    }
-  }
-
-  // 處理聊天歷史
-  handleChatHistory(data) {
-    if (Array.isArray(data.messages) && window.addMessage) {
-      data.messages.forEach(m => {
-        window.addMessage(
-          m.role === 'assistant' ? 'assistant' : 'user',
-          m.content || ''
-        );
-      });
-    }
-  }
-
-  // 處理語音登入狀態
-  handleVoiceLoginStatus(data) {
-    const statusEl = document.getElementById('voice-login-status');
-    if (statusEl) {
-      statusEl.textContent = '錄製中…';
-    }
-  }
-
-  // 處理語音登入結果
-  async handleVoiceLoginResult(data) {
-    const statusEl = document.getElementById('voice-login-status');
-    const success = !!data.success;
-
-    if (success && data.user) {
-      // 語音登入成功
-      if (window.handleAuthenticatedUser) {
-        window.handleAuthenticatedUser(data.user, data.access_token);
-      }
-
-      await this.handleVoiceLoginSuccess(data);
-    } else {
-      // 語音登入失敗
-      const reason = data.error || '未知錯誤';
-      console.error('語音登入失敗:', reason);
-
-      if (window.UIStateManager?.showError) {
-        window.UIStateManager.showError(`語音登入失敗：${reason}`);
-      }
-    }
-
-    if (statusEl) {
-      statusEl.textContent = success ? '完成' : '失敗';
-    }
-  }
-
-  // 處理語音登入成功
-  async handleVoiceLoginSuccess(data) {
-    try {
-      const userId = data.user.id;
-      const chats = await this.getUserChats(userId);
-
-      if (chats && chats.length > 0) {
-        // 使用現有對話
-        const latestChat = chats[0];
-        window.currentChatId = latestChat.chat_id;
-
-        this.clearChatAndShowWelcome(data.welcome);
-        await this.saveWelcomeMessage(data.welcome, latestChat.chat_id);
-
-        if (window.refreshChats) {
-          window.refreshChats();
-        }
-      } else {
-        // 創建新對話
-        await this.createVoiceChatSession(userId, data.welcome);
-      }
-    } catch (error) {
-      console.error('語音登入處理對話失敗:', error);
-      this.clearChatAndShowWelcome(data.welcome);
-    }
-  }
-
-  // 創建語音聊天會話
-  async createVoiceChatSession(userId, welcome) {
-    const now = new Date();
-    const title = `${now.getFullYear()}-${String(now.getMonth()+1).padStart(2,'0')}-${String(now.getDate()).padStart(2,'0')} ${String(now.getHours()).padStart(2,'0')}:${String(now.getMinutes()).padStart(2,'0')}`;
-
-    const response = await fetch('/api/chats', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ user_id: userId, title })
-    });
-
-    const result = await response.json();
-    if (result && result.chat_id) {
-      window.currentChatId = result.chat_id;
-      if (window.refreshChats) {
-        window.refreshChats();
-      }
-    }
-
-    this.clearChatAndShowWelcome(welcome);
-    await this.saveWelcomeMessage(welcome, window.currentChatId);
-  }
-
-  // 清除聊天並顯示歡迎訊息
-  clearChatAndShowWelcome(welcome) {
-    if (window.clearChat) {
-      window.clearChat();
-    }
-    if (welcome && window.addSystem) {
-      window.addSystem(String(welcome));
-    }
-  }
-
-  // 保存歡迎訊息
-  async saveWelcomeMessage(welcome, chatId) {
-    if (!welcome || !chatId) return;
-
-    try {
-      await fetch(`/api/chats/${encodeURIComponent(chatId)}/messages`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          sender: 'assistant',
-          content: String(welcome)
-        })
-      });
-    } catch (error) {
-      console.warn('保存歡迎訊息失敗:', error);
-    }
-  }
-
-  // 處理新對話創建
-  handleNewChatCreated(data) {
-    window.currentChatId = data.chat_id;
-    if (window.addSystem) {
-      window.addSystem(`已創建新對話：${data.title || '新對話'}`);
-    }
-    if (window.refreshChats) {
-      window.refreshChats();
-    }
-  }
-
-  // 處理 WebSocket 關閉事件
-  handleClose() {
-    console.log('WebSocket 連接已關閉');
-    this.notifyOnlineState(false);
-    this.isConnecting = false;
-    this.scheduleReconnect();
-  }
-
-  // 處理 WebSocket 錯誤事件
-  handleError(error) {
-    console.error('WebSocket 連接錯誤:', error);
-    this.notifyOnlineState(false);
-    this.isConnecting = false;
-  }
-
-  // 排程重連
-  scheduleReconnect() {
-    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-      console.error('WebSocket 重連次數已達上限');
-      return;
-    }
-
-    this.reconnectAttempts++;
-    const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
-
-    setTimeout(() => {
-      console.log(`WebSocket 重連嘗試 ${this.reconnectAttempts}/${this.maxReconnectAttempts}`);
-      this.connect();
-    }, delay);
-  }
-
-  // 發送訊息（通用）
-  send(data) {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify(data));
-      return true;
-    }
-    return false;
-  }
-
-  // 發送用戶輸入
-  sendUserMessage(text, chatId) {
-    if (!text || !this.isConnected()) return false;
-
-    // 檢查認證狀態
-    if (!this.auth.isAuthenticated()) {
-      if (window.addSystem) {
-        window.addSystem('❌ 請先使用 Google 登入');
-      }
-      return false;
-    }
-
-    // 檢查對話ID
-    if (!chatId) {
-      if (window.addSystem) {
-        window.addSystem('❌ 請先選擇或創建一個對話');
-      }
-      return false;
-    }
-
-    const payload = {
-      type: 'user_message',
-      message: text,
-      user_id: getCurrentUserId(),
-      chat_id: chatId
-    };
-
-    return this.send(payload);
-  }
-
-  // 檢查連接狀態
-  isConnected() {
-    return this.ws && this.ws.readyState === WebSocket.OPEN;
-  }
-
-  // 斷開連接
-  disconnect() {
-    if (this.ws) {
-      this.ws.removeEventListener('open', this.handleOpen);
-      this.ws.removeEventListener('message', this.handleMessage);
-      this.ws.removeEventListener('close', this.handleClose);
-      this.ws.removeEventListener('error', this.handleError);
-
-      this.ws.close();
-      this.ws = null;
-    }
-    this.notifyOnlineState(false);
-  }
-
-  // 添加在線狀態回調
-  onOnlineStateChange(callback) {
-    this.onlineCallbacks.push(callback);
-  }
-
-  // 添加訊息回調
-  onMessage(callback) {
-    this.messageCallbacks.push(callback);
-  }
-
-  // 通知在線狀態變化
-  notifyOnlineState(isOnline) {
-    this.onlineCallbacks.forEach(callback => {
-      safeExecute(() => callback(isOnline), null, '在線狀態回調');
-    });
-
-    // 更新DOM狀態指示器
-    if (window.setOnline) {
-      window.setOnline(isOnline);
-    }
-  }
-
-  // 獲取用戶對話列表
-  async getUserChats(userId) {
-    try {
-      const response = await fetch(`/api/chats/${userId}`);
-      const data = await response.json();
-      return data.success ? data.chats : [];
-    } catch (error) {
-      console.error('獲取用戶對話失敗:', error);
-      return [];
-    }
-  }
-
-  // 創建初始對話
-  async createInitialChat(user) {
-    if (window.createInitialChat) {
-      return window.createInitialChat(user);
-    }
-  }
-}
-
-// ========== 語音登入管理 ==========
-
-export class VoiceLoginManager {
-  constructor(wsManager) {
-    this.ws = wsManager;
-    this.isRecording = false;
-  }
-
-  // 開始語音登入
-  async startVoiceLogin() {
-    if (this.isRecording) return;
-
-    try {
-      // 確保 WebSocket 連接
-      if (!this.ws.isConnected()) {
-        await this.ws.connect();
-        await new Promise(resolve => setTimeout(resolve, 300));
-      }
-
-      // 啟動錄音
-      const stream = await navigator.mediaDevices.getUserMedia({
-        audio: { channelCount: 1, sampleRate: 48000 },
-        video: false
-      });
-
-      const audioCtx = new (window.AudioContext || window.webkitAudioContext)({
-        sampleRate: 16000
-      });
-      const source = audioCtx.createMediaStreamSource(stream);
-      const processor = audioCtx.createScriptProcessor(4096, 1, 1);
-
-      source.connect(processor);
-      processor.connect(audioCtx.destination);
-
-      this.isRecording = true;
-      this.updateStatus('準備錄製…');
-      this.ws.send({ type: 'audio_start', sample_rate: 16000 });
-
-      let collectedMs = 0;
-      const targetMs = 4000; // 4 秒錄音
-
-      processor.onaudioprocess = (e) => {
-        try {
-          const input = e.inputBuffer.getChannelData(0);
-
-          // float32 -> int16 PCM，小端
-          const pcm16 = new Int16Array(input.length);
-          for (let i = 0; i < input.length; i++) {
-            let s = Math.max(-1, Math.min(1, input[i]));
-            pcm16[i] = s < 0 ? s * 0x8000 : s * 0x7fff;
-          }
-
-          const bytes = new Uint8Array(pcm16.buffer);
-          const b64 = btoa(String.fromCharCode(...bytes));
-
-          this.ws.send({ type: 'audio_chunk', pcm16_base64: b64 });
-
-          collectedMs += (input.length / 16000) * 1000;
-          this.updateStatus(`錄製中… ${(collectedMs/1000).toFixed(1)}s / 4.0s`);
-
-          if (collectedMs >= targetMs) {
-            // 停止錄音
-            this.stopRecording(processor, source, stream);
-          }
-        } catch (error) {
-          console.error('音頻處理錯誤:', error);
-        }
-      };
-
-    } catch (error) {
-      console.error('語音登入啟動失敗:', error);
-      this.updateStatus('無法取得麥克風權限');
-
-      if (window.UIStateManager?.showError) {
-        window.UIStateManager.showError('無法啟動語音登入：麥克風不可用');
-      }
-    }
-  }
-
-  // 停止錄音
-  stopRecording(processor, source, stream) {
-    processor.disconnect();
-
-    try {
-      source.disconnect();
-    } catch(e) {
-      console.warn('斷開音頻源失敗:', e);
-    }
-
-    try {
-      stream.getTracks().forEach(track => track.stop());
-    } catch(e) {
-      console.warn('停止音頻軌道失敗:', e);
-    }
-
-    this.ws.send({ type: 'audio_stop' });
-    this.isRecording = false;
-  }
-
-  // 更新狀態顯示
-  updateStatus(message) {
-    const statusEl = document.getElementById('voice-login-status');
-    if (statusEl) {
-      statusEl.textContent = message;
-    }
-  }
-}
-
-console.log('✅ Bloom Ware WebSocket 模組已載入');

static/frontend/js/websocket.js

@@ -1,9 +1,4 @@
-/**
- * Bloom Ware WebSocket 通訊管理模組（完整版）
- * 處理 WebSocket 連接、訊息收發、重連機制
- */
 
-// ========== WebSocket 連接管理 ==========
 
 class WebSocketManager {
   constructor(wsUrl) {
@@ -14,18 +9,15 @@ class WebSocketManager {
     this.maxReconnectAttempts = 5;
     this.reconnectDelay = 2000;
 
-    // 狀態管理回調
     this.onlineCallbacks = [];
     this.messageCallbacks = [];
 
-    // 音訊錄製相關
     this.audioContext = null;
     this.audioStream = null;
     this.audioProcessor = null;
     this.audioSource = null;
     this.isRecording = false;
 
-    // 綁定方法上下文
     this.connect = this.connect.bind(this);
     this.handleOpen = this.handleOpen.bind(this);
     this.handleMessage = this.handleMessage.bind(this);
@@ -35,16 +27,13 @@ class WebSocketManager {
     this.stopRecording = this.stopRecording.bind(this);
   }
 
-  // 建立 WebSocket 連接
   async connect() {
     if (this.isConnecting || (this.ws && this.ws.readyState === WebSocket.OPEN)) {
-      console.log('⚠️ WebSocket 已連接或正在連接中');
       return;
     }
 
     try {
       this.isConnecting = true;
-      console.log('🔌 開始建立 WebSocket 連接:', this.wsUrl);
 
       this.ws = new WebSocket(this.wsUrl);
       this.notifyOnlineState(false);
@@ -61,35 +50,33 @@ class WebSocketManager {
     }
   }
 
-  // 處理 WebSocket 開啟事件
   handleOpen() {
-    console.log('✅ WebSocket 連接已建立');
     this.isConnecting = false;
     this.reconnectAttempts = 0;
     this.notifyOnlineState(true);
 
-    // 若已有目前對話，告知後端綁定 chat_id
     const cid = window.currentChatId;
     if (cid) {
       this.send({ type: 'chat_focus', chat_id: cid });
     }
 
-    // 啟動位置追蹤（WebSocket 連線後）
     if (typeof startLocationTracking === 'function') {
       startLocationTracking();
-      console.log('📍 位置追蹤已啟動');
     } else {
       console.warn('⚠️ startLocationTracking 函數未定義');
     }
   }
 
-  // 處理 WebSocket 訊息
   handleMessage(event) {
     try {
       const data = JSON.parse(event.data);
-      console.log('📩 收到 WebSocket 訊息:', data.type);
 
-      // 通知所有訊息回調
+      const silentTypes = ['env_ack', 'typing', 'stt_partial', 'stt_delta'];
+      if (!silentTypes.includes(data.type)) {
+        if (window.DEBUG_MODE) {
+        }
+      }
+
       this.messageCallbacks.forEach(callback => {
         try {
           callback(data);
@@ -103,15 +90,10 @@ class WebSocketManager {
     }
   }
 
-  // 處理 WebSocket 關閉事件
   handleClose(event) {
-    console.log('🔌 WebSocket 連接已關閉', event);
     this.notifyOnlineState(false);
     this.isConnecting = false;
 
-    // 檢查是否為認證失敗（code 1008 或 1006 表示異常關閉）
-    // code 1006: 連接異常關閉（通常是握手失敗）
-    // code 1008: 違反政策（認證失敗）
     const isAuthError = event.code === 1008 || 
                         event.code === 1006 || 
                         event.reason?.includes('認證') || 
@@ -120,30 +102,23 @@ class WebSocketManager {
 
     if (isAuthError) {
       console.error('❌ 認證失敗，清除 token 並跳轉到登入頁面');
-      // 清除過期的 token
       localStorage.removeItem('jwt_token');
-      // 跳轉到登入頁
       setTimeout(() => {
         window.location.href = '/login/';
       }, 500);
       return;
     }
 
-    // 其他情況才嘗試重連
     this.scheduleReconnect();
   }
 
-  // 處理 WebSocket 錯誤事件
   handleError(error) {
     console.error('❌ WebSocket 連接錯誤:', error);
     this.notifyOnlineState(false);
     this.isConnecting = false;
     
-    // WebSocket 錯誤通常會伴隨 close 事件，但為了安全起見也檢查 token
-    // 如果連接失敗，可能是認證問題
     setTimeout(() => {
       if (this.reconnectAttempts > 0) {
-        // 已經嘗試重連，檢查 token 是否有效
         const token = localStorage.getItem('jwt_token');
         if (token) {
           try {
@@ -165,9 +140,7 @@ class WebSocketManager {
     }, 1000);
   }
 
-  // 排程重連
   scheduleReconnect() {
-    // 如果重連次數超過 3 次，檢查是否為認證問題
     if (this.reconnectAttempts >= 3) {
       console.warn('⚠️ 多次重連失敗，檢查 token 有效性...');
       
@@ -188,7 +161,6 @@ class WebSocketManager {
         }
       }
       
-      // 如果重連次數達到上限，清除 token 並跳轉
       if (this.reconnectAttempts >= this.maxReconnectAttempts) {
         console.error('❌ WebSocket 重連次數已達上限，可能是認證問題，清除 token 並跳轉登入頁');
         localStorage.removeItem('jwt_token');
@@ -200,33 +172,30 @@ class WebSocketManager {
     this.reconnectAttempts++;
     const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
 
-    console.log(`🔄 WebSocket 將在 ${delay}ms 後重連（第 ${this.reconnectAttempts}/${this.maxReconnectAttempts} 次）`);
 
     setTimeout(() => {
-      console.log(`🔄 WebSocket 重連嘗試 ${this.reconnectAttempts}/${this.maxReconnectAttempts}`);
       this.connect();
     }, delay);
   }
 
-  // 發送訊息（通用）
   send(data) {
     if (this.ws && this.ws.readyState === WebSocket.OPEN) {
       this.ws.send(JSON.stringify(data));
-      console.log('📤 發送 WebSocket 訊息:', data.type);
+      const silentTypes = ['audio_chunk', 'env_snapshot'];
+      if (window.DEBUG_MODE && !silentTypes.includes(data.type)) {
+      }
       return true;
     }
-    console.warn('⚠️ WebSocket 未連接，無法發送訊息');
+    console.warn('⚠️ WebSocket 未連接');
     return false;
   }
 
-  // 發送用戶輸入
   sendUserMessage(text, chatId) {
     if (!text || !this.isConnected()) {
       console.warn('⚠️ WebSocket 未連接或訊息為空');
       return false;
     }
 
-    // 檢查對話ID
     if (!chatId) {
       console.warn('⚠️ 缺少 chat_id');
       return false;
@@ -241,12 +210,10 @@ class WebSocketManager {
     return this.send(payload);
   }
 
-  // 檢查連接狀態
   isConnected() {
     return this.ws && this.ws.readyState === WebSocket.OPEN;
   }
 
-  // 斷開連接
   disconnect() {
     if (this.ws) {
       this.ws.removeEventListener('open', this.handleOpen);
@@ -260,19 +227,15 @@ class WebSocketManager {
     this.notifyOnlineState(false);
   }
 
-  // 添加在線狀態回調
   onOnlineStateChange(callback) {
     this.onlineCallbacks.push(callback);
   }
 
-  // 添加訊息回調
   onMessage(callback) {
     this.messageCallbacks.push(callback);
   }
 
-  // 通知在線狀態變化
   notifyOnlineState(isOnline) {
-    console.log(`🌐 WebSocket 狀態: ${isOnline ? '已連線' : '斷線'}`);
 
     this.onlineCallbacks.forEach(callback => {
       try {
@@ -283,11 +246,7 @@ class WebSocketManager {
     });
   }
 
-  // ========== 音訊錄製功能 ==========
 
-  /**
-   * 開始錄音（用於對話模式）
-   */
   async startRecording() {
     if (this.isRecording) {
       console.warn('⚠️ 已經在錄音中');
@@ -300,14 +259,11 @@ class WebSocketManager {
     }
 
     try {
-      console.log('🎙️ 開始錄音...');
 
-      // 🔓 解鎖音頻播放（利用用戶點擊麥克風的手勢）
       if (typeof unlockAudioPlayback === 'function') {
         unlockAudioPlayback();
       }
 
-      // 請求麥克風權限
       this.audioStream = await navigator.mediaDevices.getUserMedia({
         audio: {
           channelCount: 1,
@@ -318,20 +274,16 @@ class WebSocketManager {
         }
       });
 
-      // 創建音訊上下文
       this.audioContext = new (window.AudioContext || window.webkitAudioContext)({
         sampleRate: 16000
       });
 
-      // 創建音訊處理節點
       this.audioSource = this.audioContext.createMediaStreamSource(this.audioStream);
       this.audioProcessor = this.audioContext.createScriptProcessor(4096, 1, 1);
 
-      // 連接音訊節點
       this.audioSource.connect(this.audioProcessor);
       this.audioProcessor.connect(this.audioContext.destination);
 
-      // 發送開始錄音信號（使用自動語言檢測）
       this.send({
         type: 'audio_start',
         sample_rate: 16000,
@@ -339,29 +291,24 @@ class WebSocketManager {
         language: 'auto'  // 自動檢測語言（支援：zh/en/id/ja/vi）
       });
       
-      console.log('🌐 使用自動語言檢測');
 
       this.isRecording = true;
 
-      // 處理音訊數據
       this.audioProcessor.onaudioprocess = (e) => {
         if (!this.isRecording) return;
 
         try {
           const inputData = e.inputBuffer.getChannelData(0);
 
-          // Float32 轉 Int16 PCM
           const pcm16 = new Int16Array(inputData.length);
           for (let i = 0; i < inputData.length; i++) {
             let sample = Math.max(-1, Math.min(1, inputData[i]));
             pcm16[i] = sample < 0 ? sample * 0x8000 : sample * 0x7FFF;
           }
 
-          // 轉為 Uint8Array 並 Base64 編碼
           const bytes = new Uint8Array(pcm16.buffer);
           const b64 = btoa(String.fromCharCode(...bytes));
 
-          // 發送音訊塊
           this.send({ 
             type: 'audio_chunk', 
             pcm16_base64: b64 
@@ -372,13 +319,11 @@ class WebSocketManager {
         }
       };
 
-      console.log('✅ 錄音已開始');
       return true;
 
     } catch (error) {
       console.error('❌ 開始錄音失敗:', error);
       
-      // 顯示錯誤提示
       if (error.name === 'NotAllowedError') {
         if (typeof showErrorNotification === 'function') {
           showErrorNotification('需要麥克風權限才能使用語音功能');
@@ -390,24 +335,18 @@ class WebSocketManager {
     }
   }
 
-  /**
-   * 停止錄音
-   */
   stopRecording() {
     if (!this.isRecording) {
       console.warn('⚠️ 目前沒有在錄音');
       return;
     }
 
-    console.log('🛑 停止錄音...');
 
-    // 停止音訊處理
     if (this.audioProcessor) {
       this.audioProcessor.disconnect();
       this.audioProcessor = null;
     }
 
-    // 斷開音訊源
     if (this.audioSource) {
       try {
         this.audioSource.disconnect();
@@ -417,92 +356,61 @@ class WebSocketManager {
       this.audioSource = null;
     }
 
-    // 停止麥克風軌道
     if (this.audioStream) {
       this.audioStream.getTracks().forEach(track => track.stop());
       this.audioStream = null;
     }
 
-    // 關閉音訊上下文
     if (this.audioContext) {
       this.audioContext.close();
       this.audioContext = null;
     }
 
-    // 發送停止錄音信號
     this.send({
       type: 'audio_stop',
       mode: 'realtime_chat'  // 即時轉錄模式
     });
 
     this.isRecording = false;
-    console.log('✅ 錄音已停止');
   }
 }
 
-/**
- * 初始化 WebSocket 連接（由 app.js 呼叫）
- * @param {string} token - JWT token
- */
 function initializeWebSocket(token) {
-  console.log('🚀 初始化 WebSocket 連接...');
-
-  // 根據當前頁面協議確定WebSocket協議
   const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
   const host = window.location.host;
 
-  // 讀取語音登入的情緒資料（如果有）
   const voiceEmotion = localStorage.getItem('voice_login_emotion');
-  
-  // 構建WebSocket URL（包含情緒參數）
+
   let wsUrl = `${protocol}//${host}/ws?token=${token}`;
   if (voiceEmotion) {
     wsUrl += `&emotion=${encodeURIComponent(voiceEmotion)}`;
-    console.log('😊 檢測到語音登入情緒，將傳遞給歡迎詞:', voiceEmotion);
-    // 使用後立即清除，避免重複使用
     localStorage.removeItem('voice_login_emotion');
-    
-    // 立即套用情緒主題到 UI（不等待後端回應）
+
     if (typeof applyEmotion === 'function') {
       applyEmotion(voiceEmotion);
-      console.log('✅ 語音登入情緒主題已套用:', voiceEmotion);
     }
   }
 
-  // 創建 WebSocket 管理器
   wsManager = new WebSocketManager(wsUrl);
 
-  // 監聽訊息（原本在 js/websocket.js 中的邏輯）
   wsManager.onMessage((data) => {
-    console.log('📩 收到 WebSocket 訊息:', data);
-
     switch(data.type) {
       case 'system':
-        // 系統訊息（歡迎詞、連線成功）
-        console.log('🔔 系統訊息:', data.message);
-
-        // 提取並保存 chat_id（後端在歡迎訊息中會發送）
         if (data.chat_id) {
           window.currentChatId = data.chat_id;
-          console.log('✅ Chat ID 已設定（來自 system 訊息）:', window.currentChatId);
         }
-
         if (data.message) {
           setState('speaking', {
             outputText: data.message,
-            enableTTS: false,  // 歡迎詞不使用 TTS
-            persistent: true   // 持續顯示直到用戶發起請求
+            enableTTS: false,
+            persistent: true
           });
-          // 系統訊息不自動轉回 idle，保持顯示狀態
-          // 用戶發起請求時會自動清除
         }
         break;
 
       case 'typing':
-        // 思考中提示（新請求開始，隱藏工具卡片）
         if (data.message === 'thinking') {
           setState('thinking');
-          // 隱藏上一次的工具卡片
           if (typeof hideToolCards === 'function') {
             hideToolCards();
           }
@@ -510,45 +418,31 @@ function initializeWebSocket(token) {
         break;
 
       case 'bot_message':
-        // AI 回應完成 - 使用異步方式（文字與語音並行）
-        console.log('💬 AI 回應:', data.message);
-        console.log('🔧 工具資訊:', {
-          tool_name: data.tool_name,
-          tool_data: data.tool_data,
-          has_tool_data: !!data.tool_data,
-          tool_data_keys: data.tool_data ? Object.keys(data.tool_data) : null
-        });
-        
-        // 同時啟動：文字打字效果 + 語音播放
+
+        if (data.emotion && typeof applyEmotion === 'function') {
+          applyEmotion(data.emotion);
+        }
+
+        if (data.care_mode && typeof hideToolCards === 'function') {
+          hideToolCards();
+        }
+
         setState('speaking', {
           outputText: data.message,
-          enableTTS: true  // 啟用語音（異步並行）
+          enableTTS: true
         });
 
-        // 如果有工具資料，顯示對應卡片
         if (data.tool_name && data.tool_data) {
-          console.log('📊 準備顯示工具卡片:', data.tool_name);
           displayToolCard(data.tool_name, data.tool_data);
-        } else {
-          console.log('⚠️ 無工具資料，不顯示卡片');
         }
-
-        // 不自動返回 idle，保持回應顯示
-        // 用戶下次點擊麥克風時會自動開始新的請求
-        console.log('✅ AI 回應已顯示（保持狀態直到下次請求）');
         break;
 
       case 'stt_partial':
-        // STT 臨時結果（用戶還在說話）
-        console.log('🎙️ STT 臨時結果:', data.text);
         transcript.textContent = data.text;
         transcript.className = 'voice-transcript provisional';
         break;
 
       case 'stt_delta':
-        // STT 即時增量結果（OpenAI Realtime API）
-        console.log('⚡ STT Delta:', data.text);
-        // 累積顯示轉錄文字（逐字顯示效果）
         if (!window.realtimeTranscript) {
           window.realtimeTranscript = '';
         }
@@ -558,100 +452,63 @@ function initializeWebSocket(token) {
         break;
 
       case 'stt_final':
-        // STT 最終結果（用戶停止說話）
-        console.log('✅ STT 最終結果:', data.text);
         transcript.textContent = data.text;
         transcript.className = 'voice-transcript final';
-
-        // 清空即時轉錄累積文字
         window.realtimeTranscript = '';
 
-        // 應用情緒主題（如果有的話）
         if (data.emotion && typeof applyEmotion === 'function') {
-          console.log('😊 應用情緒主題:', data.emotion);
           applyEmotion(data.emotion);
         }
         break;
 
       case 'realtime_stt_status':
-        // OpenAI Realtime API 連線狀態
-        console.log('🔌 Realtime STT 狀態:', data.status, data.message);
         if (data.status === 'connected') {
-          console.log('✅ 即時轉錄已啟動');
-          // 清空之前的累積文字
           window.realtimeTranscript = '';
-        } else if (data.status === 'disconnected') {
-          console.log('🔌 即時轉錄已結束');
         }
         break;
 
       case 'chat_ready':
-        // 後端發送當前 chat_id
         window.currentChatId = data.chat_id;
-        console.log('✅ Chat ID 已設定:', window.currentChatId);
         break;
 
       case 'error':
-        // 錯誤訊息
         console.error('❌ 後端錯誤:', data.message);
         setState('idle');
         showErrorNotification(data.message);
         break;
 
       case 'voice_login_result':
-        // 語音登入結果
         handleVoiceLoginResult(data);
         break;
 
       case 'voice_login_status':
-        // 語音登入狀態更新
-        console.log('🎙️ 語音登入狀態:', data.message);
         break;
 
       case 'emotion_detected':
-        // 情緒檢測結果
-        console.log('😊 檢測到情緒:', data.emotion, '關懷模式:', data.care_mode);
-
-        // 應用情緒主題（使用 agent.js 的 applyEmotion 函數）
         if (data.emotion && typeof applyEmotion === 'function') {
           applyEmotion(data.emotion);
-          console.log('✅ 情緒主題已套用:', data.emotion);
-        } else {
-          console.warn('⚠️ applyEmotion 函數未定義或情緒值無效');
         }
-
-        // 如果啟用關懷模式，隱藏工具卡片
-        if (data.care_mode) {
-          console.log('💙 關懷模式已啟動，隱藏工具卡片');
-          if (typeof hideToolCards === 'function') {
-            hideToolCards();
-          }
+        if (data.care_mode && typeof hideToolCards === 'function') {
+          hideToolCards();
         }
         break;
 
       case 'audio_emotion_detected':
-        // 音頻情緒檢測結果（新增）
-        console.log('🎭 檢測到音頻情緒:', data.emotion, '置信度:', data.confidence, 'source:', data.source);
-
-        // 如果置信度 >= 0.5，應用情緒主題
-        if (data.emotion && data.confidence >= 0.5 && typeof applyEmotion === 'function') {
+        if (data.emotion && data.confidence >= 0.35 && typeof applyEmotion === 'function') {
           applyEmotion(data.emotion);
-          console.log('✅ 音頻情緒主題已套用:', data.emotion, `(置信度: ${data.confidence.toFixed(2)})`);
-        } else if (data.confidence < 0.5) {
-          console.log('⚠️ 音頻情緒置信度過低，不套用主題:', data.confidence.toFixed(2));
-        } else {
-          console.warn('⚠️ applyEmotion 函數未定義或情緒值無效');
         }
         break;
 
+      case 'env_ack':
+        break;
+
       default:
-        console.log('🔍 未處理的訊息類型:', data.type);
+        if (window.DEBUG_MODE) {
+        }
     }
   });
 
-  // 監聽連線狀態變化
   wsManager.onOnlineStateChange((isOnline) => {
-    console.log(`🌐 WebSocket 狀態: ${isOnline ? '已連線' : '斷線'}`);
     if (!isOnline) {
       setState('disconnected');
     } else if (currentState === 'disconnected') {
@@ -659,25 +516,17 @@ function initializeWebSocket(token) {
     }
   });
 
-  // 開始連接
   wsManager.connect();
-
-  console.log('✅ WebSocket 管理器已初始化');
 }
 
-/**
- * 處理語音登入結果
- */
 function handleVoiceLoginResult(data) {
   if (data.success && data.user) {
     currentUserId = data.user.id;
 
-    // 套用情緒主題
     if (data.emotion && data.emotion.label) {
       applyEmotion(data.emotion.label);
     }
 
-    // 顯示歡迎詞
     if (data.welcome) {
       setState('speaking', {
         outputText: data.welcome,
@@ -686,11 +535,9 @@ function handleVoiceLoginResult(data) {
       setTimeout(() => setState('idle'), 5000);
     }
 
-    console.log('✅ 語音登入成功:', data.user.name);
   } else {
     console.warn('⚠️ 語音登入失敗:', data.error);
     showErrorNotification(`語音登入失敗: ${data.error || '未知錯誤'}`);
   }
 }
 
-console.log('✅ WebSocket 模組已載入（完整版）');