Good

app.py

@@ -757,19 +757,24 @@ async def websocket_endpoint_with_jwt(
                                 """VAD 偵測到語音段結束"""
                                 logger.debug(f"🎤 VAD Committed: {item_id}")
 
+                            # 從前端獲取語言設定（支援：zh, en, id, ja, vi，或 auto 自動檢測）
+                            language = message_data.get("language", "auto")
+                            logger.info(f"🌐 語言設定: {language}")
+
                             # 連線到 OpenAI Realtime API
                             success = await realtime_stt.connect(
                                 on_transcript_delta=on_transcript_delta,
                                 on_transcript_done=on_transcript_done,
                                 on_vad_committed=on_vad_committed,
                                 model="gpt-4o-mini-transcribe",
-                                language="zh"
+                                language=language
                             )
 
                             if success:
-                                # 儲存 Realtime STT 實例到 client info
+                                # 儲存 Realtime STT 實例和語言設定到 client info
                                 client_info = manager.get_client_info(user_id) or {}
                                 client_info["realtime_stt"] = realtime_stt
+                                client_info["language"] = language  # 儲存語言設定
                                 manager.set_client_info(user_id, client_info)
 
                                 await websocket.send_json({
@@ -814,6 +819,13 @@ async def websocket_endpoint_with_jwt(
                                 audio_bytes = base64.b64decode(b64)
                                 await realtime_stt.send_audio_chunk(audio_bytes)
                                 logger.debug(f"🎤 轉發音頻到 OpenAI: {len(audio_bytes)} bytes")
+                                
+                                # 同時儲存到本地緩衝（用於音頻情緒辨識）
+                                audio_buffer = client_info.get("audio_buffer", b"")
+                                audio_buffer += audio_bytes
+                                client_info["audio_buffer"] = audio_buffer
+                                manager.set_client_info(user_id, client_info)
+                                
                             except Exception as e:
                                 logger.error(f"❌ 轉發音頻失敗: {e}")
 
@@ -1028,6 +1040,7 @@ async def websocket_endpoint_with_jwt(
                             client_info = manager.get_client_info(user_id) or {}
                             realtime_stt = client_info.get("realtime_stt")
                             transcription = client_info.get("realtime_transcript", "")
+                            audio_buffer = client_info.get("audio_buffer", b"")
 
                             if realtime_stt:
                                 logger.info(f"🔌 關閉即時轉錄連線，用戶 {user_id}")
@@ -1051,6 +1064,38 @@ async def websocket_endpoint_with_jwt(
                             if transcription:
                                 logger.info(f"🤖 處理即時轉錄結果: {transcription}")
 
+                                # 音頻情緒辨識（新增）
+                                audio_emotion = None
+                                if audio_buffer:
+                                    try:
+                                        from services.audio_emotion_service import audio_emotion_service
+                                        logger.info(f"🎭 開始音頻情緒辨識，音頻大小: {len(audio_buffer)} bytes")
+                                        audio_emotion = await audio_emotion_service.predict_from_bytes(audio_buffer)
+                                        
+                                        if audio_emotion.get("success"):
+                                            emotion_label = audio_emotion.get("emotion")
+                                            confidence = audio_emotion.get("confidence", 0.0)
+                                            logger.info(f"✅ 音頻情緒: {emotion_label} (置信度: {confidence:.4f})")
+                                            
+                                            # 發送音頻情緒給前端
+                                            await websocket.send_json({
+                                                "type": "audio_emotion_detected",
+                                                "emotion": emotion_label,
+                                                "confidence": confidence,
+                                                "all_emotions": audio_emotion.get("all_emotions", {}),
+                                                "source": "audio"
+                                            })
+                                        else:
+                                            logger.warning(f"⚠️ 音頻情緒辨識失敗: {audio_emotion.get('error')}")
+                                            audio_emotion = None
+                                    except Exception as e:
+                                        logger.error(f"❌ 音頻情緒辨識異常: {e}")
+                                        audio_emotion = None
+                                    finally:
+                                        # 清理音頻緩衝
+                                        client_info.pop("audio_buffer", None)
+                                        manager.set_client_info(user_id, client_info)
+
                                 # 通知前端開始思考
                                 await websocket.send_json({"type": "typing", "message": "thinking"})
 
@@ -1078,28 +1123,42 @@ async def websocket_endpoint_with_jwt(
                                     # 保存用戶訊息
                                     await save_message_to_db(user_id, chat_id, "user", transcription)
 
+                                    # 取得語言設定
+                                    language = client_info.get("language", "auto")
+
                                     # 處理對話（透過 handle_message，自動處理 pipeline）
                                     response = await handle_message(
                                         transcription,
                                         user_id,
                                         chat_id,
-                                        []  # messages 參數（會自動從數據庫載入）
+                                        [],  # messages 參數（會自動從數據庫載入）
+                                        audio_emotion=audio_emotion,  # 傳遞音頻情緒
+                                        language=language  # 傳遞語言設定（新增）
                                     )
 
                                     # 發送回應
+                                    # 從 PipelineResult 提取情緒
+                                    emotion = None
+                                    care_mode = False
                                     if isinstance(response, PipelineResult):
                                         message_text = response.text
+                                        if response.meta:
+                                            emotion = response.meta.get('emotion')
+                                            care_mode = response.meta.get('care_mode', False)
 
                                         await websocket.send_json({
                                             "type": "bot_message",
                                             "message": message_text,
                                             "timestamp": time.time(),
                                             "tool_name": None,
-                                            "tool_data": None
+                                            "tool_data": None,
+                                            "emotion": emotion,
+                                            "care_mode": care_mode
                                         })
                                     elif isinstance(response, dict):
                                         tool_name = response.get('tool_name')
                                         tool_data = response.get('tool_data')
+                                        emotion = response.get('emotion')
                                         message_text = response.get('message', response.get('content', ''))
 
                                         await websocket.send_json({
@@ -1107,14 +1166,16 @@ async def websocket_endpoint_with_jwt(
                                             "message": message_text,
                                             "timestamp": time.time(),
                                             "tool_name": tool_name,
-                                            "tool_data": tool_data
+                                            "tool_data": tool_data,
+                                            "emotion": emotion
                                         })
                                     else:
                                         # 字串回應
                                         await websocket.send_json({
                                             "type": "bot_message",
                                             "message": str(response),
-                                            "timestamp": time.time()
+                                            "timestamp": time.time(),
+                                            "emotion": None
                                         })
 
                                 await _process_realtime_chat()
@@ -1128,170 +1189,6 @@ async def websocket_endpoint_with_jwt(
                                 "message": f"關閉即時轉錄失敗: {str(e)}"
                             })
 
-                    elif mode == "chat":
-                        # === 新的對話模式：並行執行 STT + 情緒辨識 ===
-                        try:
-                            import asyncio as _async_lib
-                            from services.stt_service import transcribe_audio
-                            from services.voice_login import VoiceAuthService
-
-                            # 獲取音頻數據（從 _buffers 中）
-                            audio_data = None
-                            emotion_result = None
-
-                            if hasattr(app.state, "voice_auth") and app.state.voice_auth:
-                                voice_service = app.state.voice_auth
-
-                                # 獲取音頻數據（從 _buffers 取得完整音頻）
-                                if user_id in voice_service._buffers:
-                                    audio_data = bytes(voice_service._buffers[user_id])
-                                    sample_rate = voice_service._sr_overrides.get(user_id, 16000)
-
-                                    # 並行執行 STT 和情緒辨識
-                                    stt_task = transcribe_audio(audio_data, language="zh")
-                                    emotion_task = _async_lib.to_thread(
-                                        voice_service._infer_emotion_from_bytes,
-                                        audio_data,
-                                        sample_rate
-                                    )
-
-                                    stt_result, emotion_result = await _async_lib.gather(
-                                        stt_task, emotion_task, return_exceptions=True
-                                    )
-
-                                    # 清理 session
-                                    voice_service.clear_session(user_id)
-
-                                    # 檢查結果
-                                    if isinstance(stt_result, Exception):
-                                        logger.error(f"❌ STT 失敗: {stt_result}")
-                                        await websocket.send_json({
-                                            "type": "error",
-                                            "message": f"語音轉文字失敗: {str(stt_result)}"
-                                        })
-                                        continue
-
-                                    if not stt_result.get("success"):
-                                        await websocket.send_json({
-                                            "type": "error",
-                                            "message": stt_result.get("error", "STT 失敗")
-                                        })
-                                        continue
-
-                                    # 提取轉錄文字和情緒標籤
-                                    transcription = stt_result.get("text", "")
-                                    emotion_label = emotion_result.get("label", "neutral") if emotion_result and not isinstance(emotion_result, Exception) else "neutral"
-
-                                    logger.info(f"🎙️ STT: {transcription}")
-                                    logger.info(f"😊 情緒: {emotion_label}")
-
-                                    # 發送 STT 最終結果給前端（讓用戶看到轉錄文字）
-                                    await websocket.send_json({
-                                        "type": "stt_final",
-                                        "text": transcription,
-                                        "emotion": emotion_label
-                                    })
-
-                                    # 將轉錄文字和情緒標籤一起發送給 Agent
-                                    # 構造包含情緒資訊的訊息
-                                    enhanced_message = {
-                                        "text": transcription,
-                                        "emotion": emotion_label
-                                    }
-
-                                    # 通知前端開始思考
-                                    await websocket.send_json({"type": "typing", "message": "thinking"})
-
-                                    # 異步處理對話邏輯（複用現有的 chat 流程）
-                                    async def _process_voice_chat():
-                                        chat_id = message_data.get("chat_id")
-
-                                        # 如果沒有 chat_id，創建新對話
-                                        if not chat_id:
-                                            try:
-                                                user_chats_result = await get_user_chats(user_id)
-                                                if user_chats_result["success"] and user_chats_result["chats"]:
-                                                    latest_chat = user_chats_result["chats"][0]
-                                                    chat_id = latest_chat["chat_id"]
-                                                else:
-                                                    chat_title = f"語音對話 {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
-                                                    chat_result = await create_chat(user_id, chat_title)
-                                                    if chat_result["success"]:
-                                                        chat_id = chat_result["chat"]["chat_id"]
-                                            except Exception as e:
-                                                logger.error(f"創建對話失敗: {e}")
-                                                await websocket.send_json({"type": "error", "message": "無法創建對話"})
-                                                return
-
-                                        # 保存用戶訊息（包含情緒標籤在訊息內容中）
-                                        # 注意: 目前 save_message_to_db 不支持 metadata 參數
-                                        # 情緒資訊已透過 enhanced_transcription 包含在訊息中
-                                        await save_message_to_db(user_id, chat_id, "user", transcription)
-
-                                        # 將情緒資訊嵌入用戶訊息 (讓 AI 知道用戶的情緒狀態)
-                                        enhanced_transcription = transcription
-                                        if emotion_label and emotion_label != "neutral":
-                                            # 在訊息前添加情緒標籤提示
-                                            emotion_hints = {
-                                                "happy": "開心",
-                                                "sad": "悲傷",
-                                                "angry": "憤怒",
-                                                "fear": "恐懼",
-                                                "surprise": "驚訝"
-                                            }
-                                            emotion_cn = emotion_hints.get(emotion_label, emotion_label)
-                                            enhanced_transcription = f"[用戶情緒: {emotion_cn}] {transcription}"
-
-                                        # 處理對話（透過 handle_message，自動處理 pipeline）
-                                        response = await handle_message(
-                                            enhanced_transcription,
-                                            user_id,
-                                            chat_id,
-                                            []  # messages 參數（會自動從數據庫載入）
-                                        )
-
-                                        # 發送回應
-                                        if isinstance(response, PipelineResult):
-                                            message_text = response.text
-                                            
-                                            await websocket.send_json({
-                                                "type": "bot_message",
-                                                "message": message_text,
-                                                "timestamp": time.time(),
-                                                "tool_name": None,
-                                                "tool_data": None
-                                            })
-                                            
-                                            # 保存 Agent 回應（已在 handle_message 中保存）
-                                        elif isinstance(response, dict):
-                                            tool_name = response.get('tool_name')
-                                            tool_data = response.get('tool_data')
-                                            message_text = response.get('message', response.get('content', ''))
-
-                                            await websocket.send_json({
-                                                "type": "bot_message",
-                                                "message": message_text,
-                                                "timestamp": time.time(),
-                                                "tool_name": tool_name,
-                                                "tool_data": tool_data
-                                            })
-                                            
-                                            # 保存 Agent 回應（已在 handle_message 中保存）
-                                        else:
-                                            # 字串回應
-                                            await websocket.send_json({
-                                                "type": "bot_message",
-                                                "message": str(response),
-                                                "timestamp": time.time()
-                                            })
-                                    await _process_voice_chat()
-
-                        except Exception as e:
-                            logger.error(f"語音對話流程失敗: {e}")
-                            await websocket.send_json({
-                                "type": "error",
-                                "message": f"語音對話處理失敗: {str(e)}"
-                            })
                                             
             except json.JSONDecodeError:
                 await manager.send_message("消息格式錯誤，無法解析", user_id, "error")
@@ -1310,8 +1207,8 @@ async def websocket_endpoint_with_jwt(
 # -----------------------------
 # 消息處理與AI
 # -----------------------------
-async def handle_message(user_message, user_id, chat_id, messages, request_id: str = None):
-    logger.info(f"📥 handle_message: 收到訊息='{user_message}', user_id={user_id}")
+async def handle_message(user_message, user_id, chat_id, messages, request_id: str = None, audio_emotion: dict = None, language: str = None):
+    logger.info(f"📥 handle_message: 收到訊息='{user_message}', user_id={user_id}, audio_emotion={audio_emotion}, language={language}")
     
     # 指令優先，避免進入管線造成不必要延遲
     if user_message and user_message.startswith("/"):
@@ -1342,7 +1239,7 @@ async def handle_message(user_message, user_id, chat_id, messages, request_id: s
         logger.info(f"🔧 Pipeline: 功能處理結果='{result}'")
         return result
 
-    async def _ai(messages_in, cid, model, rid, chat_id, use_care_mode=False, care_emotion=None, emotion_label=None):
+    async def _ai(messages_in, cid, model, rid, chat_id, use_care_mode=False, care_emotion=None, emotion_label=None, language=None):
         env_context = {}
         env_service = getattr(app.state, 'env_service', None)
         if env_service:
@@ -1360,6 +1257,9 @@ async def handle_message(user_message, user_id, chat_id, messages, request_id: s
         except Exception as e:
             logger.debug(f"無法取得用戶名稱，使用預設值: {e}")
 
+        # 使用傳入的 language 參數（優先）或閉包捕獲的外部變數
+        lang = language if language is not None else globals().get('language', 'zh')
+
         # 兼容：如果傳入字串，視為 user_message；如果傳入 list，視為 messages
         if isinstance(messages_in, str):
             return await ai_service.generate_response_for_user(
@@ -1373,6 +1273,7 @@ async def handle_message(user_message, user_id, chat_id, messages, request_id: s
                 user_name=user_name,
                 emotion_label=emotion_label,
                 env_context=env_context,
+                language=lang,
             )
         else:
             return await ai_service.generate_response_for_user(
@@ -1386,6 +1287,7 @@ async def handle_message(user_message, user_id, chat_id, messages, request_id: s
                 user_name=user_name,
                 emotion_label=emotion_label,
                 env_context=env_context,
+                language=lang,
             )
 
     model = settings.OPENAI_MODEL
@@ -1400,8 +1302,8 @@ async def handle_message(user_message, user_id, chat_id, messages, request_id: s
         feature_timeout=30.0,  # 功能處理超時 (15 → 30，新聞摘要生成需要更長時間)
         ai_timeout=20.0,  # AI回應超時 (30 → 20)
     )
-    logger.info(f"⚙️ 準備調用 ChatPipeline.process，user_message='{user_message}'")
-    res: PipelineResult = await pipeline.process(user_message, user_id=user_id, chat_id=chat_id, request_id=request_id)
+    logger.info(f"⚙️ 準備調用 ChatPipeline.process，user_message='{user_message}', audio_emotion={audio_emotion}, language={language}")
+    res: PipelineResult = await pipeline.process(user_message, user_id=user_id, chat_id=chat_id, request_id=request_id, audio_emotion=audio_emotion, language=language)
     logger.info(f"⚙️ ChatPipeline.process 完成，結果='{res.text}', is_fallback={res.is_fallback}, reason={res.reason}")
     
     # 檢查是否有工具元數據

core/intent_detector.py

@@ -159,23 +159,47 @@ class IntentDetector:
         
         注意：不再描述每個工具，工具定義由 tools 參數傳遞
         """
-        return """你是一個智能助手，根據用戶需求選擇合適的工具。
+        return """你是一個多語言智能助手，根據用戶需求選擇合適的工具。支援中文、英文、日文、印尼文、越南文。
 
-規則：
-1. 如果用戶需求可以用工具解決，選擇最適合的工具
-2. 如果是一般聊天或問候，不要選擇任何工具
+【核心規則】
+1. 用戶詢問任何可用工具能解決的需求時，必須選擇對應工具
+2. 只有純粹的閒聊、問候、情感表達才不選擇工具
 3. 工具參數盡量從用戶消息中提取，無法確定的使用合理預設值
 
-特殊處理：
-- 天氣查詢：城市名稱使用英文（台北→Taipei, 東京→Tokyo）
-- 匯率查詢：貨幣使用 ISO 4217 代碼（美元→USD, 台幣→TWD）
-- 公車查詢：route_name 必須是路線號碼（如 307、紅30），不是目的地名稱
-- 火車查詢：「往XX」表示 destination_station，不是 origin_station
-- 位置查詢：「我在哪」使用 reverse_geocode，不需要參數
-- YouBike 查詢：任何提到 YouBike/Ubike/微笑單車 的請求使用 tdx_youbike
+【多語言意圖識別】
+無論用戶使用什麼語言，都要識別以下意圖並選擇對應工具：
 
-情緒判斷：
-根據用戶消息的語氣判斷情緒，在回應中包含 emotion 欄位：
+天氣查詢（weather_query）：
+- 中文：天氣、氣溫、會下雨嗎、今天熱嗎
+- 英文：weather, temperature, rain, hot today, forecast
+- 日文：天気、気温、雨、暑い
+- 印尼文：cuaca, suhu, hujan
+- 越南文：thời tiết, nhiệt độ, mưa
+
+匯率查詢（exchange_rate）：
+- 中文：匯率、換算、多少錢
+- 英文：exchange rate, convert, currency
+- 日文：為替、両替
+- 印尼文：kurs, tukar
+- 越南文：tỷ giá, đổi tiền
+
+新聞查詢（news_search）：
+- 中文：新聞、頭條、最新消息
+- 英文：news, headlines, latest
+- 日文：ニュース、最新
+- 印尼文：berita, terbaru
+- 越南文：tin tức, mới nhất
+
+【參數處理】
+- 天氣查詢：城市名稱使用英文（台北→Taipei, 東京→Tokyo, Jakarta, Hanoi）
+- 匯率查詢：貨幣使用 ISO 4217 代碼（USD, TWD, JPY, IDR, VND）
+- 公車查詢：route_name 必須是路線號碼（如 307、紅30）
+- 火車查詢：「往XX」表示 destination_station
+- 位置查詢：「我在哪」「where am I」使用 reverse_geocode
+- YouBike 查詢：YouBike/Ubike/微笑單車 使用 tdx_youbike
+
+【情緒判斷】
+根據用戶消息的語氣判斷情緒：
 - neutral: 平靜、中性
 - happy: 開心、興奮
 - sad: 難過、沮喪

core/pipeline.py

@@ -47,6 +47,230 @@ class ChatPipeline:
         self._feature_timeout = feature_timeout
         self._ai_timeout = ai_timeout
         self._model = model
+        
+        # 語言名稱映射
+        self._language_names = {
+            "zh": "繁體中文",
+            "en": "English",
+            "ja": "日本語",
+            "ko": "한국어",
+            "id": "Bahasa Indonesia",
+            "vi": "Tiếng Việt",
+        }
+
+    def _detect_language(self, text: str) -> str:
+        """
+        簡單的語言檢測（基於字符範圍）
+        
+        Args:
+            text: 輸入文字
+        
+        Returns:
+            語言代碼（zh, en, ja, ko, id, vi）
+        """
+        if not text:
+            return "zh"
+        
+        # 統計各語言字符數量
+        korean_count = 0
+        japanese_count = 0
+        chinese_count = 0
+        latin_count = 0
+        vietnamese_count = 0
+        
+        vietnamese_chars = set("àáảãạăằắẳẵặâầấẩẫậèéẻẽẹêềếểễệìíỉĩịòóỏõọôồốổỗộơờớởỡợùúủũụưừứửữựỳýỷỹỵđ")
+        
+        for char in text:
+            code = ord(char)
+            # 韓文
+            if 0xAC00 <= code <= 0xD7AF or 0x1100 <= code <= 0x11FF:
+                korean_count += 1
+            # 日文假名
+            elif 0x3040 <= code <= 0x309F or 0x30A0 <= code <= 0x30FF:
+                japanese_count += 1
+            # 中文
+            elif 0x4E00 <= code <= 0x9FFF:
+                chinese_count += 1
+            # 拉丁字母
+            elif 0x0041 <= code <= 0x007A:
+                latin_count += 1
+            # 越南文特殊字符
+            if char.lower() in vietnamese_chars:
+                vietnamese_count += 1
+        
+        # 判斷主要語言
+        if korean_count > 0:
+            return "ko"
+        if japanese_count > chinese_count and japanese_count > 0:
+            return "ja"
+        if vietnamese_count > 0:
+            return "vi"
+        if chinese_count > latin_count and chinese_count > 0:
+            return "zh"
+        if latin_count > 0:
+            # 可能是英文或印尼文，預設英文
+            return "en"
+        
+        return "zh"
+
+    async def _translate_tool_data(self, tool_data: Dict[str, Any], target_language: str) -> Dict[str, Any]:
+        """
+        翻譯工具卡片中的文字欄位
+        
+        Args:
+            tool_data: 工具資料字典
+            target_language: 目標語言代碼
+        
+        Returns:
+            翻譯後的工具資料
+        """
+        if not tool_data or target_language == "zh":
+            return tool_data
+        
+        try:
+            import copy
+            translated_data = copy.deepcopy(tool_data)
+            
+            # 需要翻譯的欄位名稱（天氣、新聞等工具的顯示欄位）
+            translatable_keys = {
+                "description", "main", "name", "title", "summary", 
+                "content", "message", "text", "label", "status"
+            }
+            
+            # 收集需要翻譯的文字欄位
+            texts_to_translate = []
+            text_paths = []  # 記錄路徑以便回填
+            
+            def collect_texts(obj, path="", parent_key=""):
+                """遞迴收集需要翻譯的文字"""
+                if isinstance(obj, dict):
+                    for key, value in obj.items():
+                        new_path = f"{path}.{key}" if path else key
+                        # 跳過純技術欄位
+                        if key in ("id", "url", "link", "lat", "lon", "timestamp", "code", "icon", "base", "cod"):
+                            continue
+                        collect_texts(value, new_path, key)
+                elif isinstance(obj, list):
+                    for i, item in enumerate(obj):
+                        collect_texts(item, f"{path}[{i}]", parent_key)
+                elif isinstance(obj, str) and len(obj) > 1:
+                    # 翻譯條件：
+                    # 1. 欄位名稱在可翻譯列表中
+                    # 2. 或字串包含中文
+                    # 3. 或字串是純英文描述（非數字、非代碼）
+                    should_translate = (
+                        parent_key.lower() in translatable_keys or
+                        any('\u4e00' <= c <= '\u9fff' for c in obj) or
+                        (obj.isalpha() or ' ' in obj) and len(obj) > 2
+                    )
+                    if should_translate:
+                        texts_to_translate.append(obj)
+                        text_paths.append(path)
+            
+            collect_texts(translated_data)
+            
+            if not texts_to_translate:
+                return tool_data
+            
+            # 批量翻譯
+            import services.ai_service as ai_service
+            lang_name = self._language_names.get(target_language, target_language)
+            
+            combined_text = "\n---\n".join(texts_to_translate)
+            messages = [
+                {
+                    "role": "system",
+                    "content": f"將以下內容翻譯成 {lang_name}，保持格式和表情符號。每段用 '---' 分隔，輸出也用 '---' 分隔。只輸出翻譯結果。"
+                },
+                {"role": "user", "content": combined_text}
+            ]
+            
+            translated = await ai_service.generate_response_async(
+                messages=messages,
+                model="gpt-5-nano",
+                reasoning_effort="minimal",
+                max_tokens=800,  # 工具卡片翻譯：實際輸出限制 800 tokens
+            )
+            
+            if translated:
+                translated_parts = translated.strip().split("---")
+                translated_parts = [p.strip() for p in translated_parts if p.strip()]
+                
+                # 回填翻譯結果
+                def set_value(obj, path, value):
+                    """根據路徑設置值"""
+                    parts = path.replace("]", "").replace("[", ".").split(".")
+                    for part in parts[:-1]:
+                        if part.isdigit():
+                            obj = obj[int(part)]
+                        else:
+                            obj = obj[part]
+                    last = parts[-1]
+                    if last.isdigit():
+                        obj[int(last)] = value
+                    else:
+                        obj[last] = value
+                
+                for i, path in enumerate(text_paths):
+                    if i < len(translated_parts):
+                        try:
+                            set_value(translated_data, path, translated_parts[i])
+                        except Exception:
+                            pass
+            
+            logger.info(f"🌐 工具卡片已翻譯: {len(texts_to_translate)} 個欄位")
+            return translated_data
+            
+        except Exception as e:
+            logger.warning(f"⚠️ 工具卡片翻譯失敗: {e}")
+            return tool_data
+
+    async def _translate_tool_response(self, text: str, target_language: str) -> str:
+        """
+        翻譯工具回應到目標語言
+        
+        Args:
+            text: 原始文字（中文）
+            target_language: 目標語言代碼（en, ja, ko, id, vi）
+        
+        Returns:
+            翻譯後的文字
+        """
+        if not text or target_language == "zh":
+            return text
+        
+        try:
+            import services.ai_service as ai_service
+            
+            lang_name = self._language_names.get(target_language, target_language)
+            
+            messages = [
+                {
+                    "role": "system",
+                    "content": f"你是一個翻譯助手。將以下內容翻譯成 {lang_name}，保持格式、表情符號和數字不變。只輸出翻譯結果，不要加任何解釋。"
+                },
+                {
+                    "role": "user",
+                    "content": text
+                }
+            ]
+            
+            translated = await ai_service.generate_response_async(
+                messages=messages,
+                model="gpt-5-nano",
+                reasoning_effort="minimal",
+                max_tokens=500,  # 工具回應翻譯：實際輸出限制 500 tokens
+            )
+            
+            if translated and translated.strip():
+                logger.info(f"🌐 工具回應已翻譯: {target_language}")
+                return translated.strip()
+            
+            return text
+            
+        except Exception as e:
+            logger.warning(f"⚠️ 翻譯失敗，使用原文: {e}")
+            return text
 
     async def _with_timeout(self, coro: Awaitable[Any], timeout: float, reason: str) -> Any:
         try:
@@ -72,10 +296,17 @@ class ChatPipeline:
         user_id: Optional[str] = None,
         chat_id: Optional[str] = None,
         request_id: Optional[str] = None,
+        audio_emotion: Optional[Dict[str, Any]] = None,
+        language: Optional[str] = None,
     ) -> PipelineResult:
         if not user_message or not user_message.strip():
             return PipelineResult(text="我沒有收到您的消息，請重新輸入。", is_fallback=True, reason="empty")
 
+        # 自動檢測語言（如果沒有傳入）
+        if not language:
+            language = self._detect_language(user_message)
+            logger.info(f"🌐 自動檢測語言: {language}")
+
         # 0) 先進行意圖偵測以提取情緒（需要在關懷模式檢查前執行）
         detect_res = await self._with_timeout(
             self._intent_detector(user_message), self._detect_timeout, reason="detect"
@@ -84,10 +315,25 @@ class ChatPipeline:
             return detect_res
         has_feature, intent_data = detect_res
 
-        # 提取情緒
-        emotion = intent_data.get("emotion", "neutral") if intent_data else "neutral"
-        emotion_value = emotion or "neutral"
-        logger.info(f"😊 用戶情緒: {emotion}")
+        # 提取情緒（雙軌制：音頻情緒優先，文字情緒輔助）
+        text_emotion = intent_data.get("emotion", "neutral") if intent_data else "neutral"
+        
+        # 情緒融合邏輯
+        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:
+                emotion_value = audio_emotion_label
+                logger.info(f"🎭 使用音頻情緒: {emotion_value} (置信度: {audio_confidence:.4f})")
+                logger.info(f"📝 文字情緒: {text_emotion} (輔助)")
+            else:
+                emotion_value = text_emotion
+                logger.info(f"📝 使用文字情緒: {emotion_value} (音頻置信度過低: {audio_confidence:.4f})")
+        else:
+            emotion_value = text_emotion
+            logger.info(f"📝 使用文字情緒: {emotion_value} (無音頻情緒)")
 
         # 1) 檢查是否在關懷模式
         if user_id and EmotionCareManager.is_in_care_mode(user_id, chat_id):
@@ -169,6 +415,14 @@ class ChatPipeline:
                     tool_data = feat_res.get('tool_data')
                     if not text:
                         return PipelineResult(text="抱歉，功能處理沒有產出結果。", is_fallback=True, reason="feature-empty")
+                    
+                    # 如果語言不是中文，翻譯工具回應和工具卡片
+                    if language and language != "zh":
+                        text = await self._translate_tool_response(text, language)
+                        # 翻譯工具卡片中的文字欄位
+                        if tool_data:
+                            tool_data = await self._translate_tool_data(tool_data, language)
+                    
                     # 返回帶有工具元數據的結果（包含情緒）
                     meta_dict = {}
                     if tool_name:
@@ -187,6 +441,11 @@ class ChatPipeline:
                     text = str(feat_res or "").strip()
                     if not text:
                         return PipelineResult(text="抱歉，功能處理沒有產出結果。", is_fallback=True, reason="feature-empty")
+                    
+                    # 如果語言不是中文，翻譯工具回應
+                    if language and language != "zh":
+                        text = await self._translate_tool_response(text, language)
+                    
                     return PipelineResult(
                         text=text,
                         is_fallback=False,
@@ -203,6 +462,7 @@ class ChatPipeline:
                 request_id,
                 chat_id,
                 emotion_label=emotion_value,
+                language=language,
             ),
             self._ai_timeout,
             reason="ai",

features/mcp/agent_bridge.py

@@ -218,8 +218,8 @@ class MCPAgentBridge:
         # 將 MCP Server 的工具註冊到 tool_registry
         self._sync_tools_to_registry()
 
-        # 2025 最佳實踐：啟動時預熱熱門查詢快取
-        await self._preheat_cache()
+        # 快取預熱已移除：啟動時連續調用 7 次 GPT API 增加延遲和成本
+        # 實際使用中快取會自然累積，無需預熱
 
     def _sync_tools_to_registry(self) -> int:
         """
@@ -632,17 +632,24 @@ class MCPAgentBridge:
         注意：不再描述每個工具，工具定義由 tools 參數傳遞
         只處理特殊規則和情緒判斷
         """
-        return """你是一個智能助手，根據用戶需求選擇合適的工具。
+        return """You are an intelligent assistant that selects appropriate tools based on user needs.
 
-規則：
-1. 如果用戶需求可以用工具解決，選擇最適合的工具
-2. 如果是一般聊天或問候，不要選擇任何工具
-3. 工具參數盡量從用戶消息中提取，無法確定的使用合理預設值
+Rules:
+1. If the user's request can be solved with a tool, select the most appropriate tool
+2. Only skip tool selection for pure greetings (hi, hello) or meta questions (what can you do)
+3. Extract tool parameters from user message, use reasonable defaults if uncertain
+4. User may speak in ANY language (Chinese, English, Korean, Japanese, Indonesian, Vietnamese, etc.) - always try to match their intent to available tools
+
+【IMPORTANT】Weather/News/Exchange queries in ANY language should trigger tools:
+- "How is the weather today?" → weather_query
+- "오늘 날씨 어때?" → weather_query  
+- "今天天氣如何?" → weather_query
+- "What's the USD to JPY rate?" → exchange_query
+- "最新新聞" / "latest news" → news_query
 
 【重要】語言使用規範：
 - 調用工具時：所有參數必須使用英文（城市名、國家名、貨幣代碼等）
-- 回覆用戶時：必須使用繁體中文
-- 範例：用戶說「台北天氣」→ 參數 {"city": "Taipei"}，回覆「台北目前...」
+- 範例：用戶說「台北天氣」或 "Taipei weather" → 參數 {"city": "Taipei"}
 
 參數語言轉換規則：
 - 城市名稱：台北→Taipei, 新北→NewTaipei, 桃園→Taoyuan, 台中→Taichung, 台南→Tainan, 高雄→Kaohsiung, 新竹→Hsinchu
@@ -1244,35 +1251,4 @@ YouBike 查詢（重要！參數提取規則）：
         # 保持與舊 FeatureRouter 相同的邏輯
         return response
 
-    async def _preheat_cache(self):
-        """
-        快取預熱（2025 最佳實踐）
-
-        啟動時預先載入熱門查詢的意圖檢測結果，減少冷啟動延遲
-        預期提升首次查詢命中率 40-60%
-        """
-        logger.info("🔥 開始快取預熱...")
-
-        # 定義熱門查詢（根據使用統計調整）
-        hot_queries = [
-            "台北天氣",
-            "天氣如何",
-            "美元匯率",
-            "今日新聞",
-            "科技新聞",
-            "我的心率",
-            "今天步數",
-        ]
 
-        preheated_count = 0
-        for query in hot_queries:
-            try:
-                # 預先執行意圖檢測，寫入快取
-                await self.detect_intent(query)
-                preheated_count += 1
-                logger.debug(f"✓ 預熱快取: '{query}'")
-            except Exception as e:
-                logger.warning(f"⚠️ 預熱快取失敗 '{query}': {e}")
-
-        logger.info(f"🔥 快取預熱完成，成功預載 {preheated_count}/{len(hot_queries)} 條熱門查詢")
-        logger.info(f"💾 當前快取大小: {len(self._intent_cache)} 條")

features/mcp/tools/directions_tool.py

@@ -22,7 +22,7 @@ ORS_API_KEY = os.getenv("OPENROUTESERVICE_API_KEY", "")
 
 class DirectionsTool(MCPTool):
     NAME = "directions"
-    DESCRIPTION = "規劃兩點之間的路線（walk/drive/cycle），返回距離、時間與 polyline"
+    DESCRIPTION = "Plan routes between two points (walk/drive/cycle), returns distance, duration, and polyline"
     CATEGORY = "地理定位"
     TAGS = ["route", "navigation", "directions"]
     KEYWORDS = ["導航", "路線", "怎麼去", "怎麼走", "規劃", "開車", "步行", "騎車"]

features/mcp/tools/exchange_tool.py

@@ -28,7 +28,7 @@ class ExchangeTool(MCPTool):
     """匯率查詢 MCP 工具"""
 
     NAME = "exchange_query"
-    DESCRIPTION = "查詢即時匯率（支援主要貨幣兌換）"
+    DESCRIPTION = "Query real-time exchange rates between major currencies"
     CATEGORY = "生活資訊"
     TAGS = ["exchange", "匯率", "貨幣"]
     KEYWORDS = ["匯率", "美元", "台幣", "exchange", "USD", "TWD", "貨幣", "換算"]

features/mcp/tools/geocode_tool.py

@@ -17,7 +17,7 @@ logger = logging.getLogger("mcp.tools.geocode")
 
 class ReverseGeocodeTool(MCPTool):
     NAME = "reverse_geocode"
-    DESCRIPTION = "以經緯度反查城市/行政區（優先使用快取）"
+    DESCRIPTION = "Convert coordinates (latitude/longitude) to city/district names (uses cache when available)"
     CATEGORY = "地理定位"
     TAGS = ["geocode", "reverse", "city"]
     KEYWORDS = ["座標", "經緯度", "反查", "地址", "我在哪"]

features/mcp/tools/geocoding_tool.py

@@ -17,7 +17,7 @@ logger = logging.getLogger("mcp.tools.geocoding")
 
 class ForwardGeocodeTool(MCPTool):
     NAME = "forward_geocode"
-    DESCRIPTION = "將地點名稱（如「銘傳大學」「桃園火車站」）轉換為經緯度座標"
+    DESCRIPTION = "Convert place names (e.g., 'Ming Chuan University', 'Taoyuan Train Station') to coordinates (latitude/longitude)"
     CATEGORY = "地理定位"
     TAGS = ["geocode", "forward", "地點", "座標"]
     KEYWORDS = ["地點", "位置", "座標", "在哪裡", "地址查詢"]

features/mcp/tools/healthkit_tool.py

@@ -20,7 +20,7 @@ class HealthKitTool(MCPTool):
     """HealthKit 健康數據查詢工具 - 從數據庫讀取"""
     
     NAME = "healthkit_query"
-    DESCRIPTION = "查詢用戶的健康數據，包括心率、步數、血氧、呼吸頻率等（數據由iOS設備自動同步到Firestore）"
+    DESCRIPTION = "Query user's health data including heart rate, steps, oxygen level, respiratory rate, etc. (data synced from iOS devices to Firestore)"
     CATEGORY = "健康數據"
     TAGS = ["health", "fitness", "database", "firestore"]
     KEYWORDS = ["健康", "心率", "步數", "血氧", "睡眠", "health", "運動", "卡路里", "呼吸"]

features/mcp/tools/news_tool.py

@@ -31,7 +31,7 @@ class NewsTool(MCPTool):
     """新聞查詢 MCP 工具 - 使用 NewsData.io（更好的台灣與繁中新聞支援）"""
 
     NAME = "news_query"
-    DESCRIPTION = "查詢最新新聞（可指定類別、語言、數量）"
+    DESCRIPTION = "Query latest news articles (can specify category, language, and quantity)"
     CATEGORY = "生活資訊"
     TAGS = ["news", "新聞", "資訊"]
     KEYWORDS = ["新聞", "消息", "報導", "news", "頭條", "時事"]

features/mcp/tools/tdx_bus_arrival.py

@@ -24,7 +24,7 @@ class TDXBusArrivalTool(MCPTool):
     """TDX 公車即時到站查詢"""
     
     NAME = "tdx_bus_arrival"
-    DESCRIPTION = "查詢公車即時到站時間。適用於：1) 已知路線號碼（如307、紅30）的到站查詢；2) 查詢附近公車站。不適用於路線規劃（如「從A到B的公車」應用directions）。"
+    DESCRIPTION = "Query real-time bus arrival times. Use for: 1) Known route numbers (e.g., 307, Red 30); 2) Nearby bus stops. Not for route planning (use 'directions' instead)."
     CATEGORY = "道路運輸"
     TAGS = ["tdx", "公車", "即時到站", "公共運輸"]
     KEYWORDS = ["公車", "巴士", "bus", "到站", "即時", "幾分鐘", "公車站", "等公車", "路線號碼"]

features/mcp/tools/tdx_metro.py

@@ -17,7 +17,7 @@ class TDXMetroTool(MCPTool):
     """TDX 捷運即時到站查詢"""
     
     NAME = "tdx_metro"
-    DESCRIPTION = "查詢捷運即時到站、最近車站（台北/高雄/桃園/台中捷運）"
+    DESCRIPTION = "Query metro/MRT real-time arrivals and nearest stations (Taipei/Kaohsiung/Taoyuan/Taichung metro systems)"
     CATEGORY = "軌道運輸"
     TAGS = ["tdx", "捷運", "MRT", "即時到站"]
     KEYWORDS = ["捷運", "MRT", "地鐵", "metro", "到站"]

features/mcp/tools/tdx_parking.py

@@ -17,7 +17,7 @@ class TDXParkingTool(MCPTool):
     """TDX 停車場與充電站查詢"""
     
     NAME = "tdx_parking"
-    DESCRIPTION = "查詢附近停車場、即時剩餘車位、收費標準、充電站資訊"
+    DESCRIPTION = "Query nearby parking lots with real-time available spaces, pricing, and EV charging station information"
     CATEGORY = "停車與充電"
     TAGS = ["tdx", "停車", "充電站", "電動車"]
     KEYWORDS = ["停車", "停車場", "充電", "充電站", "車位", "電動車"]

features/mcp/tools/tdx_thsr.py

@@ -18,7 +18,7 @@ class TDXTHSRTool(MCPTool):
     """TDX 台灣高鐵時刻表查詢"""
     
     NAME = "tdx_thsr"
-    DESCRIPTION = "查詢台灣高鐵時刻表、票價、最近車站（南港-左營）"
+    DESCRIPTION = "Query Taiwan High Speed Rail (THSR) schedules, fares, and nearest stations (Nangang to Zuoying)"
     CATEGORY = "軌道運輸"
     TAGS = ["tdx", "高鐵", "THSR", "時刻表", "票價"]
     KEYWORDS = ["高鐵", "THSR", "HSR", "高速鐵路", "時刻", "票價"]

features/mcp/tools/tdx_train.py

@@ -18,7 +18,7 @@ class TDXTrainTool(MCPTool):
     """TDX 台鐵時刻表查詢"""
     
     NAME = "tdx_train"
-    DESCRIPTION = "查詢台鐵列車時刻表。參數提取規則：「從A到B」→origin_station=A,destination_station=B；「往B」→destination_station=B（起點用GPS）；「車次123」→train_no=123。"
+    DESCRIPTION = "Query Taiwan Railway (TRA) train schedules. Parameter extraction: 'from A to B' → origin_station=A, destination_station=B; 'to B' → destination_station=B (origin from GPS); 'train 123' → train_no=123."
     CATEGORY = "軌道運輸"
     TAGS = ["tdx", "台鐵", "TRA", "火車", "時刻表"]
     KEYWORDS = ["台鐵", "臺鐵", "火車", "TRA", "列車", "時刻", "自強號", "莒光號", "區間車"]

features/mcp/tools/tdx_youbike.py

@@ -17,7 +17,7 @@ class TDXBikeTool(MCPTool):
     """TDX YouBike 即時查詢"""
     
     NAME = "tdx_youbike"
-    DESCRIPTION = "查詢附近 YouBike 站點、即時車輛數、空位數（支援 YouBike 1.0/2.0）"
+    DESCRIPTION = "Query nearby YouBike stations with real-time available bikes and parking spaces (supports YouBike 1.0/2.0)"
     CATEGORY = "微型運具"
     TAGS = ["tdx", "youbike", "ubike", "共享單車", "微笑單車"]
     KEYWORDS = [

features/mcp/tools/weather_tool.py

@@ -30,7 +30,7 @@ class WeatherTool(MCPTool):
     """天氣查詢 MCP 工具"""
 
     NAME = "weather_query"
-    DESCRIPTION = "查詢指定城市的即時天氣資訊（溫度、濕度、天氣狀況等）"
+    DESCRIPTION = "Query real-time weather information (temperature, humidity, conditions, etc.) for a specified city"
     CATEGORY = "生活資訊"
     TAGS = ["weather", "天氣", "氣象"]
     KEYWORDS = ["天氣", "氣溫", "下雨", "晴天", "陰天", "weather", "溫度", "濕度", "會不會下雨", "熱不熱", "冷不冷"]

models/speaker_identification/scripts/inference.py

@@ -5,7 +5,7 @@ import numpy as np
 import pickle
 import wave
 import pyaudio
-from speechbrain.pretrained import EncoderClassifier
+from speechbrain.inference import EncoderClassifier
 from sklearn.metrics.pairwise import cosine_similarity
 
 # 常數

routers/voice.py

@@ -24,8 +24,10 @@ class SpeakerLabelBindRequest(BaseModel):
 class TTSRequest(BaseModel):
     """TTS 請求"""
     text: str
-    voice: str = "nova"
+    voice: str = "coral"
     speed: float = 1.0
+    emotion: Optional[str] = None  # 情緒標籤（neutral, happy, sad, angry, fear, surprise）
+    care_mode: bool = False  # 是否為關懷模式
 
 
 @router.post("/bind-speaker")
@@ -88,6 +90,8 @@ async def text_to_speech(
             text=request.text,
             voice=request.voice,
             speed=request.speed,
+            emotion=request.emotion,
+            care_mode=request.care_mode,
         )
 
         if not result.get("success"):

services/ai_service.py

@@ -17,6 +17,16 @@ from core.ai_client import get_openai_client
 # 超時設定（秒）
 OPENAI_TIMEOUT = settings.OPENAI_TIMEOUT
 
+# 語言指令模板
+LANGUAGE_INSTRUCTIONS = {
+    "zh": "請使用繁體中文回覆",
+    "en": "Please respond in English",
+    "id": "Silakan balas dalam Bahasa Indonesia",
+    "ja": "日本語で返信してください",
+    "vi": "Vui lòng trả lời bằng tiếng Việt",
+    "auto": "請使用與用戶相同的語言回覆"
+}
+
 # 情緒關懷模式 System Prompt（新增）
 CARE_MODE_SYSTEM_PROMPT = """你是 BloomWare 的情緒關懷助手「小花」，由銘傳大學人工智慧應用學系槓上開發團隊打造。你不是 GPT，也不要自稱 GPT；你的任務是在情緒低落時傾聽、陪伴。
 
@@ -71,6 +81,7 @@ def _build_base_system_prompt(
     use_care_mode: bool,
     care_emotion: Optional[str],
     user_name: Optional[str],
+    language: Optional[str] = None,
 ) -> str:
     if use_care_mode:
         base_prompt = CARE_MODE_SYSTEM_PROMPT.strip()
@@ -81,9 +92,12 @@ def _build_base_system_prompt(
             "你是 BloomWare 的個人化助理 小花，由銘傳大學人工智慧應用學系 槓上開發 團隊開發。"
             "你不是 GPT，也不要自稱 GPT。"
             "你是一個友善、有禮、幽默且能夠提供幫助的AI助手。"
-            "請使用使用者的語言進行回覆，保持簡潔清晰的表達。"
         )
 
+    # 加入語言指令（明確指定輸出語言）
+    language_instruction = LANGUAGE_INSTRUCTIONS.get(language or "auto", LANGUAGE_INSTRUCTIONS["auto"])
+    base_prompt = f"{base_prompt}\n\n【重要】{language_instruction}，保持簡潔清晰的表達。"
+
     if user_name:
         base_prompt = f"用戶名稱：{user_name}\n\n{base_prompt}"
 
@@ -650,6 +664,7 @@ async def generate_response_for_user(
     user_name: Optional[str] = None,
     emotion_label: Optional[str] = None,
     env_context: Optional[Dict[str, Any]] = None,
+    language: Optional[str] = None,
 ) -> str:
     """
     為用戶生成AI回應
@@ -681,6 +696,7 @@ async def generate_response_for_user(
                 user_name=user_name,
                 emotion_label=emotion_label,
                 env_context=env_context,
+                language=language,
             )
         else:
             # 回退到原有的全局歷史管理（用於向後兼容）
@@ -699,6 +715,7 @@ async def generate_response_for_user(
                 user_name=user_name,
                 emotion_label=emotion_label,
                 env_context=env_context,
+                language=language,
             )
 
         logger.error("未提供消息列表或用戶消息")
@@ -727,6 +744,7 @@ async def _generate_response_with_chat_db(
     user_name: Optional[str] = None,
     emotion_label: Optional[str] = None,
     env_context: Optional[Dict[str, Any]] = None,
+    language: Optional[str] = None,
 ):
     """使用DB管理對話歷史的實現"""
     try:
@@ -738,14 +756,24 @@ async def _generate_response_with_chat_db(
                     system_prompt = f"{CARE_MODE_SYSTEM_PROMPT}\n\n{emotion_text}"
                     logger.info(f"💙 使用關懷模式 System Prompt，情緒：{care_emotion}")
                 else:
+                    # 根據語言參數調整回應語言
+                    language_instruction = {
+                        "zh": "繁體中文",
+                        "en": "English",
+                        "ko": "한국어 (Korean)",
+                        "ja": "日本語 (Japanese)",
+                        "id": "Bahasa Indonesia",
+                        "vi": "Tiếng Việt (Vietnamese)"
+                    }.get(language, "繁體中文")
+                    
                     system_prompt = (
                         "你是 BloomWare 的個人化助理 小花，由銘傳大學人工智慧應用學系 槓上開發 團隊開發。"
                         "你不是 GPT，也不要自稱 GPT。"
                         "你是一個友善、有禮、幽默且能夠提供幫助的AI助手。\n\n"
-                        "【重要】語言使用規範：\n"
-                        "- 回覆用戶時：必須使用繁體中文，保持簡潔清晰的表達\n"
+                        f"【重要】語言使用規範：\n"
+                        f"- 回覆用戶時：必須使用 {language_instruction}，保持簡潔清晰的表達\n"
                         "- 調用工具時：所有參數必須使用英文（城市名、國家名、貨幣代碼等）\n"
-                        "- 範例：用戶問「台北天氣」→ 調用工具時參數用 {\"city\": \"Taipei\"}，回覆時說「台北目前...\""
+                        "- 範例：用戶問「台北天氣」→ 調用工具時參數用 {\"city\": \"Taipei\"}，回覆時用對應語言描述"
                     )
 
                 # 在系統提示前加上用戶名稱
@@ -860,6 +888,7 @@ async def _generate_response_with_chat_db(
                 use_care_mode=use_care_mode,
                 care_emotion=care_emotion,
                 user_name=user_name,
+                language=language,
             )
 
             messages_to_send = _compose_messages_with_context(
@@ -915,6 +944,7 @@ async def _generate_response_with_chat_db(
             user_name=user_name,
             emotion_label=emotion_label,
             env_context=env_context,
+            language=language,
         )
 
 
@@ -934,6 +964,7 @@ async def _generate_response_with_global_history(
     user_name: Optional[str] = None,
     emotion_label: Optional[str] = None,
     env_context: Optional[Dict[str, Any]] = None,
+    language: Optional[str] = None,
 ):
     """使用全局歷史的回退實現（向後兼容）"""
     try:
@@ -945,14 +976,24 @@ async def _generate_response_with_global_history(
                     system_prompt = f"{CARE_MODE_SYSTEM_PROMPT}\n\n{emotion_text}"
                     logger.info(f"💙 使用關懷模式 System Prompt（全局歷史），情緒：{care_emotion}")
                 else:
+                    # 根據語言參數調整回應語言
+                    language_instruction = {
+                        "zh": "繁體中文",
+                        "en": "English",
+                        "ko": "한국어 (Korean)",
+                        "ja": "日本語 (Japanese)",
+                        "id": "Bahasa Indonesia",
+                        "vi": "Tiếng Việt (Vietnamese)"
+                    }.get(language, "繁體中文")
+                    
                     system_prompt = (
                         "你是 BloomWare 的個人化助理 小花，由銘傳大學人工智慧應用學系 槓上開發 團隊開發。"
                         "你不是 GPT，也不要自稱 GPT。"
                         "你是一個友善、有禮、幽默且能夠提供幫助的AI助手。\n\n"
-                        "【重要】語言使用規範：\n"
-                        "- 回覆用戶時：必須使用繁體中文，保持簡潔清晰的表達\n"
+                        f"【重要】語言使用規範：\n"
+                        f"- 回覆用戶時：必須使用 {language_instruction}，保持簡潔清晰的表達\n"
                         "- 調用工具時：所有參數必須使用英文（城市名、國家名、貨幣代碼等）\n"
-                        "- 範例：用戶問「台北天氣」→ 調用工具時參數用 {\"city\": \"Taipei\"}，回覆時說「台北目前...\""
+                        "- 範例：用戶問「台北天氣」→ 調用工具時參數用 {\"city\": \"Taipei\"}，回覆時用對應語言描述"
                     )
 
                 # 在系統提示前加上用戶名稱
@@ -1007,6 +1048,7 @@ async def _generate_response_with_global_history(
                 use_care_mode=use_care_mode,
                 care_emotion=care_emotion,
                 user_name=user_name,
+                language=language,
             )
 
             # 關懷模式不帶長期記憶

services/audio_emotion_service.py

@@ -0,0 +1,175 @@
+"""
+音頻情緒辨識服務
+使用 HuBERT 中文語音情緒辨識模型進行語音語調分析
+
+支援情緒：angry, fear, happy, neutral, sad, surprise
+"""
+
+import io
+import logging
+import asyncio
+import tempfile
+import os
+from typing import Dict, Any, Optional, Tuple
+import numpy as np
+
+from core.logging import get_logger
+
+logger = get_logger("services.audio_emotion")
+
+# 延遲導入（避免啟動時載入模型）
+_emotion_module = None
+
+
+def _load_emotion_module():
+    """延遲載入情緒辨識模組"""
+    global _emotion_module
+    if _emotion_module is None:
+        try:
+            from models.emotion_recognition import emotion
+            _emotion_module = emotion
+            logger.info("✅ 音頻情緒辨識模組載入成功")
+        except Exception as e:
+            logger.error(f"❌ 音頻情緒辨識模組載入失敗: {e}")
+            _emotion_module = None
+    return _emotion_module
+
+
+class AudioEmotionService:
+    """音頻情緒辨識服務"""
+
+    # 情緒標籤映射（統一格式）
+    EMOTION_MAP = {
+        "生氣(angry)": "angry",
+        "恐懼(fear)": "fear",
+        "開心(happy)": "happy",
+        "中性(neutral)": "neutral",
+        "悲傷(sad)": "sad",
+        "驚訝(surprise)": "surprise"
+    }
+
+    def __init__(self):
+        self._initialized = False
+
+    async def predict_from_bytes(
+        self,
+        audio_bytes: bytes,
+        sample_rate: int = 16000
+    ) -> Dict[str, Any]:
+        """
+        從音頻 bytes 預測情緒
+
+        Args:
+            audio_bytes: PCM16 音頻數據
+            sample_rate: 採樣率（預設 16000Hz）
+
+        Returns:
+            {
+                "success": bool,
+                "emotion": str,  # 情緒標籤（angry, fear, happy, neutral, sad, surprise）
+                "confidence": float,  # 置信度（0-1）
+                "all_emotions": dict,  # 所有情緒的置信度
+                "source": "audio",  # 情緒來源
+                "error": str (optional)
+            }
+        """
+        try:
+            # 延遲載入模組
+            emotion_module = _load_emotion_module()
+            if emotion_module is None:
+                return {
+                    "success": False,
+                    "emotion": "neutral",
+                    "confidence": 0.0,
+                    "error": "情緒辨識模組未載入"
+                }
+
+            # 檢查音頻長度
+            if len(audio_bytes) < sample_rate * 2:  # 至少 1 秒
+                logger.warning(f"⚠️ 音頻過短: {len(audio_bytes)} bytes")
+                return {
+                    "success": False,
+                    "emotion": "neutral",
+                    "confidence": 0.0,
+                    "error": "音頻過短"
+                }
+
+            logger.info(f"🎤 開始音頻情緒辨識，音頻大小: {len(audio_bytes)} bytes")
+
+            # 使用臨時檔案（emotion.predict() 需要檔案路徑）
+            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_file:
+                temp_path = temp_file.name
+
+                # 寫入 WAV 檔案
+                import wave
+                with wave.open(temp_path, 'wb') as wf:
+                    wf.setnchannels(1)
+                    wf.setsampwidth(2)  # 16-bit PCM
+                    wf.setframerate(sample_rate)
+                    wf.writeframes(audio_bytes)
+
+            try:
+                # 在執行緒池中執行（避免阻塞事件循環）
+                loop = asyncio.get_event_loop()
+                pred_id, confidence, all_emotions = await loop.run_in_executor(
+                    None,
+                    emotion_module.predict,
+                    temp_path
+                )
+
+                # 映射情緒標籤
+                raw_emotion = emotion_module.id2class(pred_id)
+                emotion = self.EMOTION_MAP.get(raw_emotion, "neutral")
+
+                # 轉換所有情緒置信度
+                normalized_emotions = {}
+                for raw_label, score_str in all_emotions.items():
+                    normalized_label = self.EMOTION_MAP.get(raw_label, raw_label)
+                    normalized_emotions[normalized_label] = float(score_str)
+
+                logger.info(f"✅ 音頻情緒辨識完成: {emotion} (置信度: {confidence:.4f})")
+
+                return {
+                    "success": True,
+                    "emotion": emotion,
+                    "confidence": float(confidence),
+                    "all_emotions": normalized_emotions,
+                    "source": "audio"
+                }
+
+            finally:
+                # 清理臨時檔案
+                try:
+                    os.unlink(temp_path)
+                except Exception:
+                    pass
+
+        except Exception as e:
+            logger.exception(f"❌ 音頻情緒辨識失敗: {e}")
+            return {
+                "success": False,
+                "emotion": "neutral",
+                "confidence": 0.0,
+                "error": str(e)
+            }
+
+
+# 全域單例
+audio_emotion_service = AudioEmotionService()
+
+
+async def predict_emotion_from_audio(
+    audio_bytes: bytes,
+    sample_rate: int = 16000
+) -> Dict[str, Any]:
+    """
+    便捷函數：從音頻預測情緒
+
+    Args:
+        audio_bytes: PCM16 音頻數據
+        sample_rate: 採樣率
+
+    Returns:
+        情緒辨識結果
+    """
+    return await audio_emotion_service.predict_from_bytes(audio_bytes, sample_rate)

services/realtime_stt_service.py

@@ -1,13 +1,15 @@
 """
 OpenAI Realtime API - 即時語音轉文字服務
 使用 WebSocket 進行低延遲串流轉錄
+
+支援語言：中文(zh)、英文(en)、印尼文(id)、日文(ja)、越南文(vi)
 """
 
 import os
 import json
 import asyncio
 import logging
-from typing import Optional, Callable, Dict, Any
+from typing import Optional, Callable, Dict, Any, Literal
 import websockets
 from dotenv import load_dotenv
 
@@ -22,6 +24,16 @@ if not OPENAI_API_KEY:
 # OpenAI Realtime API WebSocket URL
 REALTIME_API_URL = "wss://api.openai.com/v1/realtime?intent=transcription"
 
+# 支援的語言列表
+SupportedLanguage = Literal["zh", "en", "id", "ja", "vi"]
+SUPPORTED_LANGUAGES = {
+    "zh": "中文",
+    "en": "English",
+    "id": "Bahasa Indonesia",
+    "ja": "日本語",
+    "vi": "Tiếng Việt"
+}
+
 
 class RealtimeSTTService:
     """OpenAI Realtime API 即時語音轉文字服務"""
@@ -31,6 +43,58 @@ class RealtimeSTTService:
         self.ws: Optional[websockets.WebSocketClientProtocol] = None
         self.is_connected = False
         self._receive_task: Optional[asyncio.Task] = None
+        self.current_language: str = "zh"
+
+    def _build_language_prompt(self) -> str:
+        """
+        建立語言提示，引導 Whisper 優先識別支援的 5 種語言
+        
+        Whisper 的 prompt 參數可以包含：
+        - 多語言範例文字
+        - 引導模型識別特定語言
+        
+        Returns:
+            語言提示字串
+        """
+        # 使用多語言範例引導 Whisper（每種語言的常見詞彙）
+        prompt_samples = [
+            "你好",  # 中文
+            "Hello",  # 英文
+            "Halo",  # 印尼文
+            "こんにちは",  # 日文
+            "Xin chào"  # 越南文
+        ]
+        
+        return ", ".join(prompt_samples)
+    
+    def _validate_language(self, language: str) -> Optional[str]:
+        """
+        驗證並正規化語言代碼
+
+        Args:
+            language: 語言代碼（或 'auto' 表示自動檢測）
+
+        Returns:
+            正規化後的語言代碼，或 None（自動檢測）
+        """
+        lang = language.lower().strip()
+        
+        # 自動檢測模式
+        if lang in ('auto', 'detect', ''):
+            logger.info("🌐 啟用自動語言檢測")
+            return None
+        
+        if lang in SUPPORTED_LANGUAGES:
+            return lang
+        
+        # 嘗試從完整語言名稱匹配
+        for code, name in SUPPORTED_LANGUAGES.items():
+            if name.lower() == lang.lower():
+                return code
+        
+        # 不支援的語言，使用自動檢測
+        logger.warning(f"⚠️ 不支援的語言 '{language}'，改用自動檢測")
+        return None
 
     async def connect(
         self,
@@ -48,7 +112,7 @@ class RealtimeSTTService:
             on_transcript_done: 接收完整轉錄結果的回調函數
             on_vad_committed: VAD 偵測到語音結束的回調函數
             model: 使用的模型（gpt-4o-transcribe 或 gpt-4o-mini-transcribe）
-            language: 語言代碼
+            language: 語言代碼（zh/en/id/ja/vi）
 
         Returns:
             bool: 連線是否成功
@@ -57,6 +121,16 @@ class RealtimeSTTService:
             logger.error("❌ OpenAI API Key 未設置")
             return False
 
+        # 驗證語言
+        validated_language = self._validate_language(language)
+        self.current_language = validated_language or "auto"
+        
+        if validated_language:
+            language_name = SUPPORTED_LANGUAGES.get(validated_language, validated_language)
+            logger.info(f"🌐 語言設定: {language_name} ({validated_language})")
+        else:
+            logger.info("🌐 語言設定: 自動檢測（支援 zh/en/id/ja/vi）")
+
         try:
             logger.info(f"🔌 連接到 OpenAI Realtime API: {REALTIME_API_URL}")
 
@@ -72,27 +146,37 @@ class RealtimeSTTService:
             self.is_connected = True
             logger.info("✅ 已連接到 OpenAI Realtime API")
 
-            # 發送 session 配置（按照 Microsoft/Azure 官方範例）
+            # 建立語言提示（引導 Whisper 優先識別支援的 5 種語言）
+            language_prompt = self._build_language_prompt()
+            
+            # 發送 session 配置（正確格式：需要 session 物件包裹）
             session_config = {
                 "type": "transcription_session.update",
-                "session": {  # ← 關鍵：所有配置要包在 session 物件裡
+                "session": {
                     "input_audio_format": "pcm16",
                     "input_audio_transcription": {
                         "model": model,
-                        "prompt": "",
-                        "language": language
+                        "prompt": language_prompt  # 使用語言提示引導識別
+                        # 不指定 language，讓 Whisper 自動檢測（但透過 prompt 引導）
                     },
                     "turn_detection": {
                         "type": "server_vad",
                         "threshold": 0.5,
                         "prefix_padding_ms": 300,
                         "silence_duration_ms": 500
+                    },
+                    "input_audio_noise_reduction": {
+                        "type": "far_field"
                     }
                 }
             }
+            
+            # 如果指定了語言，則加入配置
+            if validated_language:
+                session_config["session"]["input_audio_transcription"]["language"] = validated_language
 
             await self.ws.send(json.dumps(session_config))
-            logger.info("📤 已發送 session 配置")
+            logger.info("📤 已發送 session 配置（含語言引導提示）")
 
             # 啟動接收事件的背景任務
             self._receive_task = asyncio.create_task(

services/stt_service.py

@@ -1,182 +0,0 @@
-"""
-OpenAI Whisper STT 服務
-使用 OpenAI Whisper API 進行語音轉文字
-"""
-
-import os
-import io
-import wave
-import logging
-import tempfile
-from typing import Optional, Dict, Any
-from openai import OpenAI
-from dotenv import load_dotenv
-
-load_dotenv()
-
-logger = logging.getLogger("services.stt")
-
-# OpenAI 配置
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-if not OPENAI_API_KEY:
-    logger.warning("⚠️ OPENAI_API_KEY 未設置")
-
-client = OpenAI(api_key=OPENAI_API_KEY) if OPENAI_API_KEY else None
-
-
-class STTService:
-    """OpenAI Whisper 語音轉文字服務"""
-
-    def __init__(self):
-        self.client = client
-        if not self.client:
-            logger.error("❌ OpenAI client 初始化失敗，請檢查 OPENAI_API_KEY")
-
-    async def transcribe(
-        self,
-        audio_data: bytes,
-        language: str = "zh",
-        prompt: Optional[str] = None,
-        stream: bool = False,
-        on_delta: Optional[callable] = None
-    ) -> Dict[str, Any]:
-        """
-        使用 Whisper API 將音頻轉文字
-
-        Args:
-            audio_data: 音頻數據（PCM16 raw bytes 或完整 WAV 文件）
-            language: 語言代碼（zh, en, ja, ko 等）
-            prompt: 提示詞（可選，幫助提高準確度）
-            stream: 是否啟用串流轉錄（邊轉邊發）
-            on_delta: 串流模式下的回調函數，接收部分轉錄結果
-
-        Returns:
-            {
-                "success": bool,
-                "text": str,  # 轉錄文字
-                "language": str,  # 偵測到的語言
-                "error": str  # 錯誤訊息（如果失敗）
-            }
-        """
-        if not self.client:
-            return {
-                "success": False,
-                "text": "",
-                "error": "OpenAI client 未初始化"
-            }
-
-        try:
-            logger.info(f"🎙️ 開始 STT 轉錄，音頻大小: {len(audio_data)} bytes")
-
-            # 檢查是否為原始 PCM 數據（沒有 WAV header）
-            # WAV 文件以 "RIFF" 開頭
-            is_raw_pcm = not audio_data.startswith(b'RIFF')
-            
-            if is_raw_pcm:
-                # 將 PCM16 數據轉換為 WAV 格式
-                logger.info("🔄 轉換 PCM16 → WAV 格式")
-                wav_buffer = io.BytesIO()
-                with wave.open(wav_buffer, 'wb') as wav_file:
-                    wav_file.setnchannels(1)  # 單聲道
-                    wav_file.setsampwidth(2)  # 16-bit = 2 bytes
-                    wav_file.setframerate(16000)  # 16kHz
-                    wav_file.writeframes(audio_data)
-                audio_data = wav_buffer.getvalue()
-
-            # 將音頻數據寫入臨時文件（Whisper API 需要文件路徑）
-            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_audio:
-                temp_audio.write(audio_data)
-                temp_audio_path = temp_audio.name
-
-            try:
-                # 調用 Whisper API
-                with open(temp_audio_path, "rb") as audio_file:
-                    transcript_params = {
-                        "model": "gpt-4o-mini-transcribe",  # 2025 最佳實踐：WER 提升 25%
-                        "file": audio_file,
-                        "language": language
-                    }
-
-                    # 如果提供提示詞，加入參數
-                    if prompt:
-                        transcript_params["prompt"] = prompt
-
-                    response = self.client.audio.transcriptions.create(**transcript_params)
-
-                # 提取轉錄文字
-                transcribed_text = response.text.strip()
-
-                logger.info(f"✅ STT 轉錄成功: {transcribed_text[:50]}...")
-
-                return {
-                    "success": True,
-                    "text": transcribed_text,
-                    "language": language
-                }
-
-            finally:
-                # 清理臨時文件
-                import os as os_module
-                if os_module.path.exists(temp_audio_path):
-                    os_module.remove(temp_audio_path)
-
-        except Exception as e:
-            logger.exception(f"❌ STT 轉錄失敗: {e}")
-            return {
-                "success": False,
-                "text": "",
-                "error": str(e)
-            }
-
-    async def transcribe_with_retry(
-        self,
-        audio_data: bytes,
-        language: str = "zh",
-        max_retries: int = 2
-    ) -> Dict[str, Any]:
-        """
-        帶重試機制的轉錄
-
-        Args:
-            audio_data: 音頻數據
-            language: 語言代碼
-            max_retries: 最大重試次數
-
-        Returns:
-            同 transcribe()
-        """
-        for attempt in range(max_retries + 1):
-            result = await self.transcribe(audio_data, language)
-
-            if result["success"]:
-                return result
-
-            if attempt < max_retries:
-                logger.warning(f"⚠️ STT 重試 {attempt + 1}/{max_retries}")
-            else:
-                logger.error("❌ STT 達到最大重試次數")
-
-        return result
-
-
-# 全域單例
-stt_service = STTService()
-
-
-async def transcribe_audio(audio_data: bytes, language: str = "zh") -> Dict[str, Any]:
-    """
-    便捷函數：轉錄音頻
-
-    Args:
-        audio_data: 音頻數據（bytes）
-        language: 語言代碼
-
-    Returns:
-        {
-            "success": bool,
-            "text": str,
-            "language": str,
-            "error": str (optional)
-        }
-    """
-    return await stt_service.transcribe_with_retry(audio_data, language)

services/tts_service.py

@@ -1,61 +1,129 @@
 """
-OpenAI TTS 服務
-使用 OpenAI Text-to-Speech API 進行文字轉語音
+OpenAI TTS 服務（2025 最佳實踐版）
+使用 AsyncOpenAI + Streaming 進行低延遲文字轉語音
+
+特色：
+- 異步 API（AsyncOpenAI）
+- 串流播放（邊生成邊播放，降低 TTFB）
+- 支援情緒指令（gpt-4o-mini-tts）
+- 多語言支援（自動檢測：中文、英文、印尼文、日文、越南文）
 """
 
 import os
 import logging
-from typing import Optional, Dict, Any, Literal
-from openai import OpenAI
+import asyncio
+from typing import Optional, Dict, Any, Literal, AsyncIterator
+from openai import AsyncOpenAI
+from openai.helpers import LocalAudioPlayer
 from dotenv import load_dotenv
 
+# 統一日誌配置
+from core.logging import get_logger
+logger = get_logger("services.tts")
+
+# 統一配置管理
+from core.config import settings
+
 load_dotenv()
 
-logger = logging.getLogger("services.tts")
+# 支援的 TTS 聲音（2025 新增：coral, sage, verse）
+VoiceType = Literal["coral", "sage", "verse", "alloy", "echo", "fable", "onyx", "nova", "shimmer"]
+
+# 支援的音頻格式
+AudioFormat = Literal["mp3", "opus", "aac", "flac", "wav", "pcm"]
 
-# OpenAI 配置
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-if not OPENAI_API_KEY:
-    logger.warning("⚠️ OPENAI_API_KEY 未設置")
+# 情緒指令預設模板
+EMOTION_INSTRUCTIONS = {
+    "neutral": "用平穩、自然的語氣說話",
+    "happy": "用開心、愉悅的語氣說話",
+    "sad": "用溫柔、安慰的語氣說話",
+    "angry": "用冷靜、理性的語氣說話",
+    "fear": "用溫暖、鼓勵的語氣說話",
+    "surprise": "用輕快、活潑的語氣說話"
+}
 
-client = OpenAI(api_key=OPENAI_API_KEY) if OPENAI_API_KEY else None
+# 關懷模式特殊指令
+CARE_MODE_INSTRUCTION = "用溫柔、關懷、陪伴的語氣說話，讓對方感受到被理解和支持"
 
-# 支援的 TTS 聲音
-VoiceType = Literal["alloy", "echo", "fable", "onyx", "nova", "shimmer"]
+
+def get_emotion_instruction(emotion: Optional[str], care_mode: bool = False) -> str:
+    """
+    根據情緒選擇對應的 TTS instruction
+
+    Args:
+        emotion: 情緒標籤（neutral, happy, sad, angry, fear, surprise）
+        care_mode: 是否為關懷模式
+
+    Returns:
+        TTS instruction 字串
+    """
+    # 關懷模式優先
+    if care_mode:
+        return CARE_MODE_INSTRUCTION
+    
+    # 根據情緒選擇
+    if emotion and emotion in EMOTION_INSTRUCTIONS:
+        return EMOTION_INSTRUCTIONS[emotion]
+    
+    # 預設中性語氣
+    return EMOTION_INSTRUCTIONS["neutral"]
 
 
 class TTSService:
-    """OpenAI Text-to-Speech 服務"""
+    """OpenAI Text-to-Speech 服務（異步版）"""
 
     def __init__(self):
-        self.client = client
-        if not self.client:
-            logger.error("❌ OpenAI client 初始化失敗，請檢查 OPENAI_API_KEY")
+        self._client: Optional[AsyncOpenAI] = None
+        self._initialized = False
+
+    @property
+    def client(self) -> Optional[AsyncOpenAI]:
+        """延遲初始化 AsyncOpenAI 客戶端"""
+        if not self._initialized:
+            api_key = settings.OPENAI_API_KEY
+            if api_key:
+                self._client = AsyncOpenAI(
+                    api_key=api_key,
+                    timeout=float(settings.OPENAI_TIMEOUT),
+                    max_retries=3
+                )
+                logger.info("✅ TTS 服務初始化成功（AsyncOpenAI）")
+            else:
+                logger.error("❌ TTS 服務初始化失敗：OPENAI_API_KEY 未設置")
+            self._initialized = True
+        return self._client
 
     async def synthesize(
         self,
         text: str,
-        voice: VoiceType = "nova",
+        voice: VoiceType = "coral",
         model: str = "gpt-4o-mini-tts",
         speed: float = 1.0,
-        instruction: Optional[str] = None
+        instruction: Optional[str] = None,
+        emotion: Optional[str] = None,
+        care_mode: bool = False,
+        response_format: AudioFormat = "mp3"
     ) -> Dict[str, Any]:
         """
-        使用 OpenAI TTS API 將文字轉語音（2025 最佳實踐：gpt-4o-mini-tts）
+        使用 OpenAI TTS API 將文字轉語音（非串流版）
 
         Args:
             text: 要轉換的文字
-            voice: 聲音類型（alloy, echo, fable, onyx, nova, shimmer）
+            voice: 聲音類型（coral, sage, verse, alloy, echo, fable, onyx, nova, shimmer）
             model: TTS 模型（gpt-4o-mini-tts 或 tts-1-hd）
             speed: 語速（0.25 到 4.0）
-            instruction: 語音指令（如「用溫柔、安慰的語氣說話」）
+            instruction: 語音指令（手動指定，優先級最高）
+            emotion: 情緒標籤（自動選擇 instruction）
+            care_mode: 是否為關懷模式（使用特殊語氣）
+            response_format: 音頻格式（mp3, opus, aac, flac, wav, pcm）
 
         Returns:
             {
                 "success": bool,
-                "audio_data": bytes,  # MP3 音頻數據
+                "audio_data": bytes,
                 "voice": str,
-                "error": str  # 錯誤訊息（如果失敗）
+                "format": str,
+                "error": str (optional)
             }
         """
         if not self.client:
@@ -73,16 +141,21 @@ class TTSService:
                 "model": model,
                 "voice": voice,
                 "input": text,
-                "speed": speed
+                "speed": speed,
+                "response_format": response_format
             }
 
+            # 選擇 instruction（優先級：手動 > 情緒自動選擇）
+            final_instruction = instruction or get_emotion_instruction(emotion, care_mode)
+            
             # 如果提供情緒指令（gpt-4o-mini-tts 支援）
-            if instruction and model == "gpt-4o-mini-tts":
-                params["instruction"] = instruction
+            if final_instruction and model == "gpt-4o-mini-tts":
+                params["instructions"] = final_instruction
+                logger.info(f"🎭 TTS 語氣指令: {final_instruction}")
 
-            response = self.client.audio.speech.create(**params)
+            response = await self.client.audio.speech.create(**params)
 
-            # 獲取音頻數據（MP3 格式）
+            # 獲取音頻數據
             audio_data = response.content
 
             logger.info(f"✅ TTS 合成成功，音頻大小: {len(audio_data)} bytes")
@@ -90,7 +163,8 @@ class TTSService:
             return {
                 "success": True,
                 "audio_data": audio_data,
-                "voice": voice
+                "voice": voice,
+                "format": response_format
             }
 
         except Exception as e:
@@ -101,6 +175,129 @@ class TTSService:
                 "error": str(e)
             }
 
+    async def synthesize_stream(
+        self,
+        text: str,
+        voice: VoiceType = "coral",
+        model: str = "gpt-4o-mini-tts",
+        speed: float = 1.0,
+        instruction: Optional[str] = None,
+        emotion: Optional[str] = None,
+        care_mode: bool = False,
+        response_format: AudioFormat = "pcm"
+    ) -> AsyncIterator[bytes]:
+        """
+        使用 OpenAI TTS API 串流生成語音（邊生成邊播放，低延遲）
+
+        Args:
+            text: 要轉換的文字
+            voice: 聲音類型
+            model: TTS 模型
+            speed: 語速
+            instruction: 語音指令（手動指定，優先級最高）
+            emotion: 情緒標籤（自動選擇 instruction）
+            care_mode: 是否為關懷模式
+            response_format: 音頻格式（建議用 pcm 以獲得最低延遲）
+
+        Yields:
+            bytes: 音頻數據塊
+        """
+        if not self.client:
+            logger.error("❌ OpenAI client 未初始化")
+            return
+
+        try:
+            logger.info(f"🔊 開始 TTS 串流合成，文字長度: {len(text)}, 聲音: {voice}")
+
+            # 調用 OpenAI TTS API（串流模式）
+            params = {
+                "model": model,
+                "voice": voice,
+                "input": text,
+                "speed": speed,
+                "response_format": response_format
+            }
+
+            # 選擇 instruction（優先級：手動 > 情緒自動選擇）
+            final_instruction = instruction or get_emotion_instruction(emotion, care_mode)
+            
+            if final_instruction and model == "gpt-4o-mini-tts":
+                params["instructions"] = final_instruction
+                logger.info(f"🎭 TTS 串流語氣指令: {final_instruction}")
+
+            async with self.client.audio.speech.with_streaming_response.create(**params) as response:
+                logger.info("✅ TTS 串流已啟動")
+                
+                # 逐塊產出音頻數據
+                async for chunk in response.iter_bytes(chunk_size=4096):
+                    if chunk:
+                        yield chunk
+
+                logger.info("✅ TTS 串流完成")
+
+        except Exception as e:
+            logger.exception(f"❌ TTS 串流失敗: {e}")
+
+    async def play_locally(
+        self,
+        text: str,
+        voice: VoiceType = "coral",
+        model: str = "gpt-4o-mini-tts",
+        speed: float = 1.0,
+        instruction: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        使用 LocalAudioPlayer 直接播放語音（本地測試用）
+
+        Args:
+            text: 要轉換的文字
+            voice: 聲音類型
+            model: TTS 模型
+            speed: 語速
+            instruction: 語音指令
+
+        Returns:
+            {
+                "success": bool,
+                "error": str (optional)
+            }
+        """
+        if not self.client:
+            return {
+                "success": False,
+                "error": "OpenAI client 未初始化"
+            }
+
+        try:
+            logger.info(f"🔊 開始本地播放，文字長度: {len(text)}, 聲音: {voice}")
+
+            params = {
+                "model": model,
+                "voice": voice,
+                "input": text,
+                "speed": speed,
+                "response_format": "pcm"
+            }
+
+            if instruction and model == "gpt-4o-mini-tts":
+                params["instructions"] = instruction
+
+            async with self.client.audio.speech.with_streaming_response.create(**params) as response:
+                await LocalAudioPlayer().play(response)
+
+            logger.info("✅ 本地播放完成")
+
+            return {
+                "success": True
+            }
+
+        except Exception as e:
+            logger.exception(f"❌ 本地播放失敗: {e}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
 
 # 全域單例
 tts_service = TTSService()
@@ -108,23 +305,77 @@ tts_service = TTSService()
 
 async def text_to_speech(
     text: str,
-    voice: VoiceType = "nova",
-    speed: float = 1.0
+    voice: VoiceType = "coral",
+    speed: float = 1.0,
+    instruction: Optional[str] = None
 ) -> Dict[str, Any]:
     """
-    便捷函數：將文字轉為語音
+    便捷函數：將文字轉為語音（非串流）
 
     Args:
         text: 要轉換的文字
-        voice: 聲音類型（alloy, echo, fable, onyx, nova, shimmer）
+        voice: 聲音類型（coral, sage, verse, alloy, echo, fable, onyx, nova, shimmer）
         speed: 語速（0.25 到 4.0）
+        instruction: 語音指令（如「用溫柔、安慰的語氣說話」）
 
     Returns:
         {
             "success": bool,
             "audio_data": bytes,
             "voice": str,
+            "format": str,
             "error": str (optional)
         }
     """
-    return await tts_service.synthesize(text, voice, speed=speed)
+    return await tts_service.synthesize(text, voice, speed=speed, instruction=instruction)
+
+
+async def text_to_speech_stream(
+    text: str,
+    voice: VoiceType = "coral",
+    speed: float = 1.0,
+    instruction: Optional[str] = None
+) -> AsyncIterator[bytes]:
+    """
+    便捷函數：將文字轉為語音（串流模式，低延遲）
+
+    Args:
+        text: 要轉換的文字
+        voice: 聲音類型
+        speed: 語速
+        instruction: 語音指令
+
+    Yields:
+        bytes: 音頻數據塊
+    """
+    async for chunk in tts_service.synthesize_stream(text, voice, speed=speed, instruction=instruction):
+        yield chunk
+
+
+async def test_tts_playback(
+    text: str = "今天是美好的一天！",
+    voice: VoiceType = "coral",
+    instruction: Optional[str] = "用開心、愉悅的語氣說話"
+) -> None:
+    """
+    快速測試 TTS 播放（使用 LocalAudioPlayer）
+
+    Args:
+        text: 要播放的文字
+        voice: 聲音類型
+        instruction: 語音指令
+    """
+    result = await tts_service.play_locally(text, voice=voice, instruction=instruction)
+    if result["success"]:
+        print(f"✅ 播放成功：{text}")
+    else:
+        print(f"❌ 播放失敗：{result.get('error')}")
+
+
+if __name__ == "__main__":
+    # 測試範例：播放中文語音
+    asyncio.run(test_tts_playback(
+        text="你好！我是 BloomWare 智能助手，很高興為你服務！",
+        voice="coral",
+        instruction="用溫暖、友善的語氣說話"
+    ))

static/frontend/js/app.js

@@ -76,7 +76,7 @@ async function checkLoginStatus() {
 /**
  * 初始化應用（登入後）
  */
-function initializeApp(token) {
+async function initializeApp(token) {
   console.log('🚀 初始化應用...');
 
   // 初始化各個模組的事件監聽器
@@ -92,12 +92,69 @@ function initializeApp(token) {
   // 同步 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') {
+      showErrorNotification('需要麥克風權限才能使用語音功能，請在瀏覽器設定中允許');
+    } else {
+      alert('需要麥克風權限才能使用語音功能，請在瀏覽器設定中允許');
+    }
+  }
+
+  // 2. 請求地理位置權限
+  if (navigator.geolocation) {
+    try {
+      console.log('📍 請求地理位置權限...');
+      await new Promise((resolve, reject) => {
+        navigator.geolocation.getCurrentPosition(
+          (position) => {
+            console.log('✅ 地理位置權限已授予');
+            resolve(position);
+          },
+          (error) => {
+            console.warn('⚠️ 地理位置權限被拒絕:', error);
+            reject(error);
+          },
+          { enableHighAccuracy: false, timeout: 10000, maximumAge: 0 }
+        );
+      });
+    } catch (error) {
+      console.warn('⚠️ 地理位置權限被拒絕，部分功能（如查詢附近公車）將無法使用');
+      if (typeof showErrorNotification === 'function') {
+        showErrorNotification('建議允許地理位置權限以使用完整功能（如查詢附近公車、天氣等）');
+      }
+    }
+  } else {
+    console.warn('⚠️ 此瀏覽器不支援地理位置功能');
+  }
+
+  console.log('✅ 權限請求完成');
+}
+
 // ========== 頁面初始化 ==========
 
 // 只在聊天室頁面（/static/）執行登入檢查

static/frontend/js/tools.js

@@ -4,6 +4,115 @@ const positions = ['pos-top-right', 'pos-top-left', 'pos-bottom-right', 'pos-bot
 let usedPositions = [];
 const MAX_CARDS = 4;
 
+// 多語言標籤定義
+const LABELS = {
+  zh: {
+    temperature: '溫度', condition: '狀況', humidity: '濕度', wind_speed: '風速',
+    weather: '天氣', city: '城市', description: '描述',
+    feels_like: '體感', pressure: '氣壓', sunrise: '日出', sunset: '日落',
+    heart_rate: '心率', step_count: '步數', oxygen_level: '血氧', respiratory_rate: '呼吸',
+    sleep_analysis: '睡眠', record_time: '記錄時間', average: '平均值',
+    no_news: '無新聞', no_data: '無數據', unknown: '未知',
+    exchange_rate: '匯率', conversion: '轉換', time: '時間',
+    train_type: '車種', origin_station: '起站', dest_station: '迄站',
+    departure: '出發', arrival: '抵達', duration: '行駛時間',
+    distance: '距離', walking_time: '步行時間', station: '車站',
+    available_bikes: '可借車輛', available_spaces: '可還空位',
+    bike_type: '類型', service_status: '服務狀態', operating: '營運中', suspended: '暫停服務',
+    location: '位置', coordinates: '座標', origin: '起點', destination: '目的地',
+    estimated_time: '預估時間', view_in_maps: '在 Google Maps 中查看',
+    line: '路線', address: '地址', road: '道路', area: '區域'
+  },
+  en: {
+    temperature: 'Temperature', condition: 'Condition', humidity: 'Humidity', wind_speed: 'Wind Speed',
+    weather: 'Weather', city: 'City', description: 'Description',
+    feels_like: 'Feels Like', pressure: 'Pressure', sunrise: 'Sunrise', sunset: 'Sunset',
+    heart_rate: 'Heart Rate', step_count: 'Steps', oxygen_level: 'Oxygen', respiratory_rate: 'Respiratory',
+    sleep_analysis: 'Sleep', record_time: 'Record Time', average: 'Average',
+    no_news: 'No News', no_data: 'No Data', unknown: 'Unknown',
+    exchange_rate: 'Exchange Rate', conversion: 'Conversion', time: 'Time',
+    train_type: 'Train Type', origin_station: 'Origin', dest_station: 'Destination',
+    departure: 'Departure', arrival: 'Arrival', duration: 'Duration',
+    distance: 'Distance', walking_time: 'Walking Time', station: 'Station',
+    available_bikes: 'Available Bikes', available_spaces: 'Available Spaces',
+    bike_type: 'Type', service_status: 'Service Status', operating: 'Operating', suspended: 'Suspended',
+    location: 'Location', coordinates: 'Coordinates', origin: 'Origin', destination: 'Destination',
+    estimated_time: 'Estimated Time', view_in_maps: 'View in Google Maps',
+    line: 'Line', address: 'Address', road: 'Road', area: 'Area'
+  },
+  ko: {
+    temperature: '온도', condition: '상태', humidity: '습도', wind_speed: '풍속',
+    weather: '날씨', city: '도시', description: '설명',
+    feels_like: '체감', pressure: '기압', sunrise: '일출', sunset: '일몰',
+    heart_rate: '심박수', step_count: '걸음 수', oxygen_level: '혈중 산소', respiratory_rate: '호흡',
+    sleep_analysis: '수면', record_time: '기록 시간', average: '평균',
+    no_news: '뉴스 없음', no_data: '데이터 없음', unknown: '알 수 없음',
+    exchange_rate: '환율', conversion: '환전', time: '시간',
+    train_type: '열차 종류', origin_station: '출발역', dest_station: '도착역',
+    departure: '출발', arrival: '도착', duration: '소요 시간',
+    distance: '거리', walking_time: '도보 시간', station: '역',
+    available_bikes: '대여 가능', available_spaces: '반납 가능',
+    bike_type: '유형', service_status: '서비스 상태', operating: '운영 중', suspended: '일시 중단',
+    location: '위치', coordinates: '좌표', origin: '출발지', destination: '목적지',
+    estimated_time: '예상 시간', view_in_maps: 'Google Maps에서 보기',
+    line: '노선', address: '주소', road: '도로', area: '지역'
+  },
+  ja: {
+    temperature: '気温', condition: '状況', humidity: '湿度', wind_speed: '風速',
+    weather: '天気', city: '都市', description: '説明',
+    feels_like: '体感', pressure: '気圧', sunrise: '日の出', sunset: '日の入り',
+    heart_rate: '心拍数', step_count: '歩数', oxygen_level: '血中酸素', respiratory_rate: '呼吸',
+    sleep_analysis: '睡眠', record_time: '記録時刻', average: '平均',
+    no_news: 'ニュースなし', no_data: 'データなし', unknown: '不明',
+    exchange_rate: '為替レート', conversion: '換算', time: '時刻',
+    train_type: '列車種別', origin_station: '出発駅', dest_station: '到着駅',
+    departure: '出発', arrival: '到着', duration: '所要時間',
+    distance: '距離', walking_time: '徒歩時間', station: '駅',
+    available_bikes: '利用可能', available_spaces: '返却可能',
+    bike_type: 'タイプ', service_status: 'サービス状態', operating: '運行中', suspended: '一時停止',
+    location: '場所', coordinates: '座標', origin: '出発地', destination: '目的地',
+    estimated_time: '予想時間', view_in_maps: 'Google Mapsで見る',
+    line: '路線', address: '住所', road: '道路', area: 'エリア'
+  },
+  id: {
+    temperature: 'Suhu', condition: 'Kondisi', humidity: 'Kelembaban', wind_speed: 'Kecepatan Angin',
+    weather: 'Cuaca', city: 'Kota', description: 'Deskripsi',
+    feels_like: 'Terasa', pressure: 'Tekanan', sunrise: 'Matahari Terbit', sunset: 'Matahari Terbenam',
+    heart_rate: 'Detak Jantung', step_count: 'Langkah', oxygen_level: 'Oksigen', respiratory_rate: 'Pernapasan',
+    sleep_analysis: 'Tidur', record_time: 'Waktu Rekam', average: 'Rata-rata',
+    no_news: 'Tidak Ada Berita', no_data: 'Tidak Ada Data', unknown: 'Tidak Diketahui',
+    exchange_rate: 'Nilai Tukar', conversion: 'Konversi', time: 'Waktu',
+    train_type: 'Jenis Kereta', origin_station: 'Stasiun Asal', dest_station: 'Stasiun Tujuan',
+    departure: 'Keberangkatan', arrival: 'Kedatangan', duration: 'Durasi',
+    distance: 'Jarak', walking_time: 'Waktu Jalan', station: 'Stasiun',
+    available_bikes: 'Sepeda Tersedia', available_spaces: 'Tempat Tersedia',
+    bike_type: 'Tipe', service_status: 'Status Layanan', operating: 'Beroperasi', suspended: 'Ditangguhkan',
+    location: 'Lokasi', coordinates: 'Koordinat', origin: 'Asal', destination: 'Tujuan',
+    estimated_time: 'Waktu Estimasi', view_in_maps: 'Lihat di Google Maps',
+    line: 'Jalur', address: 'Alamat', road: 'Jalan', area: 'Area'
+  },
+  vi: {
+    temperature: 'Nhiệt độ', condition: 'Tình trạng', humidity: 'Độ ẩm', wind_speed: 'Tốc độ gió',
+    weather: 'Thời tiết', city: 'Thành phố', description: 'Mô tả',
+    feels_like: 'Cảm giác', pressure: 'Áp suất', sunrise: 'Mặt trời mọc', sunset: 'Mặt trời lặn',
+    heart_rate: 'Nhịp tim', step_count: 'Số bước', oxygen_level: 'Oxy', respiratory_rate: 'Hô hấp',
+    sleep_analysis: 'Giấc ngủ', record_time: 'Thời gian ghi', average: 'Trung bình',
+    no_news: 'Không có tin', no_data: 'Không có dữ liệu', unknown: 'Không rõ',
+    exchange_rate: 'Tỷ giá', conversion: 'Chuyển đổi', time: 'Thời gian',
+    train_type: 'Loại tàu', origin_station: 'Ga đi', dest_station: 'Ga đến',
+    departure: 'Khởi hành', arrival: 'Đến', duration: 'Thời gian di chuyển',
+    distance: 'Khoảng cách', walking_time: 'Thời gian đi bộ', station: 'Ga',
+    available_bikes: 'Xe có sẵn', available_spaces: 'Chỗ trống',
+    bike_type: 'Loại', service_status: 'Trạng thái dịch vụ', operating: 'Hoạt động', suspended: 'Tạm ngừng',
+    location: 'Vị trí', coordinates: 'Tọa độ', origin: 'Điểm đi', destination: 'Điểm đến',
+    estimated_time: 'Thời gian ước tính', view_in_maps: 'Xem trên Google Maps',
+    line: 'Tuyến', address: 'Địa chỉ', road: 'Đường', area: 'Khu vực'
+  }
+};
+
+// 當前語言（從用戶訊息自動檢測）
+let currentLanguage = 'zh';
+
 // 抽屜相關元素
 let toolDrawer = null;
 let toolDrawerToggle = null;
@@ -488,6 +597,7 @@ function renderWeatherData(data) {
   const weather = data.weather?.[0] || {};
   const wind = data.wind || {};
   const sys = data.sys || {};
+  const labels = LABELS[currentLanguage] || LABELS.zh;
   
   // 格式化時間
   const formatTime = (timestamp) => {
@@ -498,35 +608,35 @@ function renderWeatherData(data) {
   
   return `
     <div class="data-row">
-      <span class="data-label">🌡️ 溫度</span>
+      <span class="data-label">🌡️ ${labels.temperature}</span>
       <span class="data-value">${main.temp?.toFixed(1) || '--'}°C</span>
     </div>
     <div class="data-row">
-      <span class="data-label">🤔 體感</span>
+      <span class="data-label">🤔 ${labels.feels_like}</span>
       <span class="data-value">${main.feels_like?.toFixed(1) || '--'}°C</span>
     </div>
     <div class="data-row">
-      <span class="data-label">☁️ 狀況</span>
+      <span class="data-label">☁️ ${labels.condition}</span>
       <span class="data-value">${weather.description || '--'}</span>
     </div>
     <div class="data-row">
-      <span class="data-label">💧 濕度</span>
+      <span class="data-label">💧 ${labels.humidity}</span>
       <span class="data-value">${main.humidity || '--'}%</span>
     </div>
     <div class="data-row">
-      <span class="data-label">🌪️ 風速</span>
+      <span class="data-label">🌪️ ${labels.wind_speed}</span>
       <span class="data-value">${wind.speed?.toFixed(1) || '--'} m/s</span>
     </div>
     <div class="data-row">
-      <span class="data-label">📊 氣壓</span>
+      <span class="data-label">📊 ${labels.pressure}</span>
       <span class="data-value">${main.pressure || '--'} hPa</span>
     </div>
     <div class="data-row">
-      <span class="data-label">🌅 日出</span>
+      <span class="data-label">🌅 ${labels.sunrise}</span>
       <span class="data-value">${formatTime(sys.sunrise)}</span>
     </div>
     <div class="data-row">
-      <span class="data-label">🌇 日落</span>
+      <span class="data-label">🌇 ${labels.sunset}</span>
       <span class="data-value">${formatTime(sys.sunset)}</span>
     </div>
   `;
@@ -536,21 +646,15 @@ function renderWeatherData(data) {
  * 渲染健康指標
  */
 function renderHealthMetrics(healthData) {
+  const labels = LABELS[currentLanguage] || LABELS.zh;
+  
   if (!healthData || healthData.length === 0) {
-    return '<p class="data-row">無健康數據</p>';
+    return `<p class="data-row">${labels.no_data}</p>`;
   }
 
-  const metricNames = {
-    heart_rate: '❤️ 心率',
-    step_count: '👟 步數',
-    oxygen_level: '🫁 血氧',
-    respiratory_rate: '💨 呼吸',
-    sleep_analysis: '😴 睡眠'
-  };
-
   const metricIcons = {
     heart_rate: '❤️',
-    step_count: '👟',
+    step_count: '�',
     oxygen_level: '🫁',
     respiratory_rate: '💨',
     sleep_analysis: '😴'
@@ -571,7 +675,7 @@ function renderHealthMetrics(healthData) {
   // 渲染每種指標
   Object.entries(grouped).forEach(([metric, items], index) => {
     const icon = metricIcons[metric] || '📊';
-    const label = metricNames[metric]?.replace(/^.+\s/, '') || metric;
+    const label = labels[metric] || metric;
     const latestItem = items[0]; // 最新的數據
     const value = latestItem.value;
     const unit = latestItem.unit || '';
@@ -600,13 +704,13 @@ function renderHealthMetrics(healthData) {
         </div>
         ${timeStr ? `
         <div class="data-row" style="opacity: 0.7;">
-          <span class="data-label" style="font-size: 0.85em;">記錄時間</span>
+          <span class="data-label" style="font-size: 0.85em;">${labels.record_time}</span>
           <span class="data-value" style="font-size: 0.85em;">${timeStr}</span>
         </div>
         ` : ''}
         ${items.length > 1 ? `
         <div class="data-row" style="opacity: 0.6;">
-          <span class="data-label" style="font-size: 0.8em;">平均值</span>
+          <span class="data-label" style="font-size: 0.8em;">${labels.average}</span>
           <span class="data-value" style="font-size: 0.8em;">${(items.reduce((sum, i) => sum + i.value, 0) / items.length).toFixed(1)} ${unit}</span>
         </div>
         ` : ''}
@@ -622,32 +726,35 @@ function renderHealthMetrics(healthData) {
  * 渲染新聞列表
  */
 function renderNewsList(articles) {
+  const labels = LABELS[currentLanguage] || LABELS.zh;
   let html = '';
   articles.slice(0, 3).forEach(article => {
     html += `
       <div class="data-row" style="flex-direction: column; align-items: flex-start; margin-bottom: 10px;">
-        <span class="data-label" style="font-weight: bold;">${article.title || '無標題'}</span>
+        <span class="data-label" style="font-weight: bold;">${article.title || labels.unknown}</span>
         <span class="data-value" style="font-size: 0.85em; opacity: 0.8;">${article.source?.name || article.source || ''}</span>
       </div>
     `;
   });
 
-  return html || '<p>無新聞</p>';
+  return html || `<p>${labels.no_news}</p>`;
 }
 
 /**
  * 渲染鍵值對（天氣等）
  */
 function renderKeyValuePairs(data) {
+  // 使用當前語言的標籤
+  const labels = LABELS[currentLanguage] || LABELS.zh;
   const keyMap = {
-    city: '城市',
-    temp: '溫度',
-    temperature: '溫度',
-    condition: '狀況',
-    weather: '天氣',
-    humidity: '濕度',
-    wind_speed: '風速',
-    description: '描述'
+    city: labels.city,
+    temp: labels.temperature,
+    temperature: labels.temperature,
+    condition: labels.condition,
+    weather: labels.weather,
+    humidity: labels.humidity,
+    wind_speed: labels.wind_speed,
+    description: labels.description
   };
 
   let html = '';
@@ -680,6 +787,7 @@ function renderKeyValuePairs(data) {
  * 渲染匯率信息
  */
 function renderExchangeRate(data) {
+  const labels = LABELS[currentLanguage] || LABELS.zh;
   const currencySymbols = {
     "USD": "$", "TWD": "NT$", "JPY": "¥", "EUR": "€", 
     "GBP": "£", "CNY": "¥", "KRW": "₩", "HKD": "HK$"
@@ -696,7 +804,7 @@ function renderExchangeRate(data) {
   if (data.rate !== undefined) {
     html += `
       <div class="data-row">
-        <span class="data-label">💰 匯率</span>
+        <span class="data-label">💰 ${labels.exchange_rate}</span>
         <span class="data-value">1 ${fromCurrency} = ${data.rate.toFixed(4)} ${toCurrency}</span>
       </div>
     `;
@@ -706,7 +814,7 @@ function renderExchangeRate(data) {
   if (data.amount && data.converted_amount !== undefined) {
     html += `
       <div class="data-row">
-        <span class="data-label">🔄 轉換</span>
+        <span class="data-label">🔄 ${labels.conversion}</span>
         <span class="data-value">${fromSymbol}${data.amount.toFixed(2)} = ${toSymbol}${data.converted_amount.toFixed(2)}</span>
       </div>
     `;
@@ -717,54 +825,56 @@ function renderExchangeRate(data) {
     const time = new Date(data.raw_data.metadata.timestamp).toLocaleString('zh-TW');
     html += `
       <div class="data-row">
-        <span class="data-label">⏰ 時間</span>
+        <span class="data-label">⏰ ${labels.time}</span>
         <span class="data-value">${time}</span>
       </div>
     `;
   }
 
-  return html || '<p>無匯率數據</p>';
+  return html || `<p>${labels.no_data}</p>`;
 }
 
 /**
  * 渲染火車列車資訊
  */
 function renderTrainList(trains) {
+  const labels = LABELS[currentLanguage] || LABELS.zh;
+  
   if (!trains || trains.length === 0) {
-    return '<p class="data-row">查無列車資訊</p>';
+    return `<p class="data-row">${labels.no_data}</p>`;
   }
 
   let html = '<div class="train-list">';
 
   trains.forEach((train, index) => {
-    const trainType = train.train_type || '未知';
+    const trainType = train.train_type || labels.unknown;
     const trainNo = train.train_no || '---';
     const departTime = train.departure_time ? train.departure_time.substring(0, 5) : '--:--';
     const arriveTime = train.arrival_time ? train.arrival_time.substring(0, 5) : '--:--';
-    const duration = train.duration_min ? `${train.duration_min}分鐘` : '未知';
-    const originStation = train.origin_station || '未知';
-    const destStation = train.destination_station || '未知';
+    const durationText = train.duration_min ? `${train.duration_min}${currentLanguage === 'zh' ? '分鐘' : currentLanguage === 'en' ? ' min' : currentLanguage === 'ko' ? '분' : currentLanguage === 'ja' ? '分' : currentLanguage === 'id' ? ' menit' : ' phút'}` : labels.unknown;
+    const originStation = train.origin_station || labels.unknown;
+    const destStation = train.destination_station || labels.unknown;
 
     html += `
       <div class="train-item" style="border-bottom: 1px solid #eee; padding: 12px 0; ${index === trains.length - 1 ? 'border-bottom: none;' : ''}">
         <div class="data-row" style="margin-bottom: 8px;">
-          <span class="data-label" style="font-weight: bold; color: #0066cc;">🚂 ${trainType} ${trainNo}次</span>
+          <span class="data-label" style="font-weight: bold; color: #0066cc;">🚂 ${trainType} ${trainNo}</span>
         </div>
         <div class="data-row">
-          <span class="data-label">📍 起訖站</span>
+          <span class="data-label">📍 ${labels.origin_station} → ${labels.dest_station}</span>
           <span class="data-value">${originStation} → ${destStation}</span>
         </div>
         <div class="data-row">
-          <span class="data-label">⏰ 出發</span>
+          <span class="data-label">⏰ ${labels.departure}</span>
           <span class="data-value">${departTime}</span>
         </div>
         <div class="data-row">
-          <span class="data-label">⏱️ 抵達</span>
+          <span class="data-label">⏱️ ${labels.arrival}</span>
           <span class="data-value">${arriveTime}</span>
         </div>
         <div class="data-row">
-          <span class="data-label">🕐 行駛時間</span>
-          <span class="data-value">${duration}</span>
+          <span class="data-label">🕐 ${labels.duration}</span>
+          <span class="data-value">${durationText}</span>
         </div>
       </div>
     `;
@@ -778,16 +888,19 @@ function renderTrainList(trains) {
  * 渲染火車站點資訊
  */
 function renderTrainStations(stations) {
+  const labels = LABELS[currentLanguage] || LABELS.zh;
+  
   if (!stations || stations.length === 0) {
-    return '<p class="data-row">查無車站資訊</p>';
+    return `<p class="data-row">${labels.no_data}</p>`;
   }
 
   let html = '<div class="station-list">';
 
   stations.forEach((station, index) => {
-    const stationName = station.station_name || station.name || '未知車站';
-    const distance = station.distance_m ? `${Math.round(station.distance_m)}公尺` : '';
-    const walkTime = station.walking_time_min ? `步行約${station.walking_time_min}分鐘` : '';
+    const stationName = station.station_name || station.name || labels.unknown;
+    const distanceUnit = currentLanguage === 'zh' ? '公尺' : currentLanguage === 'en' ? 'm' : currentLanguage === 'ko' ? '미터' : currentLanguage === 'ja' ? 'メートル' : currentLanguage === 'id' ? 'm' : 'm';
+    const distance = station.distance_m ? `${Math.round(station.distance_m)}${distanceUnit}` : '';
+    const walkTimeText = station.walking_time_min ? `${currentLanguage === 'zh' ? '步行約' : ''}${station.walking_time_min}${currentLanguage === 'zh' ? '分鐘' : currentLanguage === 'en' ? ' min walk' : currentLanguage === 'ko' ? '분 도보' : currentLanguage === 'ja' ? '分 徒歩' : currentLanguage === 'id' ? ' menit jalan' : ' phút đi bộ'}` : '';
 
     html += `
       <div class="station-item" style="border-bottom: 1px solid #eee; padding: 12px 0; ${index === stations.length - 1 ? 'border-bottom: none;' : ''}">
@@ -796,14 +909,14 @@ function renderTrainStations(stations) {
         </div>
         ${distance ? `
         <div class="data-row">
-          <span class="data-label">📏 距離</span>
+          <span class="data-label">📏 ${labels.distance}</span>
           <span class="data-value">${distance}</span>
         </div>
         ` : ''}
-        ${walkTime ? `
+        ${walkTimeText ? `
         <div class="data-row">
-          <span class="data-label">🚶 步行時間</span>
-          <span class="data-value">${walkTime}</span>
+          <span class="data-label">🚶 ${labels.walking_time}</span>
+          <span class="data-value">${walkTimeText}</span>
         </div>
         ` : ''}
       </div>
@@ -818,29 +931,34 @@ function renderTrainStations(stations) {
  * 渲染 YouBike 站點資訊
  */
 function renderYouBikeStations(stations) {
+  const labels = LABELS[currentLanguage] || LABELS.zh;
+  
   if (!stations || stations.length === 0) {
-    return '<p class="data-row">附近無 YouBike 站點</p>';
+    return `<p class="data-row">${labels.no_data}</p>`;
   }
 
   let html = '<div class="youbike-list">';
 
   stations.forEach((station, index) => {
-    const stationName = station.station_name || '未知站點';
+    const stationName = station.station_name || labels.unknown;
     const availableBikes = station.available_bikes ?? 0;
     const availableSpaces = station.available_spaces ?? 0;
     const distance = station.distance_m || 0;
     const walkingTime = station.walking_time_min || 0;
     const bikeType = station.bike_type || 'YouBike';
-    const serviceStatus = station.service_status === 1 ? '營運中' : '暫停服務';
+    const serviceStatus = station.service_status === 1 ? labels.operating : labels.suspended;
+    const walkText = currentLanguage === 'zh' ? `步行約 ${walkingTime} 分鐘` : currentLanguage === 'en' ? `${walkingTime} min walk` : currentLanguage === 'ko' ? `도보 ${walkingTime}분` : currentLanguage === 'ja' ? `徒歩${walkingTime}分` : currentLanguage === 'id' ? `${walkingTime} menit jalan` : `${walkingTime} phút đi bộ`;
+    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 bikeStatusColor = '#e74c3c';
     let bikeStatusIcon = '🚫';
     if (availableBikes > 3) {
-      bikeStatusColor = '#27ae60'; // 綠色
+      bikeStatusColor = '#27ae60';
       bikeStatusIcon = '✅';
     } else if (availableBikes > 0) {
-      bikeStatusColor = '#f39c12'; // 橘色
+      bikeStatusColor = '#f39c12';
       bikeStatusIcon = '⚠️';
     }
 
@@ -850,19 +968,19 @@ function renderYouBikeStations(stations) {
           <span class="data-label" style="font-weight: bold; color: #e67e22;">🚲 ${stationName}</span>
         </div>
         <div class="data-row">
-          <span class="data-label">📍 距離</span>
-          <span class="data-value">${distance}m (步行約 ${walkingTime} 分鐘)</span>
+          <span class="data-label">📍 ${labels.distance}</span>
+          <span class="data-value">${distance}m (${walkText})</span>
         </div>
         <div class="data-row">
-          <span class="data-label">🚴 可借車輛</span>
-          <span class="data-value" style="color: ${bikeStatusColor}; font-weight: bold;">${bikeStatusIcon} ${availableBikes} 輛</span>
+          <span class="data-label">🚴 ${labels.available_bikes}</span>
+          <span class="data-value" style="color: ${bikeStatusColor}; font-weight: bold;">${bikeStatusIcon} ${availableBikes} ${bikeUnit}</span>
         </div>
         <div class="data-row">
-          <span class="data-label">🅿️ 可還空位</span>
-          <span class="data-value">${availableSpaces} 個</span>
+          <span class="data-label">🅿️ ${labels.available_spaces}</span>
+          <span class="data-value">${availableSpaces} ${spaceUnit}</span>
         </div>
         <div class="data-row">
-          <span class="data-label">ℹ️ 類型</span>
+          <span class="data-label">ℹ️ ${labels.bike_type}</span>
           <span class="data-value">${bikeType} (${serviceStatus})</span>
         </div>
       </div>
@@ -877,8 +995,10 @@ function renderYouBikeStations(stations) {
  * 渲染公車到站資訊
  */
 function renderBusArrivals(arrivals, routeName) {
+  const labels = LABELS[currentLanguage] || LABELS.zh;
+  
   if (!arrivals || arrivals.length === 0) {
-    return '<p>目前無到站資訊</p>';
+    return `<p>${labels.no_data}</p>`;
   }
 
   let html = '';
@@ -886,7 +1006,7 @@ function renderBusArrivals(arrivals, routeName) {
   // 按站點分組
   const stopGroups = {};
   arrivals.forEach(arr => {
-    const stopName = arr.stop_name || '未知站點';
+    const stopName = arr.stop_name || labels.unknown;
     if (!stopGroups[stopName]) {
       stopGroups[stopName] = [];
     }
@@ -907,11 +1027,11 @@ function renderBusArrivals(arrivals, routeName) {
     `;
     
     stopArrivals.forEach(arr => {
-      const direction = arr.direction === 0 ? '往 ↑' : '返 ↓';
-      const status = arr.status || '未知';
+      const directionText = arr.direction === 0 ? (currentLanguage === 'zh' ? '往 ↑' : currentLanguage === 'en' ? 'To ↑' : currentLanguage === 'ko' ? '방향 ↑' : currentLanguage === 'ja' ? '行き ↑' : currentLanguage === 'id' ? 'Ke ↑' : 'Đến ↑') : (currentLanguage === 'zh' ? '返 ↓' : currentLanguage === 'en' ? 'Return ↓' : currentLanguage === 'ko' ? '회차 ↓' : currentLanguage === 'ja' ? '戻り ↓' : currentLanguage === 'id' ? 'Kembali ↓' : 'Về ↓');
+      const status = arr.status || labels.unknown;
       html += `
         <div style="display: flex; justify-content: space-between; width: 100%; padding: 2px 0;">
-          <span style="font-size: 0.9em; opacity: 0.8;">${direction}</span>
+          <span style="font-size: 0.9em; opacity: 0.8;">${directionText}</span>
           <span class="data-value" style="font-size: 0.9em;">${status}</span>
         </div>
       `;
@@ -927,7 +1047,8 @@ function renderBusArrivals(arrivals, routeName) {
  * 渲染地理反查資訊（reverse_geocode）
  */
 function renderReverseGeocode(data) {
-  const displayName = data.display_name || '未知地點';
+  const labels = LABELS[currentLanguage] || LABELS.zh;
+  const displayName = data.display_name || labels.unknown;
   const city = data.city || '';
   const road = data.road || '';
   const houseNumber = data.house_number || '';
@@ -952,34 +1073,34 @@ function renderReverseGeocode(data) {
 
   return `
     <div class="data-row">
-      <span class="data-label">📍 位置</span>
+      <span class="data-label">📍 ${labels.location}</span>
       <span class="data-value" style="font-weight: bold;">${displayName}</span>
     </div>
     ${city ? `
     <div class="data-row">
-      <span class="data-label">🏙️ 城市</span>
+      <span class="data-label">🏙️ ${labels.city}</span>
       <span class="data-value">${city}</span>
     </div>
     ` : ''}
     ${road ? `
     <div class="data-row">
-      <span class="data-label">🛣️ 道路</span>
+      <span class="data-label">🛣️ ${labels.road}</span>
       <span class="data-value">${road}${houseNumber ? ' ' + houseNumber : ''}</span>
     </div>
     ` : ''}
     ${suburb ? `
     <div class="data-row">
-      <span class="data-label">🏘️ 區域</span>
+      <span class="data-label">🏘️ ${labels.area}</span>
       <span class="data-value">${suburb}</span>
     </div>
     ` : ''}
     <div class="data-row">
-      <span class="data-label">🌐 座標</span>
+      <span class="data-label">🌐 ${labels.coordinates}</span>
       <span class="data-value" style="font-size: 0.85em;">${lat}, ${lon}</span>
     </div>
     <div class="data-row" style="margin-top: 8px;">
       <a href="${mapsUrl}" target="_blank" style="color: #0066cc; text-decoration: none; font-size: 0.9em;">
-        🗺️ 在 Google Maps 中查看 →
+        🗺️ ${labels.view_in_maps} →
       </a>
     </div>
   `;
@@ -989,21 +1110,23 @@ function renderReverseGeocode(data) {
  * 渲染附近公車站點
  */
 function renderNearbyStops(stops) {
+  const labels = LABELS[currentLanguage] || LABELS.zh;
+  
   if (!stops || stops.length === 0) {
-    return '<p>附近沒有公車站</p>';
+    return `<p>${labels.no_data}</p>`;
   }
 
   let html = '';
   stops.slice(0, 5).forEach((stop, index) => {
-    const stopName = stop.stop_name || '未知站點';
+    const stopName = stop.stop_name || labels.unknown;
     const distance = stop.distance_m ? `${Math.round(stop.distance_m)}m` : '';
-    const walkTime = stop.walking_time_min ? `步行 ${stop.walking_time_min} 分` : '';
+    const walkTimeText = stop.walking_time_min ? `${currentLanguage === 'zh' ? '步行 ' : ''}${stop.walking_time_min}${currentLanguage === 'zh' ? ' 分' : currentLanguage === 'en' ? ' min walk' : currentLanguage === 'ko' ? '분 도보' : currentLanguage === 'ja' ? '分 徒歩' : currentLanguage === 'id' ? ' menit jalan' : ' phút đi bộ'}` : '';
     
     html += `
       <div class="data-row" style="margin-bottom: 8px;">
         <div style="flex: 1;">
           <div style="font-weight: 600; margin-bottom: 2px;">🚏 ${stopName}</div>
-          <div style="font-size: 0.85em; opacity: 0.7;">${walkTime} ${distance ? `(${distance})` : ''}</div>
+          <div style="font-size: 0.85em; opacity: 0.7;">${walkTimeText} ${distance ? `(${distance})` : ''}</div>
         </div>
       </div>
     `;
@@ -1016,17 +1139,22 @@ function renderNearbyStops(stops) {
  * 渲染導航路線（directions）
  */
 function renderDirections(data) {
-  const originLabel = data.origin_label || '起點';
-  const destLabel = data.dest_label || '目的地';
+  const labels = LABELS[currentLanguage] || LABELS.zh;
+  const originLabel = data.origin_label || labels.origin;
+  const destLabel = data.dest_label || labels.destination;
   const distanceM = data.distance_m;
   const durationS = data.duration_s;
   
   // 格式化距離
   let distanceStr = '--';
   if (distanceM !== undefined) {
-    distanceStr = distanceM >= 1000 
-      ? `${(distanceM / 1000).toFixed(1)} 公里` 
-      : `${Math.round(distanceM)} 公尺`;
+    if (distanceM >= 1000) {
+      const kmUnit = currentLanguage === 'zh' ? '公里' : currentLanguage === 'en' ? ' km' : currentLanguage === 'ko' ? '킬로미터' : currentLanguage === 'ja' ? 'キロ' : currentLanguage === 'id' ? ' km' : ' km';
+      distanceStr = `${(distanceM / 1000).toFixed(1)}${kmUnit}`;
+    } else {
+      const mUnit = currentLanguage === 'zh' ? '公尺' : currentLanguage === 'en' ? ' m' : currentLanguage === 'ko' ? '미터' : currentLanguage === 'ja' ? 'メートル' : currentLanguage === 'id' ? ' m' : ' m';
+      distanceStr = `${Math.round(distanceM)}${mUnit}`;
+    }
   }
   
   // 格式化時間
@@ -1036,9 +1164,12 @@ function renderDirections(data) {
     if (minutes >= 60) {
       const hours = Math.floor(minutes / 60);
       const mins = minutes % 60;
-      durationStr = mins > 0 ? `${hours} 小時 ${mins} 分鐘` : `${hours} 小時`;
+      const hourUnit = currentLanguage === 'zh' ? '小時' : currentLanguage === 'en' ? ' hr' : currentLanguage === 'ko' ? '시간' : currentLanguage === 'ja' ? '時間' : currentLanguage === 'id' ? ' jam' : ' giờ';
+      const minUnit = currentLanguage === 'zh' ? '分鐘' : currentLanguage === 'en' ? ' min' : currentLanguage === 'ko' ? '분' : currentLanguage === 'ja' ? '分' : currentLanguage === 'id' ? ' menit' : ' phút';
+      durationStr = mins > 0 ? `${hours}${hourUnit} ${mins}${minUnit}` : `${hours}${hourUnit}`;
     } else {
-      durationStr = `${minutes} 分鐘`;
+      const minUnit = currentLanguage === 'zh' ? '分鐘' : currentLanguage === 'en' ? ' min' : currentLanguage === 'ko' ? '분' : currentLanguage === 'ja' ? '分' : currentLanguage === 'id' ? ' menit' : ' phút';
+      durationStr = `${minutes}${minUnit}`;
     }
   }
   
@@ -1049,7 +1180,7 @@ function renderDirections(data) {
     mapsLink = `
       <div class="data-row" style="margin-top: 8px;">
         <a href="${mapsUrl}" target="_blank" style="color: #0066cc; text-decoration: none; font-size: 0.9em;">
-          🗺️ 在 Google Maps 中查看 →
+          🗺️ ${labels.view_in_maps} →
         </a>
       </div>
     `;
@@ -1057,19 +1188,19 @@ function renderDirections(data) {
   
   return `
     <div class="data-row">
-      <span class="data-label">📍 起點</span>
+      <span class="data-label">📍 ${labels.origin}</span>
       <span class="data-value">${originLabel}</span>
     </div>
     <div class="data-row">
-      <span class="data-label">🎯 目的地</span>
+      <span class="data-label">🎯 ${labels.destination}</span>
       <span class="data-value">${destLabel}</span>
     </div>
     <div class="data-row">
-      <span class="data-label">📏 距離</span>
+      <span class="data-label">📏 ${labels.distance}</span>
       <span class="data-value">${distanceStr}</span>
     </div>
     <div class="data-row">
-      <span class="data-label">⏱️ 預估時間</span>
+      <span class="data-label">⏱️ ${labels.estimated_time}</span>
       <span class="data-value">${durationStr}</span>
     </div>
     ${mapsLink}
@@ -1080,8 +1211,10 @@ function renderDirections(data) {
  * 渲染捷運到站資訊（tdx_metro arrivals）
  */
 function renderMetroArrivals(arrivals) {
+  const labels = LABELS[currentLanguage] || LABELS.zh;
+  
   if (!arrivals || arrivals.length === 0) {
-    return '<p class="data-row">目前無捷運到站資訊</p>';
+    return `<p class="data-row">${labels.no_data}</p>`;
   }
 
   let html = '<div class="metro-arrivals">';
@@ -1089,7 +1222,7 @@ function renderMetroArrivals(arrivals) {
   // 按路線分組
   const lineGroups = {};
   arrivals.forEach(arr => {
-    const lineName = arr.line_name || '未知路線';
+    const lineName = arr.line_name || labels.unknown;
     if (!lineGroups[lineName]) {
       lineGroups[lineName] = [];
     }
@@ -1106,15 +1239,17 @@ function renderMetroArrivals(arrivals) {
     `;
     
     lineArrivals.slice(0, 3).forEach(arr => {
-      const dest = arr.destination || '未知';
+      const dest = arr.destination || labels.unknown;
       const timeSec = arr.arrival_time_sec;
-      const status = arr.train_status || '未知';
+      const status = arr.train_status || labels.unknown;
       
       let timeStr = status;
       if (timeSec > 0) {
         const min = Math.floor(timeSec / 60);
         const sec = timeSec % 60;
-        timeStr = min > 0 ? `${min} 分 ${sec} 秒` : `${sec} 秒`;
+        const minUnit = currentLanguage === 'zh' ? '分' : currentLanguage === 'en' ? ' min' : currentLanguage === 'ko' ? '분' : currentLanguage === 'ja' ? '分' : currentLanguage === 'id' ? ' menit' : ' phút';
+        const secUnit = currentLanguage === 'zh' ? '秒' : currentLanguage === 'en' ? ' sec' : currentLanguage === 'ko' ? '초' : currentLanguage === 'ja' ? '秒' : currentLanguage === 'id' ? ' detik' : ' giây';
+        timeStr = min > 0 ? `${min}${minUnit} ${sec}${secUnit}` : `${sec}${secUnit}`;
       }
       
       html += `
@@ -1136,16 +1271,19 @@ function renderMetroArrivals(arrivals) {
  * 渲染捷運站點資訊（tdx_metro stations）
  */
 function renderMetroStations(stations) {
+  const labels = LABELS[currentLanguage] || LABELS.zh;
+  
   if (!stations || stations.length === 0) {
-    return '<p class="data-row">附近無捷運站</p>';
+    return `<p class="data-row">${labels.no_data}</p>`;
   }
 
   let html = '<div class="metro-stations">';
 
   stations.forEach((station, index) => {
-    const stationName = station.station_name || '未知車站';
-    const distance = station.distance_m ? `${Math.round(station.distance_m)} 公尺` : '';
-    const walkTime = station.walking_time_min ? `步行約 ${station.walking_time_min} 分鐘` : '';
+    const stationName = station.station_name || labels.unknown;
+    const distanceUnit = currentLanguage === 'zh' ? '公尺' : currentLanguage === 'en' ? 'm' : currentLanguage === 'ko' ? '미터' : currentLanguage === 'ja' ? 'メートル' : currentLanguage === 'id' ? 'm' : 'm';
+    const distance = station.distance_m ? `${Math.round(station.distance_m)} ${distanceUnit}` : '';
+    const walkTimeText = station.walking_time_min ? `${currentLanguage === 'zh' ? '步行約 ' : ''}${station.walking_time_min}${currentLanguage === 'zh' ? ' 分鐘' : currentLanguage === 'en' ? ' min walk' : currentLanguage === 'ko' ? '분 도보' : currentLanguage === 'ja' ? '分 徒歩' : currentLanguage === 'id' ? ' menit jalan' : ' phút đi bộ'}` : '';
     const address = station.address || '';
 
     html += `
@@ -1155,19 +1293,19 @@ function renderMetroStations(stations) {
         </div>
         ${distance ? `
         <div class="data-row">
-          <span class="data-label">📏 距離</span>
+          <span class="data-label">📏 ${labels.distance}</span>
           <span class="data-value">${distance}</span>
         </div>
         ` : ''}
-        ${walkTime ? `
+        ${walkTimeText ? `
         <div class="data-row">
-          <span class="data-label">🚶 步行時間</span>
-          <span class="data-value">${walkTime}</span>
+          <span class="data-label">🚶 ${labels.walking_time}</span>
+          <span class="data-value">${walkTimeText}</span>
         </div>
         ` : ''}
         ${address ? `
         <div class="data-row">
-          <span class="data-label">📍 地址</span>
+          <span class="data-label">📍 ${labels.address}</span>
           <span class="data-value" style="font-size: 0.85em;">${address}</span>
         </div>
         ` : ''}
@@ -1183,7 +1321,8 @@ function renderMetroStations(stations) {
  * 渲染正向地理編碼（forward_geocode）
  */
 function renderForwardGeocode(data) {
-  const displayName = data.display_name || '未知地點';
+  const labels = LABELS[currentLanguage] || LABELS.zh;
+  const displayName = data.display_name || labels.unknown;
   const lat = data.lat?.toFixed(6) || '';
   const lon = data.lon?.toFixed(6) || '';
   const city = data.city || '';
@@ -1195,34 +1334,34 @@ function renderForwardGeocode(data) {
 
   return `
     <div class="data-row">
-      <span class="data-label">📍 地點</span>
+      <span class="data-label">📍 ${labels.location}</span>
       <span class="data-value" style="font-weight: bold;">${displayName}</span>
     </div>
     ${city ? `
     <div class="data-row">
-      <span class="data-label">🏙️ 城市</span>
+      <span class="data-label">🏙️ ${labels.city}</span>
       <span class="data-value">${city}</span>
     </div>
     ` : ''}
     ${road ? `
     <div class="data-row">
-      <span class="data-label">🛣️ 道路</span>
+      <span class="data-label">🛣️ ${labels.road}</span>
       <span class="data-value">${road}</span>
     </div>
     ` : ''}
     ${suburb ? `
     <div class="data-row">
-      <span class="data-label">🏘️ 區域</span>
+      <span class="data-label">🏘️ ${labels.area}</span>
       <span class="data-value">${suburb}</span>
     </div>
     ` : ''}
     <div class="data-row">
-      <span class="data-label">🌐 座標</span>
+      <span class="data-label">🌐 ${labels.coordinates}</span>
       <span class="data-value" style="font-size: 0.85em;">${lat}, ${lon}</span>
     </div>
     <div class="data-row" style="margin-top: 8px;">
       <a href="${mapsUrl}" target="_blank" style="color: #0066cc; text-decoration: none; font-size: 0.9em;">
-        🗺️ 在 Google Maps 中查看 →
+        🗺️ ${labels.view_in_maps} →
       </a>
     </div>
   `;

static/frontend/js/websocket.js

@@ -331,12 +331,15 @@ class WebSocketManager {
       this.audioSource.connect(this.audioProcessor);
       this.audioProcessor.connect(this.audioContext.destination);
 
-      // 發送開始錄音信號
+      // 發送開始錄音信號（使用自動語言檢測）
       this.send({
         type: 'audio_start',
         sample_rate: 16000,
-        mode: 'realtime_chat'  // 即時轉錄模式（使用 OpenAI Realtime API）
+        mode: 'realtime_chat',  // 即時轉錄模式（使用 OpenAI Realtime API）
+        language: 'auto'  // 自動檢測語言（支援：zh/en/id/ja/vi）
       });
+      
+      console.log('🌐 使用自動語言檢測');
 
       this.isRecording = true;