Latest

app.py

@@ -5,6 +5,7 @@ import base64
 import mimetypes
 import logging
 import secrets
+import jwt
 from datetime import datetime
 from typing import List, Dict, Optional, Any
 
@@ -108,94 +109,26 @@ def serialize_for_json(obj: Any) -> Any:
             return None
 
 # -----------------------------
-# Pydantic 模型
+# Pydantic 模型（從統一模組導入）
 # -----------------------------
-class UserCreate(BaseModel):
-    name: str
-    email: EmailStr
-    password: str = Field(min_length=6)
-
-
-class UserLogin(BaseModel):
-    email: EmailStr
-    password: str
-
-
-class ChatCreateRequest(BaseModel):
-    user_id: str
-    title: Optional[str] = "新對話"
-
-
-class MessageCreateRequest(BaseModel):
-    sender: str
-    content: str
-
-
-class ChatTitleUpdateRequest(BaseModel):
-    title: str
-
-
-class UserInfo(BaseModel):
-    id: str
-    name: str
-    email: EmailStr
-    created_at: datetime
-
-
-class UserPublic(BaseModel):
-    success: bool
-    user: UserInfo
-
-
-class UserLoginPublicResponse(BaseModel):
-    success: bool
-    user: UserInfo
-    token: Optional[str] = None
-
-
-class ChatPublic(BaseModel):
-    chat_id: str
-    user_id: str
-    title: str
-    created_at: datetime
-    updated_at: datetime
-
-
-class MessagePublic(BaseModel):
-    sender: str
-    content: str
-    timestamp: datetime
-
-
-class ChatDetailResponse(ChatPublic):
-    messages: List[MessagePublic]
-
-
-class ChatSummary(BaseModel):
-    chat_id: str
-    title: str
-    updated_at: datetime
-
-
-class ChatListResponse(BaseModel):
-    chats: List[ChatSummary]
-
-
-class FileAnalysisRequest(BaseModel):
-    filename: str
-    content: str
-    mime_type: str
-    user_prompt: Optional[str] = "請分析這個檔案的內容"
-
-
-class FileAnalysisResponse(BaseModel):
-    success: bool
-    filename: str
-    analysis: Optional[str] = None
-    error: Optional[str] = None
-
-class SpeakerLabelBindRequest(BaseModel):
-    speaker_label: str
+from models.schemas import (
+    UserCreate,
+    UserLogin,
+    ChatCreateRequest,
+    MessageCreateRequest,
+    ChatTitleUpdateRequest,
+    UserInfo,
+    UserPublic,
+    UserLoginPublicResponse,
+    ChatPublic,
+    MessagePublic,
+    ChatDetailResponse,
+    ChatSummary,
+    ChatListResponse,
+    FileAnalysisRequest,
+    FileAnalysisResponse,
+    SpeakerLabelBindRequest,
+)
 
 
 # -----------------------------
@@ -278,8 +211,8 @@ async def lifespan(app: FastAPI):
                 window_seconds=3,
                 required_windows=1,
                 sample_rate=16000,
-                prob_threshold=0.40,
-                margin_threshold=0.01,
+                prob_threshold=0.50,  # ECAPA-TDNN 餘弦相似度 + 0.35 加成後門檻
+                margin_threshold=0.05,
                 min_snr_db=12.0,
             ))
         except Exception as e:
@@ -351,8 +284,8 @@ async def periodic_cleanup():
     """定期清理過期的會話和數據"""
     while True:
         try:
-            # 每30分鐘清理一次
-            await asyncio.sleep(1800)  # 30分鐘
+            # 定期清理（使用配置常數）
+            await asyncio.sleep(settings.CLEANUP_INTERVAL)
 
             # 清理過期的WebSocket會話
             await manager.cleanup_expired_sessions()
@@ -378,10 +311,10 @@ async def periodic_cleanup():
 
 app = FastAPI(title="聊天機器人API（整合版）", lifespan=lifespan)
 
-# CORS 設定
+# CORS 設定（從環境變數讀取，生產環境應設定具體來源）
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],
+    allow_origins=settings.get_cors_origins(),
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
@@ -419,7 +352,7 @@ app.add_middleware(CSPMiddleware)
 
 # 掛載靜態檔案目錄（語音沉浸式前端）
 static_dir = Path("static/frontend")
-login_dir = Path("static/frontend/login")
+login_dir = Path("bloom-ware-login/out")  # 直接使用 Next.js 專案的輸出目錄
 
 if static_dir.exists() and static_dir.is_dir():
     app.mount("/static", StaticFiles(directory=str(static_dir), html=True), name="frontend")
@@ -433,7 +366,7 @@ if login_dir.exists() and login_dir.is_dir():
     app.mount("/login", StaticFiles(directory=str(login_dir), html=True), name="login_static")
     logger.info(f"✅ 已掛載登入頁面: /login → {login_dir}")
 else:
-    logger.warning("⚠️ 未找到 static/frontend/login/ 目錄，請先 build bloom-ware-login 專案")
+    logger.warning(f"⚠️ 未找到 {login_dir} 目錄，請先執行: cd bloom-ware-login && npm run build")
 
 # 環境設定
 app.state.intent_model = settings.OPENAI_MODEL
@@ -452,226 +385,30 @@ def get_client_ip(request: Request) -> str:
             return ip
     return request.client.host if request.client else "unknown"
 
-# CORS
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
+# 注意：CORS 已在上方配置，此處移除重複配置
 
 # -----------------------------
-# WebSocket 連線管理（JWT認證）
+# WebSocket 連線管理（從統一模組導入）
 # -----------------------------
-class ConnectionManager:
-    def __init__(self):
-        self.active_connections: Dict[str, WebSocket] = {}
-        self.client_info: Dict[str, dict] = {}
-        self.user_sessions: Dict[str, Dict[str, Any]] = {}  # 用戶會話信息
-        self.last_env: Dict[str, Dict[str, Any]] = {}  # 最近的環境快照
-
-    async def connect(self, websocket: WebSocket, user_id: str, user_info: Dict[str, Any]):
-        await websocket.accept()
-        self.active_connections[user_id] = websocket
-        self.user_sessions[user_id] = user_info
-        logger.info(f"新的WebSocket連接: {user_id}")
-
-    def disconnect(self, user_id: str):
-        if user_id in self.active_connections:
-            del self.active_connections[user_id]
-            if user_id in self.user_sessions:
-                del self.user_sessions[user_id]
-            logger.info(f"WebSocket連接關閉: {user_id}")
-
-    async def send_message(self, message: str, user_id: str, message_type: str = "bot_message"):
-        if user_id in self.active_connections:
-            try:
-                payload = {"type": message_type, "message": message, "timestamp": time.time()}
-                await self.active_connections[user_id].send_json(
-                    payload
-                )
-                try:
-                    preview = (str(message) or "").strip().replace("\n", " ")
-                    if len(preview) > 120:
-                        preview = preview[:120] + "..."
-                    logger.info(f"WebSocket已發送 → client={user_id} type={message_type} bytes≈{len((str(message) or '').encode('utf-8'))} preview=\"{preview}\"")
-                except Exception:
-                    pass
-            except Exception as e:
-                logger.error(f"發送消息到客戶端 {user_id} 時出錯: {str(e)}")
-
-    def set_client_info(self, user_id: str, info: dict):
-        self.client_info[user_id] = info
-
-    def get_client_info(self, user_id: str) -> dict:
-        return self.client_info.get(user_id, {})
-
-    def get_user_session(self, user_id: str) -> Optional[Dict[str, Any]]:
-        """獲取用戶會話信息"""
-        return self.user_sessions.get(user_id)
-
-    async def cleanup_expired_sessions(self):
-        """清理過期的用戶會話"""
-        current_time = datetime.now()
-        expired_users = []
-
-        for user_id, session_info in self.user_sessions.items():
-            # 如果會話超過30分鐘沒有活動，標記為過期
-            last_activity = session_info.get("last_activity", current_time)
-            if (current_time - last_activity).total_seconds() > 1800:  # 30分鐘
-                expired_users.append(user_id)
-
-        for user_id in expired_users:
-            logger.info(f"清理過期會話: {user_id}")
-            self.disconnect(user_id)
-
-
-manager = ConnectionManager()
-
+from websocket import manager
 
 # -----------------------------
-# 語音綁定狀態管理器（關鍵字匹配，無 GPT）
+# 語音綁定狀態管理器（從統一模組導入）
 # -----------------------------
-class VoiceBindingStateMachine:
-    """
-    語音帳號綁定狀態機（硬編碼關鍵字匹配）
-
-    流程：
-    1. 用戶說「我要綁定語音登入」
-    2. Agent 回應「好的，你現在要綁定誰？」
-    3. 用戶提供名稱
-    4. 系統綁定 speaker_label 到用戶帳號
-    5. Agent 回應「綁定成功！」
-    """
-
-    def __init__(self):
-        # 用戶狀態：{user_id: {state: str, speaker_label: str}}
-        self.user_states: Dict[str, Dict[str, Any]] = {}
-
-    def check_binding_trigger(self, user_id: str, message: str) -> Optional[str]:
-        """
-        檢查是否觸發綁定流程
-
-        Returns:
-            - "TRIGGER": 觸發綁定流程
-            - "AWAITING_NAME": 等待用戶提供名稱
-            - None: 不是綁定相關訊息
-        """
-        message_lower = message.lower().replace(" ", "")
-
-        # 檢測觸發關鍵字
-        trigger_keywords = ["綁定語音登入", "語音登入綁定", "綁定語音", "設定語音登入"]
-        for keyword in trigger_keywords:
-            if keyword.replace(" ", "") in message_lower:
-                # 進入等待狀態
-                self.user_states[user_id] = {
-                    "state": "AWAITING_NAME",
-                    "timestamp": datetime.now()
-                }
-                return "TRIGGER"
-
-        # 檢查是否在等待名稱狀態
-        if user_id in self.user_states:
-            state_info = self.user_states[user_id]
-            if state_info.get("state") == "AWAITING_NAME":
-                # 檢查是否超時（5分鐘）
-                if (datetime.now() - state_info.get("timestamp")).total_seconds() > 300:
-                    del self.user_states[user_id]
-                    return None
-                return "AWAITING_NAME"
-
-        return None
-
-    async def handle_binding_flow(
-        self,
-        user_id: str,
-        message: str,
-        websocket: WebSocket,
-        voice_service: Optional[VoiceAuthService] = None
-    ) -> bool:
-        """
-        處理綁定流程
-
-        Returns:
-            True: 已處理（不要繼續到 Agent）
-            False: 未處理（繼續到 Agent）
-        """
-        state = self.check_binding_trigger(user_id, message)
-
-        if state == "TRIGGER":
-            # 用戶觸發綁定 - 先檢查是否已經綁定過
-            logger.info(f"🎙️ 用戶 {user_id} 觸發語音綁定流程")
-
-            # 檢查使用者是否已經綁定過 speaker_label
-            from core.database import get_user_by_id
-            try:
-                user_data = await get_user_by_id(user_id)
-                if user_data and user_data.get("speaker_label"):
-                    # 已經綁定過了
-                    existing_label = user_data.get("speaker_label")
-                    logger.info(f"⚠️ 用戶 {user_id} 已綁定 speaker_label: {existing_label}")
-
-                    await websocket.send_json({
-                        "type": "bot_message",
-                        "message": f"你已經綁定過語音了！目前的聲紋標籤是：{existing_label}。如果需要重新綁定，請聯繫管理員。",
-                        "timestamp": time.time()
-                    })
-
-                    # 清理 FSM 狀態
-                    self.clear_state(user_id)
-                    return True
-            except Exception as e:
-                logger.error(f"❌ 檢查使用者綁定狀態失敗: {e}")
-                await websocket.send_json({
-                    "type": "error",
-                    "message": "系統錯誤，無法檢查綁定狀態"
-                })
-                return True
-
-            # 未綁定，繼續綁定流程
-            logger.info(f"✅ 用戶 {user_id} 尚未綁定，啟動綁定流程")
-
-            # 標記用戶進入語音綁定等待狀態
-            user_session = manager.get_client_info(user_id) or {}
-            user_session["voice_binding_pending"] = True
-            user_session["voice_binding_started_at"] = datetime.now()
-            manager.set_client_info(user_id, user_session)
-
-            await websocket.send_json({
-                "type": "bot_message",
-                "message": "好的，請錄製一段語音（約3-5秒），用於建立你的聲紋特徵。系統會自動識別並綁定到你的帳號。",
-                "timestamp": time.time()
-            })
-            await websocket.send_json({
-                "type": "voice_binding_ready",
-                "message": "請點擊錄音按鈕開始錄製"
-            })
-            return True
-
-        elif state == "AWAITING_NAME":
-            # 這個狀態已不再使用，因為我們改為直接錄音綁定
-            # 但保留以防萬一
-            pass
-
-        return False
-
-    def clear_state(self, user_id: str):
-        """清理用戶狀態"""
-        self.user_states.pop(user_id, None)
-
-
-voice_binding_fsm = VoiceBindingStateMachine()
+from services.voice_binding import voice_binding_fsm
 
 
 # -----------------------------
 # 統一 WebSocket 端點（JWT認證）
 # -----------------------------
 @app.websocket("/ws")
-async def websocket_endpoint_with_jwt(websocket: WebSocket, token: str = Query(None)):
+async def websocket_endpoint_with_jwt(
+    websocket: WebSocket, 
+    token: str = Query(None),
+    emotion: str = Query("")
+):
     """JWT認證的WebSocket端點（支援語音登入匿名連線）"""
-    logger.info("WebSocket連接請求 - JWT認證")
+    logger.info(f"WebSocket連接請求 - JWT認證 (emotion={emotion})")
 
     # 特殊處理：語音登入匿名連線
     is_voice_login_mode = token == "anonymous_voice_login"
@@ -756,11 +493,11 @@ async def websocket_endpoint_with_jwt(websocket: WebSocket, token: str = Query(N
                     logger.debug(f"讀取使用者時區失敗: {tz_err}")
 
                 td = app.state.feature_router.get_current_time_data()
-                # WebSocket 連線時沒有語音情緒，使用空字串
+                # 使用語音登入傳遞的情緒（如果有）
                 welcome_msg = compose_welcome(
                     user_name=user_info.get('name'),
                     time_data=td,
-                    emotion_label="",
+                    emotion_label=emotion,
                     timezone=tz_hint,
                 )
             except Exception as e:
@@ -833,7 +570,10 @@ async def websocket_endpoint_with_jwt(websocket: WebSocket, token: str = Query(N
                         {
                             "role": "system",
                             "content": (
-                                "你是一個友善、有禮且能夠提供幫助的AI助手。請使用繁體中文回覆，保持簡潔清晰的表達。"
+                                "你是一個友善、有禮且能夠提供幫助的AI助手。\n\n"
+                                "【重要】語���使用規範：\n"
+                                "- 回覆用戶時：必須使用繁體中文，保持簡潔清晰的表達\n"
+                                "- 調用工具時：所有參數必須使用英文（城市名、國家名、貨幣代碼等）\n\n"
                                 "另外，請勿自稱為 GPT-4 或其他版本。若需要自我介紹，請表述為 '基於 gpt-5-nano 模型'。"
                             ),
                         },
@@ -971,28 +711,119 @@ async def websocket_endpoint_with_jwt(websocket: WebSocket, token: str = Query(N
                         await websocket.send_json({"type": "error", "message": f"CHAT_FOCUS_ERROR: {str(e)}"})
 
                 elif message_type == "audio_start":
-                    # 語音處理邏輯（保持不變）
+                    # 語音處理邏輯（支援多種模式）
+                    mode = message_data.get("mode", "voice_login")
+
                     try:
                         sr = int(message_data.get("sample_rate", 16000))
                     except Exception:
                         sr = 16000
-                    try:
-                        if hasattr(app.state, "voice_auth") and app.state.voice_auth:
-                            app.state.voice_auth.start_session(user_id, sr)
-                            await websocket.send_json({"type": "voice_login_status", "message": "recording_started"})
-                        else:
-                            await websocket.send_json({"type": "voice_login_result", "success": False, "error": "VOICE_AUTH_NOT_AVAILABLE"})
-                    except Exception as e:
-                        await websocket.send_json({"type": "voice_login_result", "success": False, "error": f"START_ERROR: {str(e)}"})
+
+                    if mode == "realtime_chat":
+                        # === 即時轉錄模式（使用 OpenAI Realtime API）===
+                        try:
+                            from services.realtime_stt_service import RealtimeSTTService
+
+                            logger.info(f"🎙️ 啟動即時轉錄模式，用戶 {user_id}")
+
+                            # 建立 Realtime STT 服務實例
+                            realtime_stt = RealtimeSTTService()
+
+                            # 定義轉錄回調函數
+                            async def on_transcript_delta(delta_text: str):
+                                """接收部分轉錄結果並即時發送給前端"""
+                                await websocket.send_json({
+                                    "type": "stt_delta",
+                                    "text": delta_text,
+                                    "timestamp": time.time()
+                                })
+                                logger.debug(f"📤 STT Delta: {delta_text}")
+
+                            async def on_transcript_done(full_text: str):
+                                """接收完整轉錄結果"""
+                                await websocket.send_json({
+                                    "type": "stt_final",
+                                    "text": full_text,
+                                    "timestamp": time.time()
+                                })
+                                logger.info(f"✅ STT Final: {full_text}")
+
+                                # 儲存轉錄文字到 client_info，供 audio_stop 使用
+                                client_info = manager.get_client_info(user_id) or {}
+                                client_info["realtime_transcript"] = full_text
+                                manager.set_client_info(user_id, client_info)
+
+                            async def on_vad_committed(item_id: str):
+                                """VAD 偵測到語音段結束"""
+                                logger.debug(f"🎤 VAD Committed: {item_id}")
+
+                            # 連線到 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"
+                            )
+
+                            if success:
+                                # 儲存 Realtime STT 實例到 client info
+                                client_info = manager.get_client_info(user_id) or {}
+                                client_info["realtime_stt"] = realtime_stt
+                                manager.set_client_info(user_id, client_info)
+
+                                await websocket.send_json({
+                                    "type": "realtime_stt_status",
+                                    "status": "connected",
+                                    "message": "即時轉錄已啟動"
+                                })
+                                logger.info(f"✅ 用戶 {user_id} 即時轉錄已啟動")
+                            else:
+                                raise Exception("無法連接到 OpenAI Realtime API")
+
+                        except Exception as e:
+                            logger.error(f"❌ 啟動即時轉錄失敗: {e}")
+                            await websocket.send_json({
+                                "type": "error",
+                                "message": f"即時轉錄啟動失敗: {str(e)}"
+                            })
+
+                    else:
+                        # === 傳統模式（語音登入或語音綁定）===
+                        try:
+                            if hasattr(app.state, "voice_auth") and app.state.voice_auth:
+                                app.state.voice_auth.start_session(user_id, sr)
+                                await websocket.send_json({"type": "voice_login_status", "message": "recording_started"})
+                            else:
+                                await websocket.send_json({"type": "voice_login_result", "success": False, "error": "VOICE_AUTH_NOT_AVAILABLE"})
+                        except Exception as e:
+                            await websocket.send_json({"type": "voice_login_result", "success": False, "error": f"START_ERROR: {str(e)}"})
 
                 elif message_type == "audio_chunk":
                     try:
                         b64 = message_data.get("pcm16_base64", "")
-                        if b64 and hasattr(app.state, "voice_auth") and app.state.voice_auth:
+
+                        # 檢查是否為即時轉錄模式
+                        client_info = manager.get_client_info(user_id) or {}
+                        realtime_stt = client_info.get("realtime_stt")
+
+                        if realtime_stt and b64:
+                            # === 即時轉錄模式：轉發到 OpenAI Realtime API ===
+                            try:
+                                import base64
+                                audio_bytes = base64.b64decode(b64)
+                                await realtime_stt.send_audio_chunk(audio_bytes)
+                                logger.debug(f"🎤 轉發音頻到 OpenAI: {len(audio_bytes)} bytes")
+                            except Exception as e:
+                                logger.error(f"❌ 轉發音頻失敗: {e}")
+
+                        elif b64 and hasattr(app.state, "voice_auth") and app.state.voice_auth:
+                            # === 傳統模式：存到 buffer ===
                             app.state.voice_auth.append_chunk_base64(user_id, b64)
                             # 添加調試日誌
                             current_buffer_size = len(app.state.voice_auth._buffers.get(user_id, b""))
                             logger.info(f"🎤 收到音頻chunk，用戶 {user_id}，當前緩衝區大小: {current_buffer_size} bytes")
+
                     except Exception as e:
                         await websocket.send_json({"type": "voice_login_result", "success": False, "error": f"CHUNK_ERROR: {str(e)}"})
 
@@ -1191,6 +1022,112 @@ async def websocket_endpoint_with_jwt(websocket: WebSocket, token: str = Query(N
                                 "detail": {k: v for k, v in result.items() if k not in {"success"}},
                             })
 
+                    elif mode == "realtime_chat":
+                        # === 即時轉錄模式：關閉 OpenAI Realtime 連線並處理轉錄結果 ===
+                        try:
+                            client_info = manager.get_client_info(user_id) or {}
+                            realtime_stt = client_info.get("realtime_stt")
+                            transcription = client_info.get("realtime_transcript", "")
+
+                            if realtime_stt:
+                                logger.info(f"🔌 關閉即時轉錄連線，用戶 {user_id}")
+                                await realtime_stt.disconnect()
+
+                                # 清理 client info
+                                client_info.pop("realtime_stt", None)
+                                client_info.pop("realtime_transcript", None)
+                                manager.set_client_info(user_id, client_info)
+
+                                await websocket.send_json({
+                                    "type": "realtime_stt_status",
+                                    "status": "disconnected",
+                                    "message": "即時轉錄已結束"
+                                })
+                                logger.info(f"✅ 用戶 {user_id} 即時轉錄已結束")
+                            else:
+                                logger.warning(f"⚠️ 找不到 realtime_stt 實例，用戶 {user_id}")
+
+                            # 如果有轉錄文字，送給 AI Agent 處理
+                            if transcription:
+                                logger.info(f"🤖 處理即時轉錄結果: {transcription}")
+
+                                # 通知前端開始思考
+                                await websocket.send_json({"type": "typing", "message": "thinking"})
+
+                                # 異步處理對話邏輯
+                                async def _process_realtime_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
+
+                                    # 保存用戶訊息
+                                    await save_message_to_db(user_id, chat_id, "user", transcription)
+
+                                    # 處理對話（透過 handle_message，自動處理 pipeline）
+                                    response = await handle_message(
+                                        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
+                                        })
+                                    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
+                                        })
+                                    else:
+                                        # 字串回應
+                                        await websocket.send_json({
+                                            "type": "bot_message",
+                                            "message": str(response),
+                                            "timestamp": time.time()
+                                        })
+
+                                await _process_realtime_chat()
+                            else:
+                                logger.debug(f"沒有轉錄文字，返回待機狀態")
+
+                        except Exception as e:
+                            logger.error(f"❌ 關閉即時轉錄失敗: {e}")
+                            await websocket.send_json({
+                                "type": "error",
+                                "message": f"關閉即時轉錄失敗: {str(e)}"
+                            })
+
                     elif mode == "chat":
                         # === 新的對話模式：並行執行 STT + 情緒辨識 ===
                         try:
@@ -1838,6 +1775,134 @@ async def logout():
         "message": "登出成功"
     }
 
+
+# -----------------------------
+# 語音登入 API
+# -----------------------------
+class VoiceLoginRequest(BaseModel):
+    """語音登入請求"""
+    audio_base64: str  # base64 編碼的 PCM16 音訊
+    sample_rate: int = 16000
+
+
+@app.post("/auth/voice/login")
+async def voice_login(request: VoiceLoginRequest):
+    """
+    語音登入 API
+    
+    流程：
+    1. 接收 base64 編碼的音訊
+    2. 執行身份辨識 + 情緒辨識
+    3. 查詢 speaker_label 對應的用戶
+    4. 生成 JWT token
+    5. 回傳 token + 情緒
+    """
+    import base64
+    
+    try:
+        # 取得 VoiceAuthService 實例
+        voice_auth = getattr(app.state, "voice_auth", None)
+        if not voice_auth:
+            logger.error("❌ VoiceAuthService 未初始化")
+            return JSONResponse(status_code=503, content={
+                "success": False,
+                "error": "語音辨識服務未就緒，請稍後再試"
+            })
+        
+        # 解碼音訊
+        try:
+            audio_bytes = base64.b64decode(request.audio_base64)
+        except Exception as e:
+            logger.error(f"❌ 音訊解碼失敗: {e}")
+            return JSONResponse(status_code=400, content={
+                "success": False,
+                "error": "音訊格式錯誤"
+            })
+        
+        logger.info(f"🎙️ 收到語音登入請求，音訊大小: {len(audio_bytes)} bytes")
+        
+        # 建立臨時 session 並處理音訊
+        temp_user_id = f"voice_login_{datetime.now().timestamp()}"
+        voice_auth.start_session(temp_user_id, request.sample_rate)
+        voice_auth._buffers[temp_user_id] = bytearray(audio_bytes)
+        
+        # 執行辨識
+        result = voice_auth.stop_and_authenticate(temp_user_id)
+        
+        # 清理 session
+        voice_auth.clear_session(temp_user_id)
+        
+        if not result.get("success"):
+            error_code = result.get("error", "UNKNOWN_ERROR")
+            error_messages = {
+                "NO_AUDIO": "沒有收到音訊資料",
+                "AUDIO_TOO_SHORT": "音訊太短，請錄製至少 3 秒",
+                "LOW_SNR": "環境太吵，請在安靜的地方重試",
+                "INCONSISTENT_WINDOWS": "無法確認身份，請重試",
+                "THRESHOLD_NOT_MET": "無法確認身份，請重試",
+                "MODEL_ERROR": "辨識系統錯誤，請稍後重試",
+            }
+            logger.warning(f"🎙️ 語音辨識失敗: {error_code}")
+            return JSONResponse(content={
+                "success": False,
+                "error": error_messages.get(error_code, f"辨識失敗：{error_code}")
+            })
+        
+        # 取得辨識結果
+        speaker_label = result.get("label")
+        emotion = result.get("emotion", {})
+        emotion_label = emotion.get("label", "neutral") if isinstance(emotion, dict) else "neutral"
+        
+        logger.info(f"🎙️ 語音辨識成功: speaker={speaker_label}, emotion={emotion_label}")
+        
+        # 查詢對應的用戶
+        from core.database import get_user_by_speaker_label
+        user = await get_user_by_speaker_label(speaker_label)
+        
+        if not user:
+            logger.warning(f"🎙️ 找不到綁定的帳號: speaker_label={speaker_label}")
+            return JSONResponse(content={
+                "success": False,
+                "error": f"找不到綁定的帳號。請先使用 Google 登入並綁定語音。"
+            })
+        
+        # 生成 JWT token
+        user_id = user.get("id")
+        user_name = user.get("name", "用戶")
+        user_email = user.get("email", "")
+        
+        payload = {
+            "sub": user_id,
+            "name": user_name,
+            "email": user_email,
+            "iat": datetime.utcnow(),
+            "exp": datetime.utcnow() + timedelta(days=7),
+            "login_method": "voice",
+            "emotion": emotion_label,
+        }
+        
+        token = jwt.encode(payload, settings.JWT_SECRET_KEY, algorithm="HS256")
+        
+        logger.info(f"✅ 語音登入成功: user={user_name}, emotion={emotion_label}")
+        
+        return {
+            "success": True,
+            "access_token": token,
+            "user": {
+                "id": user_id,
+                "name": user_name,
+                "email": user_email,
+            },
+            "emotion": emotion_label,
+        }
+        
+    except Exception as e:
+        logger.exception(f"❌ 語音登入失敗: {e}")
+        return JSONResponse(status_code=500, content={
+            "success": False,
+            "error": f"系統錯誤：{str(e)}"
+        })
+
     """
     Google OAuth 2.0 登入端點 (向後兼容)
     接收前端傳來的 Google JWT token，驗證後創建或登入用戶

bloom-ware-login/app/layout.tsx

@@ -13,6 +13,8 @@ export const metadata: Metadata = {
   generator: "v0.app",
 }
 
+import { OfflineIndicator } from "@/components/offline-indicator"
+
 export default function RootLayout({
   children,
 }: Readonly<{
@@ -21,6 +23,7 @@ export default function RootLayout({
   return (
     <html lang="en">
       <body className={`font-sans antialiased`}>
+        <OfflineIndicator />
         {children}
       </body>
     </html>

bloom-ware-login/components/login-form.tsx

@@ -3,12 +3,15 @@
 import { useEffect, useRef, useCallback, useState } from "react"
 import { Button } from "@/components/ui/button"
 import { TulipIllustration } from "@/components/tulip-illustration"
-import { Mic, ExternalLink } from "lucide-react"
+import { Mic, ExternalLink, Loader2 } from "lucide-react"
 
 export function LoginForm() {
   const popupRef = useRef<Window | null>(null)
   const popupCheckIntervalRef = useRef<NodeJS.Timeout | null>(null)
   const [isInIframe, setIsInIframe] = useState(false)
+  const [isLoading, setIsLoading] = useState(false)
+  const [loadingType, setLoadingType] = useState<'google' | 'voice' | null>(null)
+  const [error, setError] = useState<string | null>(null)
 
   // 檢測是否在 iframe 中（HF Space 嵌入模式）
   useEffect(() => {
@@ -153,6 +156,9 @@ export function LoginForm() {
   }
 
   const handleGoogleLogin = async () => {
+    // 清除之前的錯誤
+    setError(null);
+
     // 如果在 iframe 中，引導用戶在新分頁開啟
     if (isInIframe) {
       console.log('📦 檢測到 iframe 環境，引導用戶在新分頁開啟');
@@ -160,6 +166,9 @@ export function LoginForm() {
       return;
     }
 
+    setIsLoading(true);
+    setLoadingType('google');
+
     try {
       console.log('🚀 開始 Google OAuth 登入流程（Popup 模式）...');
 
@@ -204,6 +213,8 @@ export function LoginForm() {
       popupCheckIntervalRef.current = setInterval(() => {
         if (popupRef.current && popupRef.current.closed) {
           console.log('📪 Popup 視窗已關閉');
+          setIsLoading(false);
+          setLoadingType(null);
           if (popupCheckIntervalRef.current) {
             clearInterval(popupCheckIntervalRef.current);
           }
@@ -212,14 +223,119 @@ export function LoginForm() {
 
     } catch (error) {
       console.error('❌ OAuth 初始化失敗:', error);
-      alert('Google 登入初始化失敗，請稍後再試');
+      setError('Google 登入初始化失敗，請稍後再試');
+      setIsLoading(false);
+      setLoadingType(null);
     }
   }
 
-  const handleVoiceLogin = () => {
+  const [voiceStatus, setVoiceStatus] = useState<string>('');
+
+  const handleVoiceLogin = async () => {
+    setError(null);
+    setIsLoading(true);
+    setLoadingType('voice');
+    setVoiceStatus('請求麥克風權限...');
     console.log('🎤 開始語音登入...');
-    localStorage.setItem('jwt_token', 'anonymous_voice_login');
-    window.location.href = '/static/';
+
+    try {
+      // 請求麥克風權限
+      const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      console.log('✅ 麥克風權限已獲取');
+
+      // 設定錄音參數
+      const audioContext = new AudioContext({ sampleRate: 16000 });
+      const source = audioContext.createMediaStreamSource(stream);
+      const processor = audioContext.createScriptProcessor(4096, 1, 1);
+      
+      const audioChunks: Float32Array[] = [];
+      const recordDuration = 4000; // 4 秒（確保足夠長度）
+      
+      processor.onaudioprocess = (e) => {
+        const inputData = e.inputBuffer.getChannelData(0);
+        audioChunks.push(new Float32Array(inputData));
+      };
+      
+      source.connect(processor);
+      processor.connect(audioContext.destination);
+      
+      setVoiceStatus('🎙️ 錄音中... 請說話 (4秒)');
+      console.log('🎙️ 開始錄音 4 秒...');
+      
+      // 錄音 3 秒
+      await new Promise(resolve => setTimeout(resolve, recordDuration));
+      
+      // 停止錄音
+      processor.disconnect();
+      source.disconnect();
+      stream.getTracks().forEach(track => track.stop());
+      await audioContext.close();
+      
+      setVoiceStatus('辨識中...');
+      console.log('✅ 錄音完成，處理音訊...');
+      
+      // 合併音訊資料
+      const totalLength = audioChunks.reduce((acc, chunk) => acc + chunk.length, 0);
+      const audioData = new Float32Array(totalLength);
+      let offset = 0;
+      for (const chunk of audioChunks) {
+        audioData.set(chunk, offset);
+        offset += chunk.length;
+      }
+      
+      // 轉換為 PCM16
+      const pcm16 = new Int16Array(audioData.length);
+      for (let i = 0; i < audioData.length; i++) {
+        const s = Math.max(-1, Math.min(1, audioData[i]));
+        pcm16[i] = s < 0 ? s * 0x8000 : s * 0x7FFF;
+      }
+      
+      // 轉換為 base64
+      const uint8Array = new Uint8Array(pcm16.buffer);
+      let binary = '';
+      for (let i = 0; i < uint8Array.length; i++) {
+        binary += String.fromCharCode(uint8Array[i]);
+      }
+      const audioBase64 = btoa(binary);
+      
+      console.log('📤 發送語音到後端進行辨識...');
+      
+      // 呼叫語音登入 API
+      const response = await fetch('/auth/voice/login', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          audio_base64: audioBase64,
+          sample_rate: 16000,
+        }),
+      });
+      
+      const data = await response.json();
+      
+      if (data.success) {
+        console.log('✅ 語音登入成功！');
+        localStorage.setItem('jwt_token', data.access_token);
+        // 儲存情緒標籤供歡迎詞使用
+        if (data.emotion) {
+          localStorage.setItem('voice_login_emotion', data.emotion);
+        }
+        window.location.href = '/static/';
+      } else {
+        throw new Error(data.error || '語音登入失敗');
+      }
+      
+    } catch (error: any) {
+      console.error('❌ 語音登入失敗:', error);
+      if (error.name === 'NotAllowedError') {
+        setError('請允許麥克風權限以使用語音登入');
+      } else {
+        setError(error.message || '語音登入失敗，請重試');
+      }
+      setIsLoading(false);
+      setLoadingType(null);
+    }
   }
 
   return (
@@ -236,6 +352,13 @@ export function LoginForm() {
       </div>
 
       <div className="w-full space-y-3 sm:space-y-4">
+        {/* 錯誤訊息 */}
+        {error && (
+          <div className="bg-red-50 border border-red-200 text-red-700 px-4 py-2 rounded-lg text-sm text-center">
+            {error}
+          </div>
+        )}
+
         {/* iframe 環境提示 - 簡約風格 */}
         {isInIframe && (
           <p className="text-[#8B7355] text-[11px] sm:text-xs text-center tracking-wide opacity-80">
@@ -245,40 +368,56 @@ export function LoginForm() {
 
         {/* Google Login */}
         <Button
+          type="button"
           onClick={handleGoogleLogin}
-          className="w-full h-11 sm:h-12 bg-white hover:bg-gray-50 text-[#2C2C2C] shadow-md hover:shadow-lg transition-all duration-200 rounded-lg border border-gray-200 text-sm sm:text-base"
+          disabled={isLoading}
+          className="w-full h-11 sm:h-12 bg-white hover:bg-gray-50 text-[#2C2C2C] shadow-md hover:shadow-lg transition-all duration-200 rounded-lg border border-gray-200 text-sm sm:text-base disabled:opacity-50 disabled:cursor-not-allowed"
           variant="outline"
         >
-          <svg className="w-4 h-4 sm:w-5 sm:h-5 mr-2 sm:mr-3" viewBox="0 0 24 24">
-            <path
-              fill="#4285F4"
-              d="M22.56 12.25c0-.78-.07-1.53-.2-2.25H12v4.26h5.92c-.26 1.37-1.04 2.53-2.21 3.31v2.77h3.57c2.08-1.92 3.28-4.74 3.28-8.09z"
-            />
-            <path
-              fill="#34A853"
-              d="M12 23c2.97 0 5.46-.98 7.28-2.66l-3.57-2.77c-.98.66-2.23 1.06-3.71 1.06-2.86 0-5.29-1.93-6.16-4.53H2.18v2.84C3.99 20.53 7.7 23 12 23z"
-            />
-            <path
-              fill="#FBBC05"
-              d="M5.84 14.09c-.22-.66-.35-1.36-.35-2.09s.13-1.43.35-2.09V7.07H2.18C1.43 8.55 1 10.22 1 12s.43 3.45 1.18 4.93l2.85-2.22.81-.62z"
-            />
-            <path
-              fill="#EA4335"
-              d="M12 5.38c1.62 0 3.06.56 4.21 1.64l3.15-3.15C17.45 2.09 14.97 1 12 1 7.7 1 3.99 3.47 2.18 7.07l3.66 2.84c.87-2.6 3.3-4.53 6.16-4.53z"
-            />
-          </svg>
-          <span className="font-medium">Continue with Google</span>
-          {isInIframe && <ExternalLink className="w-3 h-3 ml-2 opacity-50" />}
+          {isLoading && loadingType === 'google' ? (
+            <Loader2 className="w-4 h-4 sm:w-5 sm:h-5 mr-2 sm:mr-3 animate-spin" />
+          ) : (
+            <svg className="w-4 h-4 sm:w-5 sm:h-5 mr-2 sm:mr-3" viewBox="0 0 24 24">
+              <path
+                fill="#4285F4"
+                d="M22.56 12.25c0-.78-.07-1.53-.2-2.25H12v4.26h5.92c-.26 1.37-1.04 2.53-2.21 3.31v2.77h3.57c2.08-1.92 3.28-4.74 3.28-8.09z"
+              />
+              <path
+                fill="#34A853"
+                d="M12 23c2.97 0 5.46-.98 7.28-2.66l-3.57-2.77c-.98.66-2.23 1.06-3.71 1.06-2.86 0-5.29-1.93-6.16-4.53H2.18v2.84C3.99 20.53 7.7 23 12 23z"
+              />
+              <path
+                fill="#FBBC05"
+                d="M5.84 14.09c-.22-.66-.35-1.36-.35-2.09s.13-1.43.35-2.09V7.07H2.18C1.43 8.55 1 10.22 1 12s.43 3.45 1.18 4.93l2.85-2.22.81-.62z"
+              />
+              <path
+                fill="#EA4335"
+                d="M12 5.38c1.62 0 3.06.56 4.21 1.64l3.15-3.15C17.45 2.09 14.97 1 12 1 7.7 1 3.99 3.47 2.18 7.07l3.66 2.84c.87-2.6 3.3-4.53 6.16-4.53z"
+              />
+            </svg>
+          )}
+          <span className="font-medium">
+            {isLoading && loadingType === 'google' ? '登入中...' : 'Continue with Google'}
+          </span>
+          {isInIframe && !isLoading && <ExternalLink className="w-3 h-3 ml-2 opacity-50" />}
         </Button>
 
         {/* Voice Login */}
         <Button
+          type="button"
           onClick={handleVoiceLogin}
-          className="w-full h-11 sm:h-12 bg-white hover:bg-gray-50 text-[#2C2C2C] shadow-md hover:shadow-lg transition-all duration-200 rounded-lg border border-gray-200 text-sm sm:text-base"
+          disabled={isLoading}
+          className="w-full h-11 sm:h-12 bg-white hover:bg-gray-50 text-[#2C2C2C] shadow-md hover:shadow-lg transition-all duration-200 rounded-lg border border-gray-200 text-sm sm:text-base disabled:opacity-50 disabled:cursor-not-allowed"
           variant="outline"
         >
-          <Mic className="w-4 h-4 sm:w-5 sm:h-5 mr-2 sm:mr-3" />
-          <span className="font-medium">Voice Login</span>
+          {isLoading && loadingType === 'voice' ? (
+            <Loader2 className="w-4 h-4 sm:w-5 sm:h-5 mr-2 sm:mr-3 animate-spin" />
+          ) : (
+            <Mic className="w-4 h-4 sm:w-5 sm:h-5 mr-2 sm:mr-3" />
+          )}
+          <span className="font-medium">
+            {isLoading && loadingType === 'voice' ? (voiceStatus || '處理中...') : 'Voice Login'}
+          </span>
         </Button>
       </div>
 

bloom-ware-login/components/offline-indicator.tsx

@@ -0,0 +1,63 @@
+"use client"
+
+import { useEffect, useState } from "react"
+import { WifiOff, Wifi } from "lucide-react"
+
+export function OfflineIndicator() {
+  const [isOnline, setIsOnline] = useState(true)
+  const [showReconnected, setShowReconnected] = useState(false)
+
+  useEffect(() => {
+    // 初始狀態
+    setIsOnline(navigator.onLine)
+
+    const handleOnline = () => {
+      setIsOnline(true)
+      setShowReconnected(true)
+      // 3 秒後隱藏「已恢復連線」提示
+      setTimeout(() => setShowReconnected(false), 3000)
+    }
+
+    const handleOffline = () => {
+      setIsOnline(false)
+      setShowReconnected(false)
+    }
+
+    window.addEventListener("online", handleOnline)
+    window.addEventListener("offline", handleOffline)
+
+    return () => {
+      window.removeEventListener("online", handleOnline)
+      window.removeEventListener("offline", handleOffline)
+    }
+  }, [])
+
+  // 在線且不需要顯示恢復提示時，不渲染任何內容
+  if (isOnline && !showReconnected) {
+    return null
+  }
+
+  return (
+    <div
+      className={`fixed top-4 left-1/2 transform -translate-x-1/2 z-50 
+        px-4 py-2 rounded-full shadow-lg flex items-center gap-2 
+        transition-all duration-300 ${
+          isOnline
+            ? "bg-green-500 text-white"
+            : "bg-red-500 text-white animate-pulse"
+        }`}
+    >
+      {isOnline ? (
+        <>
+          <Wifi className="w-4 h-4" />
+          <span className="text-sm font-medium">已恢復連線</span>
+        </>
+      ) : (
+        <>
+          <WifiOff className="w-4 h-4" />
+          <span className="text-sm font-medium">網路已斷線</span>
+        </>
+      )}
+    </div>
+  )
+}

core/ai_client.py

@@ -0,0 +1,83 @@
+"""
+統一 OpenAI 客戶端管理
+單一真理來源，避免重複初始化
+"""
+
+import logging
+from typing import Optional
+
+from core.config import settings
+from core.logging import get_logger
+
+logger = get_logger("core.ai_client")
+
+# 全域 OpenAI 客戶端
+_openai_client = None
+_initialized = False
+
+
+def get_openai_client():
+    """
+    取得 OpenAI 客戶端（單例模式）
+
+    Returns:
+        OpenAI 客戶端實例，若初始化失敗則返回 None
+    """
+    global _openai_client, _initialized
+
+    if _initialized:
+        return _openai_client
+
+    try:
+        from openai import OpenAI
+
+        api_key = settings.OPENAI_API_KEY
+        if not api_key:
+            logger.error("❌ OpenAI API Key 未設定")
+            _initialized = True
+            return None
+
+        _openai_client = OpenAI(
+            api_key=api_key,
+            timeout=float(settings.OPENAI_TIMEOUT),
+            max_retries=3,
+        )
+
+        _initialized = True
+        logger.info("✅ OpenAI 客戶端初始化成功")
+        return _openai_client
+
+    except ImportError:
+        logger.error("❌ 無法導入 OpenAI SDK")
+        _initialized = True
+        return None
+
+    except Exception as e:
+        logger.error(f"❌ OpenAI 客戶端初始化失敗: {e}")
+        _initialized = True
+        return None
+
+
+def reset_client() -> None:
+    """
+    重置客戶端（用於測試或重新初始化）
+    """
+    global _openai_client, _initialized
+    _openai_client = None
+    _initialized = False
+    logger.info("OpenAI 客戶端已重置")
+
+
+def is_available() -> bool:
+    """
+    檢查 OpenAI 服務是否可用
+
+    Returns:
+        True 如果客戶端已初始化且可用
+    """
+    client = get_openai_client()
+    return client is not None
+
+
+# 便捷別名
+client = property(lambda self: get_openai_client())

core/config.py

@@ -118,6 +118,40 @@ class Settings:
     ENV_CONTEXT_HEADING_THRESHOLD: float = float(os.getenv("ENV_CONTEXT_HEADING_THRESHOLD", "25"))
     ENV_CONTEXT_TTL_SECONDS: float = float(os.getenv("ENV_CONTEXT_TTL_SECONDS", "300"))
 
+    # ===== CORS 安全設定 =====
+    # 生產環境應設定具體的允許來源，多個來源用逗號分隔
+    # 例如：CORS_ORIGINS=https://example.com,https://app.example.com
+    _cors_origins_raw: str = os.getenv("CORS_ORIGINS", "*")
+
+    @classmethod
+    def get_cors_origins(cls) -> list:
+        """取得 CORS 允許的來源列表"""
+        if cls._cors_origins_raw == "*":
+            return ["*"]
+        return [origin.strip() for origin in cls._cors_origins_raw.split(",") if origin.strip()]
+
+    # ===== 安全性設定 =====
+    # 登入失敗封鎖閾值
+    FAILED_LOGIN_THRESHOLD: int = int(os.getenv("FAILED_LOGIN_THRESHOLD", "5"))
+    # 封鎖時間（秒）
+    LOGIN_BLOCK_DURATION: int = int(os.getenv("LOGIN_BLOCK_DURATION", "900"))  # 15 分鐘
+    # JWT Secret 最小長度
+    JWT_SECRET_MIN_LENGTH: int = 32
+
+    # ===== 效能調優常數 =====
+    # WebSocket 會話超時（秒）
+    WEBSOCKET_SESSION_TIMEOUT: int = int(os.getenv("WEBSOCKET_SESSION_TIMEOUT", "1800"))  # 30 分鐘
+    # 定期清理間隔（秒）
+    CLEANUP_INTERVAL: int = int(os.getenv("CLEANUP_INTERVAL", "1800"))  # 30 分鐘
+    # 記憶重要性閾值
+    MEMORY_IMPORTANCE_THRESHOLD: float = float(os.getenv("MEMORY_IMPORTANCE_THRESHOLD", "0.6"))
+    # 意圖快取 TTL（秒）
+    INTENT_CACHE_TTL: int = int(os.getenv("INTENT_CACHE_TTL", "300"))  # 5 分鐘
+    # 對話歷史載入限制
+    CHAT_HISTORY_LIMIT: int = int(os.getenv("CHAT_HISTORY_LIMIT", "12"))
+    # 關懷模式對話歷史限制
+    CARE_MODE_HISTORY_LIMIT: int = int(os.getenv("CARE_MODE_HISTORY_LIMIT", "3"))
+
     @classmethod
     def validate(cls) -> bool:
         """
@@ -156,9 +190,16 @@ class Settings:
         if not cls.OPENAI_API_KEY.startswith("sk-"):
             print("⚠️ OpenAI API Key 格式可能不正確（應以 'sk-' 開頭）")
 
-        # 驗證 JWT Secret 長度
-        if len(cls.JWT_SECRET_KEY) < 32:
-            print("⚠️ JWT Secret Key 長度建議至少 32 個字符")
+        # 驗證 JWT Secret 長度（強制檢查）
+        if len(cls.JWT_SECRET_KEY) < cls.JWT_SECRET_MIN_LENGTH:
+            print(f"❌ JWT Secret Key 長度必須至少 {cls.JWT_SECRET_MIN_LENGTH} 個字符")
+            if cls.IS_PRODUCTION:
+                return False
+            print("⚠️ 開發環境允許繼續，但生產環境將拒絕啟動")
+
+        # 生產環境 CORS 檢查
+        if cls.IS_PRODUCTION and cls._cors_origins_raw == "*":
+            print("⚠️ 生產環境建議設定具體的 CORS_ORIGINS，而非 '*'")
 
         return True
 

core/database/base.py

@@ -39,6 +39,35 @@ route_cache_collection = None
 MAX_MEMORIES_PER_USER = 500
 
 
+def _serialize_firestore_data(data: Any) -> Any:
+    """
+    遞迴轉換 Firestore 資料中的 DatetimeWithNanoseconds 物件為 ISO 字串
+
+    Args:
+        data: Firestore 回傳的資料（可能包含 DatetimeWithNanoseconds）
+
+    Returns:
+        JSON 可序列化的資料
+    """
+    from google.cloud.firestore_v1._helpers import DatetimeWithNanoseconds
+
+    if isinstance(data, DatetimeWithNanoseconds):
+        # 轉成 ISO 8601 字串
+        return data.isoformat()
+    elif isinstance(data, datetime):
+        # 一般 Python datetime 也轉成字串
+        return data.isoformat()
+    elif isinstance(data, dict):
+        # 遞迴處理字典
+        return {k: _serialize_firestore_data(v) for k, v in data.items()}
+    elif isinstance(data, list):
+        # 遞迴處理列表
+        return [_serialize_firestore_data(item) for item in data]
+    else:
+        # 其他型別直接回傳
+        return data
+
+
 def _get_user_doc_ref(user_id: str) -> DocumentReference:
     if users_collection is None:
         raise RuntimeError("Firestore尚未連接，無法操作使用者資料")
@@ -143,13 +172,15 @@ async def get_user_by_id(user_id: str):
             
         user_doc = docs[0]
         user_data = user_doc.to_dict()
-        
-        return {
+
+        result = {
             "id": user_data["user_id"],
             "name": user_data.get("name", ""),
             "email": user_data.get("email", ""),
             "created_at": user_data.get("created_at"),
         }
+        # 序列化 Firestore 時間物件，避免 JSON 序列化炸裂
+        return _serialize_firestore_data(result)
     except Exception as e:
         logger.error(f"查找使用者時發生錯誤: {e}")
         return None
@@ -192,7 +223,8 @@ async def get_user_history(user_id, limit=20):
         
         messages = await _asyncio.to_thread(_fetch_messages)
         logger.info(f"已獲取用戶 {user_id} 的 {len(messages)} 條歷史記錄")
-        return messages
+        # 序列化 Firestore 時間物件，避免 JSON 序列化炸裂
+        return _serialize_firestore_data(messages)
     except Exception as e:
         logger.error(f"獲取歷史記錄時發生錯誤: {e}")
         return []
@@ -371,7 +403,9 @@ async def create_chat(user_id, title="新對話"):
             "created_at": chat["created_at"],
             "updated_at": chat["updated_at"],
         }
-        return {"success": True, "chat": chat_info}
+        # 序列化時間物件，避免 JSON 序列化炸裂
+        serialized_chat_info = _serialize_firestore_data(chat_info)
+        return {"success": True, "chat": serialized_chat_info}
     except Exception as e:
         logger.error(f"創建對話時發生錯誤: {e}")
         return {"success": False, "error": str(e)}
@@ -401,7 +435,9 @@ async def get_user_chats(user_id):
         
         chats = await _asyncio.to_thread(_fetch_chats)
         logger.info(f"獲取到用戶 {user_id} 的 {len(chats)} 個對話")
-        return {"success": True, "chats": chats}
+        # 序列化 Firestore 時間物件，避免 JSON 序列化炸裂
+        serialized_chats = _serialize_firestore_data(chats)
+        return {"success": True, "chats": serialized_chats}
     except Exception as e:
         logger.error(f"獲取用戶對話時發生錯誤: {e}")
         return {"success": False, "error": str(e)}
@@ -524,7 +560,8 @@ async def get_chat_messages(chat_id: str, limit: int | None = None, ascending: b
 
         messages = await _asyncio.to_thread(_query)
         if messages:
-            return messages
+            # 序列化 Firestore 時間物件，避免 JSON 序列化炸裂
+            return _serialize_firestore_data(messages)
 
         # 向後相容：若子集合無資料，嘗試讀取舊頂層 messages 集合
         if messages_collection is None:
@@ -557,7 +594,8 @@ async def get_chat_messages(chat_id: str, limit: int | None = None, ascending: b
                     logger.warning(f"回填 legacy messages 失敗（可忽略）: {backfill_err}")
 
             await _asyncio.to_thread(_backfill)
-        return view_messages
+        # 序列化 Firestore 時間物件，避免 JSON 序列化炸裂
+        return _serialize_firestore_data(view_messages)
     except Exception as e:
         logger.error(f"讀取對話消息失敗: {e}")
         return []
@@ -730,12 +768,14 @@ async def get_user_by_speaker_label(speaker_label: str):
             return None
 
         data = doc.to_dict()
-        return {
+        result = {
             "id": data.get("user_id"),
             "name": data.get("name", ""),
             "email": data.get("email", ""),
             "created_at": data.get("created_at"),
         }
+        # 序列化 Firestore 時間物件，避免 JSON 序列化炸裂
+        return _serialize_firestore_data(result)
     except Exception as e:
         logger.error(f"查詢語音標籤對應用戶時發生錯誤: {e}")
         return None
@@ -912,7 +952,9 @@ async def get_user_env_current(user_id: str) -> Dict[str, Any]:
         data = await _asyncio.to_thread(_read)
         if not data:
             return {"success": False, "error": "NOT_FOUND"}
-        return {"success": True, "context": data}
+        # 序列化 Firestore 時間物件，避免 JSON 序列化炸裂
+        serialized_data = _serialize_firestore_data(data)
+        return {"success": True, "context": serialized_data}
     except Exception as e:
         logger.error(f"讀取環境現況失敗: {e}")
         return {"success": False, "error": str(e)}
@@ -928,7 +970,9 @@ async def get_geo_cache(geohash7: str) -> Optional[Dict[str, Any]]:
         def _read():
             doc = geo_cache_collection.document(geohash7).get()
             return doc.to_dict() if doc.exists else None
-        return await _asyncio.to_thread(_read)
+        result = await _asyncio.to_thread(_read)
+        # 序列化 Firestore 時間物件，避免 JSON 序列化炸裂
+        return _serialize_firestore_data(result) if result else None
     except Exception as e:
         logger.warning(f"讀取 geo_cache 失敗: {e}")
         return None
@@ -959,7 +1003,9 @@ async def get_route_cache(key: str) -> Optional[Dict[str, Any]]:
         def _read():
             doc = route_cache_collection.document(key).get()
             return doc.to_dict() if doc.exists else None
-        return await _asyncio.to_thread(_read)
+        result = await _asyncio.to_thread(_read)
+        # 序列化 Firestore 時間物件，避免 JSON 序列化炸裂
+        return _serialize_firestore_data(result) if result else None
     except Exception as e:
         logger.warning(f"讀取 route_cache 失敗: {e}")
         return None
@@ -1024,7 +1070,9 @@ async def get_user_memories(
             await _asyncio.to_thread(_mark_accessed, [m["memory_id"] for m in memories])
 
         logger.info(f"獲取到用戶 {user_id} 的 {len(memories)} 條記憶")
-        return {"success": True, "memories": memories}
+        # 序列化 Firestore 時間物件，避免 JSON 序列化炸裂
+        serialized_memories = _serialize_firestore_data(memories)
+        return {"success": True, "memories": serialized_memories}
 
     except Exception as e:
         logger.error(f"獲取記憶時發生錯誤: {e}")

core/emotion_care_manager.py

@@ -90,13 +90,15 @@ class EmotionCareManager:
         return True
 
     @classmethod
-    def check_release(cls, user_id: str, message: str, chat_id: Optional[str] = None) -> bool:
+    def check_release(cls, user_id: str, message: str, chat_id: Optional[str] = None, emotion: Optional[str] = None) -> bool:
         """
-        檢查用戶訊息是否包含解除關鍵字
+        檢查用戶訊息是否包含解除關鍵字或情緒恢復為 neutral
 
         參數:
             user_id: 用戶 ID
             message: 用戶訊息
+            chat_id: 對話 ID（可選）
+            emotion: 當前偵測到的情緒（可選）
 
         返回:
             bool: 是否解除關懷模式（True=解除，False=繼續關懷）
@@ -105,18 +107,29 @@ class EmotionCareManager:
         if not state or not state.get("in_care_mode", False):
             return False
 
+        # 優先檢查情緒：如果偵測到 neutral，立即解除關懷模式
+        if emotion and emotion.lower() == "neutral":
+            original_emotion = state.get("emotion", "unknown")
+            duration = time.time() - state.get("start_time", 0)
+
+            state["in_care_mode"] = False
+            state["last_exit_time"] = time.time()
+
+            logger.info(f"✅ 用戶 {user_id}（chat={chat_id or 'default'}）情緒恢復為 neutral（{original_emotion} → neutral），解除關懷模式（持續 {duration:.1f}秒）")
+            return True
+
         # 檢查是否包含解除關鍵字
         message_lower = message.lower().strip()
         for keyword in cls.RELEASE_KEYWORDS:
             if keyword in message_lower:
                 # 解除關懷模式
-                emotion = state.get("emotion", "unknown")
+                original_emotion = state.get("emotion", "unknown")
                 duration = time.time() - state.get("start_time", 0)
 
                 state["in_care_mode"] = False
                 state["last_exit_time"] = time.time()
 
-                logger.info(f"✅ 用戶 {user_id}（chat={chat_id or 'default'}）情緒恢復（{emotion} → 正常），解除關懷模式（持續 {duration:.1f}秒）")
+                logger.info(f"✅ 用戶 {user_id}（chat={chat_id or 'default'}）情緒恢復（{original_emotion} → 正常），解除關懷模式（持續 {duration:.1f}秒）")
                 return True
 
         return False

core/exceptions.py

@@ -0,0 +1,267 @@
+"""
+統一異常處理
+定義自訂異常類別和錯誤響應格式
+"""
+
+from typing import Optional, Dict, Any
+from fastapi import HTTPException
+from fastapi.responses import JSONResponse
+
+
+class BloomWareException(Exception):
+    """Bloom Ware 基礎異常類別"""
+
+    def __init__(
+        self,
+        message: str,
+        code: str = "UNKNOWN_ERROR",
+        status_code: int = 500,
+        details: Optional[Dict[str, Any]] = None,
+    ):
+        self.message = message
+        self.code = code
+        self.status_code = status_code
+        self.details = details or {}
+        super().__init__(message)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """轉換為字典格式"""
+        return {
+            "success": False,
+            "error": {
+                "code": self.code,
+                "message": self.message,
+                "details": self.details,
+            }
+        }
+
+    def to_response(self) -> JSONResponse:
+        """轉換為 JSON 響應"""
+        return JSONResponse(
+            status_code=self.status_code,
+            content=self.to_dict(),
+        )
+
+
+# ==================== 認證相關異常 ====================
+
+class AuthenticationError(BloomWareException):
+    """認證錯誤"""
+
+    def __init__(self, message: str = "認證失敗", details: Optional[Dict[str, Any]] = None):
+        super().__init__(
+            message=message,
+            code="AUTHENTICATION_ERROR",
+            status_code=401,
+            details=details,
+        )
+
+
+class TokenExpiredError(AuthenticationError):
+    """Token 過期"""
+
+    def __init__(self):
+        super().__init__(
+            message="Token 已過期，請重新登入",
+            details={"reason": "token_expired"},
+        )
+
+
+class InvalidTokenError(AuthenticationError):
+    """無效的 Token"""
+
+    def __init__(self):
+        super().__init__(
+            message="無效的認證令牌",
+            details={"reason": "invalid_token"},
+        )
+
+
+class PermissionDeniedError(BloomWareException):
+    """權限不足"""
+
+    def __init__(self, message: str = "權限不足"):
+        super().__init__(
+            message=message,
+            code="PERMISSION_DENIED",
+            status_code=403,
+        )
+
+
+# ==================== 資源相關異常 ====================
+
+class ResourceNotFoundError(BloomWareException):
+    """資源不存在"""
+
+    def __init__(self, resource_type: str, resource_id: str):
+        super().__init__(
+            message=f"{resource_type} 不存在",
+            code="RESOURCE_NOT_FOUND",
+            status_code=404,
+            details={
+                "resource_type": resource_type,
+                "resource_id": resource_id,
+            },
+        )
+
+
+class ChatNotFoundError(ResourceNotFoundError):
+    """對話不存在"""
+
+    def __init__(self, chat_id: str):
+        super().__init__("對話", chat_id)
+
+
+class UserNotFoundError(ResourceNotFoundError):
+    """用戶不存在"""
+
+    def __init__(self, user_id: str):
+        super().__init__("用戶", user_id)
+
+
+# ==================== 驗證相關異常 ====================
+
+class ValidationError(BloomWareException):
+    """驗證錯誤"""
+
+    def __init__(self, field: str, message: str):
+        super().__init__(
+            message=f"參數 '{field}' 驗證失敗: {message}",
+            code="VALIDATION_ERROR",
+            status_code=400,
+            details={"field": field},
+        )
+
+
+class RateLimitExceededError(BloomWareException):
+    """請求頻率超限"""
+
+    def __init__(self, retry_after: int = 60):
+        super().__init__(
+            message="請求頻率超過限制，請稍後再試",
+            code="RATE_LIMIT_EXCEEDED",
+            status_code=429,
+            details={"retry_after": retry_after},
+        )
+
+
+# ==================== 服務相關異常 ====================
+
+class ServiceUnavailableError(BloomWareException):
+    """服務不可用"""
+
+    def __init__(self, service_name: str):
+        super().__init__(
+            message=f"{service_name} 服務暫時不可用",
+            code="SERVICE_UNAVAILABLE",
+            status_code=503,
+            details={"service": service_name},
+        )
+
+
+class DatabaseError(BloomWareException):
+    """數據庫錯誤"""
+
+    def __init__(self, message: str = "數據庫操作失敗"):
+        super().__init__(
+            message=message,
+            code="DATABASE_ERROR",
+            status_code=500,
+        )
+
+
+class AIServiceError(BloomWareException):
+    """AI 服務錯誤"""
+
+    def __init__(self, message: str = "AI 服務暫時不可用"):
+        super().__init__(
+            message=message,
+            code="AI_SERVICE_ERROR",
+            status_code=503,
+        )
+
+
+class ExternalAPIError(BloomWareException):
+    """外部 API 錯誤"""
+
+    def __init__(self, api_name: str, message: str):
+        super().__init__(
+            message=f"{api_name} API 錯誤: {message}",
+            code="EXTERNAL_API_ERROR",
+            status_code=502,
+            details={"api": api_name},
+        )
+
+
+# ==================== 語音相關異常 ====================
+
+class VoiceAuthError(BloomWareException):
+    """語音認證錯誤"""
+
+    def __init__(self, message: str, reason: str):
+        super().__init__(
+            message=message,
+            code="VOICE_AUTH_ERROR",
+            status_code=400,
+            details={"reason": reason},
+        )
+
+
+class SpeakerLabelTakenError(VoiceAuthError):
+    """語音標籤已被使用"""
+
+    def __init__(self):
+        super().__init__(
+            message="此語音標籤已被其他用戶綁定",
+            reason="speaker_label_taken",
+        )
+
+
+# ==================== 異常處理器 ====================
+
+def create_error_response(
+    code: str,
+    message: str,
+    status_code: int = 500,
+    details: Optional[Dict[str, Any]] = None,
+) -> JSONResponse:
+    """創建標準錯誤響應"""
+    return JSONResponse(
+        status_code=status_code,
+        content={
+            "success": False,
+            "error": {
+                "code": code,
+                "message": message,
+                "details": details or {},
+            }
+        }
+    )
+
+
+def handle_exception(exc: Exception) -> JSONResponse:
+    """
+    統一異常處理
+    
+    將各種異常轉換為標準 JSON 響應
+    """
+    if isinstance(exc, BloomWareException):
+        return exc.to_response()
+    
+    if isinstance(exc, HTTPException):
+        return create_error_response(
+            code="HTTP_ERROR",
+            message=exc.detail,
+            status_code=exc.status_code,
+        )
+    
+    # 未知異常
+    import logging
+    logger = logging.getLogger("core.exceptions")
+    logger.exception(f"未處理的異常: {exc}")
+    
+    return create_error_response(
+        code="INTERNAL_ERROR",
+        message="內部伺服器錯誤",
+        status_code=500,
+    )

core/intent_detector.py

@@ -0,0 +1,272 @@
+"""
+意圖檢測器
+2025 最佳實踐：使用 OpenAI 原生 Function Calling 進行意圖檢測
+
+核心改進：
+1. 不再使用巨大的 system_prompt 描述每個工具
+2. 直接使用 OpenAI tools 參數傳遞工具定義
+3. GPT 原生選擇工具並生成結構化參數
+4. 新增工具只需註冊到 Registry，不需更新任何 prompt
+"""
+
+import json
+import hashlib
+import time
+import logging
+from typing import Dict, Any, Optional, Tuple, List
+
+from core.tool_registry import tool_registry
+from core.logging import get_logger
+
+logger = get_logger("core.intent_detector")
+
+
+class IntentDetector:
+    """
+    意圖檢測器
+    
+    使用 OpenAI 原生 Function Calling 進行意圖檢測，
+    不需要自定義 prompt 描述每個工具。
+    """
+    
+    # 情緒列表
+    EMOTIONS = ["neutral", "happy", "sad", "angry", "fear", "surprise"]
+    
+    # 快取 TTL（秒）
+    CACHE_TTL = 300.0
+    
+    def __init__(self):
+        self._cache: Dict[str, Tuple[bool, Optional[Dict[str, Any]], float]] = {}
+    
+    async def detect(
+        self,
+        message: str,
+        user_id: Optional[str] = None,
+        include_location_tools: bool = True,
+    ) -> Tuple[bool, Optional[Dict[str, Any]]]:
+        """
+        檢測用戶消息中的意圖
+        
+        Args:
+            message: 用戶消息
+            user_id: 用戶 ID（用於日誌）
+            include_location_tools: 是否包含需要位置的工具
+        
+        Returns:
+            (是否檢測到工具調用, 意圖數據)
+        """
+        # 檢查快取
+        cache_key = hashlib.md5(message.encode()).hexdigest()
+        if cache_key in self._cache:
+            has_intent, intent_data, cached_time = self._cache[cache_key]
+            if time.time() - cached_time < self.CACHE_TTL:
+                logger.debug(f"💾 意圖快取命中: {message[:50]}...")
+                return has_intent, intent_data
+            else:
+                del self._cache[cache_key]
+        
+        logger.info(f"🔍 檢測意圖: \"{message[:100]}...\"")
+        
+        # 檢查特殊命令
+        special_result = self._check_special_commands(message)
+        if special_result:
+            return special_result
+        
+        # 使用 OpenAI Function Calling 進行意圖檢測
+        try:
+            result = await self._detect_with_function_calling(
+                message,
+                include_location_tools=include_location_tools,
+            )
+            
+            # 寫入快取
+            self._cache[cache_key] = (*result, time.time())
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"❌ 意圖檢測失敗: {e}")
+            # 降級：使用關鍵字匹配
+            return self._keyword_fallback(message)
+    
+    def _check_special_commands(self, message: str) -> Optional[Tuple[bool, Dict[str, Any]]]:
+        """檢查特殊命令"""
+        for command in ["功能列表", "有什麼功能", "能做什麼"]:
+            if command in message:
+                logger.info(f"檢測到特殊命令: {command}")
+                return True, {
+                    "type": "special_command",
+                    "command": "feature_list"
+                }
+        return None
+    
+    async def _detect_with_function_calling(
+        self,
+        message: str,
+        include_location_tools: bool = True,
+    ) -> Tuple[bool, Optional[Dict[str, Any]]]:
+        """
+        使用 OpenAI Function Calling 進行意圖檢測
+        
+        核心邏輯：
+        1. 將所有工具以 OpenAI tools 格式傳遞
+        2. GPT 自動選擇最適合的工具
+        3. 如果 GPT 不選擇任何工具，視為一般聊天
+        """
+        import services.ai_service as ai_service
+        from core.reasoning_strategy import get_optimal_reasoning_effort
+        
+        # 取得所有工具定義（OpenAI 格式）
+        tools = tool_registry.get_openai_tools(
+            include_location_tools=include_location_tools,
+            strict=True,
+        )
+        
+        if not tools:
+            logger.warning("⚠️ 沒有可用的工具")
+            return False, {"emotion": "neutral"}
+        
+        # 建構精簡的 system prompt（只處理情緒和特殊規則）
+        system_prompt = self._build_system_prompt()
+        
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": message}
+        ]
+        
+        # 使用 OpenAI Function Calling
+        optimal_effort = get_optimal_reasoning_effort("intent_detection")
+        logger.info(f"🧠 意圖檢測推理強度: {optimal_effort}")
+        
+        try:
+            response = await ai_service.generate_response_with_tools(
+                messages=messages,
+                tools=tools,
+                user_id="intent_detection",
+                model="gpt-5-nano",
+                reasoning_effort=optimal_effort,
+            )
+            
+            return self._parse_function_calling_response(response)
+            
+        except Exception as e:
+            logger.error(f"❌ Function Calling 失敗: {e}")
+            raise
+    
+    def _build_system_prompt(self) -> str:
+        """
+        建構精簡的 system prompt
+        
+        注意：不再描述每個工具，工具定義由 tools 參數傳遞
+        """
+        return """你是一個智能助手，根據用戶需求選擇合適的工具。
+
+規則：
+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 欄位：
+- neutral: 平靜、中性
+- happy: 開心、興奮
+- sad: 難過、沮喪
+- angry: 生氣、煩躁
+- fear: 恐懼、擔心
+- surprise: 驚訝、意外"""
+    
+    def _parse_function_calling_response(
+        self,
+        response: Dict[str, Any],
+    ) -> Tuple[bool, Optional[Dict[str, Any]]]:
+        """
+        解析 Function Calling 回應
+        
+        Args:
+            response: OpenAI API 回應
+        
+        Returns:
+            (是否檢測到工具調用, 意圖數據)
+        """
+        # 檢查是否有 tool_calls
+        tool_calls = response.get("tool_calls", [])
+        
+        if tool_calls:
+            # 取第一個工具調用
+            tool_call = tool_calls[0]
+            function = tool_call.get("function", {})
+            tool_name = function.get("name", "")
+            arguments_str = function.get("arguments", "{}")
+            
+            try:
+                arguments = json.loads(arguments_str)
+            except json.JSONDecodeError:
+                arguments = {}
+            
+            logger.info(f"✅ GPT 選擇工具: {tool_name}")
+            logger.debug(f"工具參數: {arguments}")
+            
+            # 提取情緒（從 content 或預設）
+            emotion = self._extract_emotion_from_response(response)
+            
+            return True, {
+                "type": "mcp_tool",
+                "tool_name": tool_name,
+                "arguments": arguments,
+                "emotion": emotion,
+            }
+        
+        # 沒有工具調用，視為一般聊天
+        logger.info("💬 GPT 判斷為一般聊天")
+        emotion = self._extract_emotion_from_response(response)
+        
+        return False, {"emotion": emotion}
+    
+    def _extract_emotion_from_response(self, response: Dict[str, Any]) -> str:
+        """從回應中提取情緒"""
+        # 嘗試從 content 中提取
+        content = response.get("content", "")
+        if content:
+            for emotion in self.EMOTIONS:
+                if emotion in content.lower():
+                    return emotion
+        
+        return "neutral"
+    
+    def _keyword_fallback(self, message: str) -> Tuple[bool, Optional[Dict[str, Any]]]:
+        """關鍵字匹配降級方案"""
+        message_lower = message.lower()
+        
+        # 取得所有工具摘要
+        summaries = tool_registry.get_summaries()
+        
+        for summary in summaries:
+            keywords = summary.get("keywords", [])
+            for keyword in keywords:
+                if keyword.lower() in message_lower:
+                    logger.info(f"🔑 關鍵字匹配: {keyword} → {summary['name']}")
+                    return True, {
+                        "type": "mcp_tool",
+                        "tool_name": summary["name"],
+                        "arguments": {},
+                        "emotion": "neutral",
+                    }
+        
+        return False, {"emotion": "neutral"}
+    
+    def clear_cache(self) -> None:
+        """清除快取"""
+        self._cache.clear()
+        logger.info("🗑️ 意圖快取已清除")
+
+
+# 全域單例
+intent_detector = IntentDetector()

core/logging.py

@@ -0,0 +1,105 @@
+"""
+統一日誌配置
+集中管理所有模組的日誌設定
+
+使用方式：
+    from core.logging import get_logger
+    logger = get_logger(__name__)
+"""
+
+import os
+import logging
+from typing import Optional
+
+# 全域日誌等級（只讀取一次）
+_LOG_LEVEL_NAME = os.getenv("BLOOMWARE_LOG_LEVEL", "WARNING").upper()
+_LOG_LEVEL = getattr(logging, _LOG_LEVEL_NAME, logging.WARNING)
+
+# 日誌格式
+_LOG_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+
+
+def get_log_level() -> int:
+    """獲取日誌等級"""
+    return _LOG_LEVEL
+
+
+def setup_logging(
+    name: Optional[str] = None,
+    level: Optional[int] = None,
+) -> logging.Logger:
+    """
+    設置日誌配置
+    
+    Args:
+        name: 日誌名稱（None 表示 root logger）
+        level: 日誌等級（None 表示使用環境變數）
+    
+    Returns:
+        配置好的 Logger 實例
+    """
+    if level is None:
+        level = _LOG_LEVEL
+
+    # 配置格式
+    formatter = logging.Formatter(_LOG_FORMAT)
+
+    # 獲取或創建 logger
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+
+    # 避免重複添加 handler
+    if not logger.handlers:
+        # 控制台 handler
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(level)
+        console_handler.setFormatter(formatter)
+        logger.addHandler(console_handler)
+
+    # 防止日誌重複輸出
+    logger.propagate = False
+
+    return logger
+
+
+def get_logger(name: str) -> logging.Logger:
+    """
+    獲取已配置的 Logger（推薦使用）
+    
+    Args:
+        name: 日誌名稱，建議使用 __name__
+    
+    Returns:
+        Logger 實例
+    
+    Example:
+        from core.logging import get_logger
+        logger = get_logger(__name__)
+        logger.info("Hello")
+    """
+    return setup_logging(name)
+
+
+def get_level_name() -> str:
+    """獲取當前日誌等級名稱"""
+    return _LOG_LEVEL_NAME
+
+
+# 預設配置 root logger
+_root_configured = False
+
+def configure_root_logger():
+    """配置 root logger（只執行一次）"""
+    global _root_configured
+    if not _root_configured:
+        level = get_log_level()
+        logging.basicConfig(
+            level=level,
+            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+            handlers=[logging.StreamHandler()]
+        )
+        _root_configured = True
+
+
+# 自動配置
+configure_root_logger()

core/memory_system.py

@@ -1,31 +1,19 @@
-import os
-import logging
+import json
 from typing import List, Dict, Any, Optional, Tuple
 from datetime import datetime
-import json
 
-# 設置日誌
-LOG_LEVEL_NAME = os.getenv("BLOOMWARE_LOG_LEVEL", "WARNING").upper()
-LOG_LEVEL = getattr(logging, LOG_LEVEL_NAME, logging.WARNING)
-logging.basicConfig(level=LOG_LEVEL, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-logger = logging.getLogger("MemorySystem")
-logger.setLevel(LOG_LEVEL)
+# 統一日誌配置
+from core.logging import get_logger
+logger = get_logger("MemorySystem")
+
+# 統一 OpenAI 客戶端
+from core.ai_client import get_openai_client
+
+def _get_memory_client():
+    """取得記憶系統用的 OpenAI 客戶端"""
+    return get_openai_client()
 
-# 載入環境變數
-from dotenv import load_dotenv
-load_dotenv()
 
-# 嘗試導入 OpenAI
-try:
-    from openai import OpenAI
-    memory_client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-    logger.info("記憶系統成功導入 OpenAI SDK")
-except ImportError:
-    logger.error("Failed to import OpenAI for memory system")
-    memory_client = None
-except Exception as e:
-    logger.error(f"初始化記憶系統 OpenAI 客戶端時出錯: {e}")
-    memory_client = None
 
 # 導入數據庫函數
 try:
@@ -139,7 +127,8 @@ class MemoryAnalyzer:
     async def analyze_conversation(self, user_message: str, assistant_response: str = "",
                                   conversation_history: List[Dict] = None) -> List[Dict[str, Any]]:
         """使用AI分析對話內容，提取重要記憶"""
-        if not memory_client:
+        client = _get_memory_client()
+        if not client:
             logger.warning("OpenAI客戶端不可用，跳過AI記憶分析")
             return []
 
@@ -196,11 +185,11 @@ class MemoryAnalyzer:
                     else:
                         max_tokens_value = 2000
 
-                    response = memory_client.chat.completions.create(
+                    response = client.chat.completions.create(
                         model="gpt-5-nano",
                         messages=messages,
-                        max_completion_tokens=max_tokens_value,  # 修正：使用 max_completion_tokens 而非 max_tokens
-                        reasoning_effort="low"  # 記憶分析需要理解，但不需深度推理
+                        max_completion_tokens=max_tokens_value,
+                        reasoning_effort="low"
                     )
                     break  # 成功後跳出重試循環
 
@@ -279,7 +268,7 @@ class MemoryManager:
 
             # 2. 使用AI分析提取記憶（如果可用）
             ai_memories = []
-            if memory_client:
+            if _get_memory_client():
                 ai_memories = await self.analyzer.analyze_conversation(
                     user_message, assistant_response, conversation_history
                 )
@@ -439,3 +428,6 @@ class MemoryManager:
 
 # 全局記憶管理器實例
 memory_manager = MemoryManager()
+
+# 向後兼容別名
+memory_system = memory_manager

core/pipeline.py

@@ -76,10 +76,23 @@ class ChatPipeline:
         if not user_message or not user_message.strip():
             return PipelineResult(text="我沒有收到您的消息，請重新輸入。", is_fallback=True, reason="empty")
 
-        # 0) 檢查是否在關懷模式（新增）
+        # 0) 先進行意圖偵測以提取情緒（需要在關懷模式檢查前執行）
+        detect_res = await self._with_timeout(
+            self._intent_detector(user_message), self._detect_timeout, reason="detect"
+        )
+        if isinstance(detect_res, PipelineResult):
+            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}")
+
+        # 1) 檢查是否在關懷模式
         if user_id and EmotionCareManager.is_in_care_mode(user_id, chat_id):
-            # 檢查是否解除關懷模式
-            if EmotionCareManager.check_release(user_id, user_message, chat_id):
+            # 檢查是否解除關懷模式（傳入情緒資訊）
+            if EmotionCareManager.check_release(user_id, user_message, chat_id, emotion=emotion_value):
                 logger.info(f"✅ 用戶 {user_id} 情緒恢復，解除關懷模式，繼續正常流程")
                 # 解除後繼續正常流程
             else:
@@ -107,22 +120,9 @@ class ChatPipeline:
                     return PipelineResult(text="我在這裡陪你，隨時可以聊聊。", is_fallback=True, reason="ai-care-empty")
                 return PipelineResult(text=text, is_fallback=False, meta={"care_mode": True, "emotion": care_emotion})
 
-        # 1) 意圖偵測（限時）
-        detect_res = await self._with_timeout(
-            self._intent_detector(user_message), self._detect_timeout, reason="detect"
-        )
-        if isinstance(detect_res, PipelineResult):
-            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}")
-
-        # 檢查是否需要進入關懷模式（新增）
-        if user_id and EmotionCareManager.check_and_enter_care_mode(user_id, emotion, chat_id):
-            logger.warning(f"⚠️ 偵測到極端情緒 [{emotion}]，進入關懷模式")
+        # 2) 檢查是否需要進入關懷模式
+        if user_id and EmotionCareManager.check_and_enter_care_mode(user_id, emotion_value, chat_id):
+            logger.warning(f"⚠️ 偵測到極端情緒 [{emotion_value}]，進入關懷模式")
             # 立即使用關懷模式 AI 回應
             ai_res = await self._with_timeout(
                 self._ai_generator(
@@ -132,8 +132,8 @@ class ChatPipeline:
                     request_id,
                     chat_id,
                     use_care_mode=True,
-                    care_emotion=emotion,
-                    emotion_label=emotion,
+                    care_emotion=emotion_value,
+                    emotion_label=emotion_value,
                 ),
                 self._ai_timeout,
                 reason="ai-care",
@@ -146,9 +146,9 @@ class ChatPipeline:
 
             # 第一次進入關懷模式時，附加退出提示（新增）
             exit_hint = "\n\n💙 關懷模式已啟動。說「我沒事了」可以退出。"
-            return PipelineResult(text=text + exit_hint, is_fallback=False, meta={"care_mode": True, "emotion": emotion})
+            return PipelineResult(text=text + exit_hint, is_fallback=False, meta={"care_mode": True, "emotion": emotion_value})
 
-        # 2) 有功能 → 功能處理(限時)
+        # 3) 有功能 → 功能處理(限時)
         if has_feature and intent_data:
             feat_res = await self._with_timeout(
                 self._feature_processor(intent_data, user_id, user_message, chat_id),
@@ -193,7 +193,7 @@ class ChatPipeline:
                         meta={"emotion": emotion_value},
                     )
 
-        # 3) 無功能 → 一般聊天（限時）
+        # 4) 無功能 → 一般聊天（限時）
         # 注意：不傳 messages，改傳 user_message，讓 ai_generator 自動載入歷史對話和記憶
         ai_res = await self._with_timeout(
             self._ai_generator(

core/prompts/__init__.py

@@ -0,0 +1,13 @@
+"""
+Prompt 模板管理
+統一管理 AI 系統提示詞，支援動態組合
+"""
+
+from .intent_detection import get_intent_prompt, TOOL_RULES
+from .care_mode import CARE_MODE_PROMPT
+
+__all__ = [
+    "get_intent_prompt",
+    "TOOL_RULES",
+    "CARE_MODE_PROMPT",
+]

core/prompts/care_mode.py

@@ -0,0 +1,45 @@
+"""
+情緒關懷模式 Prompt
+精簡化設計，保持關懷品質
+"""
+
+CARE_MODE_PROMPT = """你是 BloomWare 的情緒關懷助手「小花」。你的任務是傾聽、陪伴。
+
+【回應原則】
+1. 第一句貼近用戶的核心感受，讓對方感受到被理解
+2. 第二句溫柔陪伴或追問，邀請分享
+3. 句式自然口語，避免罐頭話術
+
+【限制】
+- 最多 2 句話、60 字以內
+- 禁止：指示性建議、醫療診斷、教科書式說法
+- 禁止：重複相同句型
+
+【範例】
+用戶：「我好難過」
+你：「聽見你說好難過，心裡一定很不好受。想聊聊發生了什麼嗎？」
+
+用戶：「我很生氣」
+你：「這件事讓你超級生氣，情緒一定卡著。要不要說說最困擾的地方？」"""
+
+
+def get_care_prompt(emotion: str = None, user_name: str = None) -> str:
+    """
+    生成關懷模式 Prompt
+
+    Args:
+        emotion: 用戶情緒標籤
+        user_name: 用戶名稱
+
+    Returns:
+        關懷模式 System Prompt
+    """
+    prompt = CARE_MODE_PROMPT
+
+    if emotion:
+        prompt = f"用戶情緒：{emotion}\n\n{prompt}"
+
+    if user_name:
+        prompt = f"用戶名稱：{user_name}\n\n{prompt}"
+
+    return prompt

core/prompts/intent_detection.py

@@ -0,0 +1,93 @@
+"""
+意圖檢測 Prompt 模板
+精簡化設計，減少 token 消耗約 40%
+"""
+
+# 工具特定規則（按需載入）
+TOOL_RULES = {
+    "weather": """天氣查詢：城市必須用英文（台北→Taipei, 高雄→Kaohsiung），預設 Taipei""",
+
+    "exchange": """匯率查詢：貨幣必須用 ISO 4217 代碼（美元→USD, 台幣→TWD），預設 USD→TWD""",
+
+    "news": """新聞查詢：「新聞」「消息」「報導」→ news_query，country/language 用英文代碼（tw, zh）""",
+
+    "bus": """公車查詢：「公車」「巴士」→ tdx_bus_arrival
+- route_name 必須是公車路線號碼（如 137、307、紅30）
+- 「往 X 的公車」「去 X 的公車」不是路線查詢，應使用 directions 或 forward_geocode
+- 「附近公車」「公車站」不需 route_name，系統用 GPS 查詢
+例：「137公車」→ tdx_bus_arrival:route_name=137
+例：「往台北的公車」→ forward_geocode:query=台北（這是導航需求）""",
+
+    "train": """台鐵查詢：「火車」「台鐵」→ tdx_train
+「往XX」「到XX」是目的地（destination_station），不是起點
+沒說起點就不填 origin_station，讓 GPS 決定
+例：「往台北的火車」→ tdx_train:destination_station=台北""",
+
+    "youbike": """YouBike 查詢：「YouBike」「Ubike」「微笑單車」「共享單車」→ tdx_youbike
+城市參數必須用英文（台北→Taipei, 桃園→Taoyuan），站名可用中文
+不是 tdx_parking！這是單車不是停車場""",
+
+    "location": """位置查詢：
+「我在哪」「這是哪裡」→ reverse_geocode（不需參數）
+「怎麼去 X」→ forward_geocode:query=X""",
+}
+
+# 情緒標籤說明
+EMOTION_RULES = """情緒判斷：neutral/happy/sad/angry/fear/surprise
+- happy: 開心、興奮（「好開心！」「太棒了」）
+- sad: 難過、沮喪（「好難過」「心情不好」）
+- angry: 生氣、煩躁（「煩死了」「氣死我了」）
+- fear: 恐懼、擔心（「好害怕」「怎麼辦」）
+- surprise: 驚訝（「什麼！」「真的假的」）
+- neutral: 其他"""
+
+
+def get_intent_prompt(tools_description: str, include_rules: list = None) -> str:
+    """
+    生成意圖檢測 Prompt
+
+    Args:
+        tools_description: 可用工具描述
+        include_rules: 要包含的工具規則列表，None 表示全部
+
+    Returns:
+        精簡化的 System Prompt
+    """
+    # 基礎 Prompt
+    base = f"""你是意圖解析助手。分析用戶消息，決定是否調用工具。
+
+可用工具：
+{tools_description}
+
+"""
+
+    # 添加工具規則
+    if include_rules is None:
+        include_rules = list(TOOL_RULES.keys())
+
+    rules_text = "\n".join(
+        f"- {TOOL_RULES[rule]}"
+        for rule in include_rules
+        if rule in TOOL_RULES
+    )
+
+    if rules_text:
+        base += f"""工具規則：
+{rules_text}
+
+"""
+
+    # 添加情緒規則
+    base += f"""{EMOTION_RULES}
+
+回應格式：
+- is_tool_call: true/false
+- tool_name: 工具名稱:參數（is_tool_call=true 時）
+- emotion: 情緒標籤
+
+示例：
+- "台北天氣" → {{"is_tool_call": true, "tool_name": "weather_query:city=Taipei", "emotion": "neutral"}}
+- "你好" → {{"is_tool_call": false, "tool_name": "", "emotion": "neutral"}}
+- "我好難過" → {{"is_tool_call": false, "tool_name": "", "emotion": "sad"}}"""
+
+    return base

core/reasoning_strategy.py

@@ -43,10 +43,10 @@ class ReasoningStrategy:
             reasoning_effort: minimal/low/medium/high
         """
 
-        # 🔥 規則 1：意圖檢測必須極速（minimal）
+        # 🔥 規則 1：意圖檢測使用 low reasoning（平衡速度與準確度）
         if task_type == "intent_detection":
-            logger.debug("🧠 意圖檢測 → minimal reasoning（極速模式）")
-            return "minimal"
+            logger.debug("🧠 意圖檢測 → low reasoning（快速但準確）")
+            return "low"
 
         # 🔥 規則 2：關懷模式優先速度（用戶情緒不佳時不要讓他等）
         if user_emotion in ["sad", "angry", "fear"]:

core/retry.py

@@ -0,0 +1,150 @@
+"""
+API 重試機制
+自動重試失敗的 API 調用，支援指數退避
+"""
+
+import asyncio
+import functools
+import random
+from typing import Callable, TypeVar, Any, Optional, Tuple, Type
+
+from core.logging import get_logger
+
+logger = get_logger("core.retry")
+
+T = TypeVar("T")
+
+# 預設重試配置
+DEFAULT_MAX_RETRIES = 3
+DEFAULT_BASE_DELAY = 1.0  # 秒
+DEFAULT_MAX_DELAY = 30.0  # 秒
+DEFAULT_EXPONENTIAL_BASE = 2
+
+
+class RetryConfig:
+    """重試配置"""
+
+    def __init__(
+        self,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        base_delay: float = DEFAULT_BASE_DELAY,
+        max_delay: float = DEFAULT_MAX_DELAY,
+        exponential_base: float = DEFAULT_EXPONENTIAL_BASE,
+        jitter: bool = True,
+        retryable_exceptions: Tuple[Type[Exception], ...] = (Exception,),
+    ):
+        self.max_retries = max_retries
+        self.base_delay = base_delay
+        self.max_delay = max_delay
+        self.exponential_base = exponential_base
+        self.jitter = jitter
+        self.retryable_exceptions = retryable_exceptions
+
+    def calculate_delay(self, attempt: int) -> float:
+        """計算重試延遲（指數退避 + 抖動）"""
+        delay = self.base_delay * (self.exponential_base ** attempt)
+        delay = min(delay, self.max_delay)
+
+        if self.jitter:
+            # 添加 ±25% 的隨機抖動
+            jitter_range = delay * 0.25
+            delay += random.uniform(-jitter_range, jitter_range)
+
+        return max(0, delay)
+
+
+async def retry_async(
+    func: Callable[..., Any],
+    *args,
+    config: Optional[RetryConfig] = None,
+    **kwargs,
+) -> Any:
+    """
+    異步重試執行函數
+
+    Args:
+        func: 要執行的異步函數
+        *args: 函數參數
+        config: 重試配置
+        **kwargs: 函數關鍵字參數
+
+    Returns:
+        函數執行結果
+
+    Raises:
+        最後一次重試的異常
+    """
+    if config is None:
+        config = RetryConfig()
+
+    last_exception = None
+
+    for attempt in range(config.max_retries + 1):
+        try:
+            return await func(*args, **kwargs)
+
+        except config.retryable_exceptions as e:
+            last_exception = e
+
+            if attempt < config.max_retries:
+                delay = config.calculate_delay(attempt)
+                logger.warning(
+                    f"重試 {attempt + 1}/{config.max_retries}: "
+                    f"{func.__name__} 失敗 ({type(e).__name__}: {e})，"
+                    f"{delay:.2f}s 後重試"
+                )
+                await asyncio.sleep(delay)
+            else:
+                logger.error(
+                    f"重試耗盡: {func.__name__} 在 {config.max_retries} 次重試後仍失敗"
+                )
+
+    raise last_exception
+
+
+def with_retry(
+    max_retries: int = DEFAULT_MAX_RETRIES,
+    base_delay: float = DEFAULT_BASE_DELAY,
+    retryable_exceptions: Tuple[Type[Exception], ...] = (Exception,),
+):
+    """
+    重試裝飾器
+
+    用法：
+        @with_retry(max_retries=3)
+        async def my_api_call():
+            ...
+    """
+    config = RetryConfig(
+        max_retries=max_retries,
+        base_delay=base_delay,
+        retryable_exceptions=retryable_exceptions,
+    )
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        @functools.wraps(func)
+        async def wrapper(*args, **kwargs):
+            return await retry_async(func, *args, config=config, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+# 預設配置實例
+default_retry_config = RetryConfig()
+
+# API 調用專用配置（較短延遲）
+api_retry_config = RetryConfig(
+    max_retries=2,
+    base_delay=0.5,
+    max_delay=5.0,
+    retryable_exceptions=(ConnectionError, TimeoutError, OSError),
+)
+
+# 資料庫操作專用配置（較長延遲）
+db_retry_config = RetryConfig(
+    max_retries=3,
+    base_delay=1.0,
+    max_delay=10.0,
+)

core/tool_registry.py

@@ -0,0 +1,330 @@
+"""
+工具註冊中心
+統一管理 MCP 工具的 OpenAI Function Calling Schema
+2025 最佳實踐：讓 GPT 原生選擇工具，不需要自定義意圖檢測 Prompt
+
+重構版本：整合 Pydantic Schema 自動生成
+"""
+
+from typing import Dict, List, Any, Optional, Callable, Type
+from dataclasses import dataclass, field
+
+from core.logging import get_logger
+from core.tool_schema import (
+    ToolSchema,
+    ToolMetadata,
+    ToolSchemaRegistry,
+    tool_schema_registry,
+    extract_schema_from_mcp_tool,
+)
+
+logger = get_logger("core.tool_registry")
+
+
+@dataclass
+class ToolDefinition:
+    """工具定義（向後兼容）"""
+    name: str
+    description: str
+    parameters: Dict[str, Any]
+    handler: Optional[Callable] = None
+    category: str = "general"
+    requires_auth: bool = False
+    requires_location: bool = False
+    keywords: List[str] = field(default_factory=list)
+    examples: List[str] = field(default_factory=list)
+
+
+class ToolRegistry:
+    """
+    工具註冊中心（重構版）
+
+    功能：
+    1. 統一註冊所有 MCP 工具
+    2. 自動從 MCPTool 類別生成 OpenAI Function Calling Schema
+    3. 支援工具分類和過濾
+    4. 動態啟用/停用工具
+    5. 整合 ToolSchemaRegistry 提供 Pydantic 支援
+    """
+
+    def __init__(self):
+        self._tools: Dict[str, ToolDefinition] = {}
+        self._disabled_tools: set = set()
+        # 整合新的 Schema Registry
+        self._schema_registry = tool_schema_registry
+
+    def register(
+        self,
+        name: str,
+        description: str,
+        parameters: Dict[str, Any],
+        handler: Optional[Callable] = None,
+        category: str = "general",
+        requires_auth: bool = False,
+        requires_location: bool = False,
+        keywords: Optional[List[str]] = None,
+        examples: Optional[List[str]] = None,
+    ) -> None:
+        """註冊工具（向後兼容 + 自動同步到 Schema Registry）"""
+        self._tools[name] = ToolDefinition(
+            name=name,
+            description=description,
+            parameters=parameters,
+            handler=handler,
+            category=category,
+            requires_auth=requires_auth,
+            requires_location=requires_location,
+            keywords=keywords or [],
+            examples=examples or [],
+        )
+        
+        # 同步到 Schema Registry
+        schema = ToolSchema(
+            metadata=ToolMetadata(
+                name=name,
+                description=description,
+                category=category,
+                keywords=keywords or [],
+                examples=examples or [],
+                requires_location=requires_location,
+                requires_auth=requires_auth,
+            ),
+            input_schema=parameters,
+            handler=handler,
+        )
+        self._schema_registry.register(schema)
+        
+        logger.debug(f"註冊工具: {name}")
+
+    def register_mcp_tool(self, tool_class: Type) -> bool:
+        """
+        從 MCPTool 類別自動註冊工具
+        
+        Args:
+            tool_class: MCPTool 子類別
+        
+        Returns:
+            是否註冊成功
+        """
+        schema = extract_schema_from_mcp_tool(tool_class)
+        if not schema:
+            return False
+        
+        # 註冊到 Schema Registry
+        self._schema_registry.register(schema)
+        
+        # 同步到舊的 _tools（向後兼容）
+        self._tools[schema.metadata.name] = ToolDefinition(
+            name=schema.metadata.name,
+            description=schema.metadata.description,
+            parameters=schema.input_schema,
+            handler=schema.handler,
+            category=schema.metadata.category,
+            requires_auth=schema.metadata.requires_auth,
+            requires_location=schema.metadata.requires_location,
+            keywords=schema.metadata.keywords,
+            examples=schema.metadata.examples,
+        )
+        
+        logger.debug(f"從 MCPTool 註冊工具: {schema.metadata.name}")
+        return True
+
+    def unregister(self, name: str) -> bool:
+        """取消註冊工具"""
+        if name in self._tools:
+            del self._tools[name]
+            self._schema_registry.unregister(name)
+            return True
+        return False
+
+    def disable(self, name: str) -> None:
+        """停用工具"""
+        self._disabled_tools.add(name)
+        self._schema_registry.disable(name)
+
+    def enable(self, name: str) -> None:
+        """啟用工具"""
+        self._disabled_tools.discard(name)
+        self._schema_registry.enable(name)
+
+    def get_tool(self, name: str) -> Optional[ToolDefinition]:
+        """取得工具定義"""
+        if name in self._disabled_tools:
+            return None
+        return self._tools.get(name)
+
+    def get_openai_tools(
+        self,
+        categories: Optional[List[str]] = None,
+        include_location_tools: bool = True,
+        strict: bool = True,
+    ) -> List[Dict[str, Any]]:
+        """
+        生成 OpenAI Function Calling 格式的工具列表
+
+        Args:
+            categories: 只包含指定分類的工具
+            include_location_tools: 是否包含需要位置的工具
+            strict: 是否啟用 strict mode（確保輸出符合 schema）
+
+        Returns:
+            OpenAI tools 格式的列表
+        """
+        # 優先使用 Schema Registry（支援 strict mode）
+        return self._schema_registry.get_openai_tools(
+            categories=categories,
+            include_location_tools=include_location_tools,
+            strict=strict,
+        )
+
+    def get_openai_tools_legacy(
+        self,
+        categories: Optional[List[str]] = None,
+        include_location_tools: bool = True,
+    ) -> List[Dict[str, Any]]:
+        """
+        生成 OpenAI Function Calling 格式的工具列表（舊版，不支援 strict mode）
+        """
+        tools = []
+
+        for name, tool in self._tools.items():
+            # 跳過停用的工具
+            if name in self._disabled_tools:
+                continue
+
+            # 分類過濾
+            if categories and tool.category not in categories:
+                continue
+
+            # 位置過濾
+            if not include_location_tools and tool.requires_location:
+                continue
+
+            tools.append({
+                "type": "function",
+                "function": {
+                    "name": tool.name,
+                    "description": tool.description,
+                    "parameters": tool.parameters,
+                }
+            })
+
+        return tools
+
+    def get_tool_names(self) -> List[str]:
+        """取得所有已註冊的工具名稱"""
+        return [
+            name for name in self._tools.keys()
+            if name not in self._disabled_tools
+        ]
+
+    def get_stats(self) -> Dict[str, Any]:
+        """取得統計資訊"""
+        return self._schema_registry.get_stats()
+
+    def get_summaries(self) -> List[Dict[str, Any]]:
+        """取得所有工具摘要（用於快速意圖匹配）"""
+        return self._schema_registry.get_summaries()
+
+
+# 全域單例
+tool_registry = ToolRegistry()
+
+
+def register_mcp_tools_to_registry(mcp_server) -> int:
+    """
+    從 MCP Server 自動註冊工具到 Registry
+    
+    2025 重構版：優先使用 MCPTool 類別自動提取 Schema
+
+    Args:
+        mcp_server: MCPServer 實例
+
+    Returns:
+        註冊的工具數量
+    """
+    count = 0
+
+    for tool_name, tool in mcp_server.tools.items():
+        # 優先嘗試從 MCPTool 類別提取完整 Schema
+        if hasattr(tool, 'handler') and hasattr(tool.handler, '__self__'):
+            tool_class = tool.handler.__self__
+            if tool_registry.register_mcp_tool(type(tool_class)):
+                count += 1
+                continue
+        
+        # 降級：使用舊方法註冊
+        description = getattr(tool, 'description', f'{tool_name} 工具')
+        parameters = {"type": "object", "properties": {}, "required": []}
+
+        if hasattr(tool, 'handler') and hasattr(tool.handler, '__self__'):
+            tool_class = tool.handler.__self__
+            if hasattr(tool_class, 'get_input_schema'):
+                try:
+                    parameters = tool_class.get_input_schema()
+                except Exception as e:
+                    logger.warning(f"取得 {tool_name} schema 失敗: {e}")
+
+        # 提取關鍵字和範例
+        keywords = []
+        examples = []
+        if hasattr(tool, 'handler') and hasattr(tool.handler, '__self__'):
+            tool_class = tool.handler.__self__
+            keywords = getattr(tool_class, 'KEYWORDS', [])
+            examples = getattr(tool_class, 'USAGE_TIPS', [])
+
+        # 判斷分類
+        category = _infer_category(tool_name)
+
+        # 判斷是否需要位置
+        requires_location = _requires_location(tool_name, parameters)
+
+        tool_registry.register(
+            name=tool_name,
+            description=description,
+            parameters=parameters,
+            handler=getattr(tool, 'handler', None),
+            category=category,
+            requires_location=requires_location,
+            keywords=keywords,
+            examples=examples,
+        )
+        count += 1
+
+    logger.info(f"從 MCP Server 註冊了 {count} 個工具")
+    return count
+
+
+def _infer_category(tool_name: str) -> str:
+    """推斷工具分類"""
+    name_lower = tool_name.lower()
+
+    if any(k in name_lower for k in ['weather', 'forecast']):
+        return "weather"
+    if any(k in name_lower for k in ['bus', 'train', 'metro', 'thsr', 'youbike', 'parking']):
+        return "transportation"
+    if any(k in name_lower for k in ['geocode', 'directions', 'location']):
+        return "location"
+    if any(k in name_lower for k in ['news']):
+        return "information"
+    if any(k in name_lower for k in ['exchange', 'currency']):
+        return "finance"
+    if any(k in name_lower for k in ['health', 'heart', 'sleep', 'step']):
+        return "health"
+
+    return "general"
+
+
+def _requires_location(tool_name: str, parameters: Dict) -> bool:
+    """判斷工具是否需要位置資訊"""
+    # 檢查參數中是否有 lat/lon
+    props = parameters.get("properties", {})
+    if "lat" in props or "lon" in props or "latitude" in props or "longitude" in props:
+        return True
+
+    # 檢查工具名稱
+    location_tools = [
+        'reverse_geocode', 'directions', 'tdx_bus_arrival',
+        'tdx_youbike', 'tdx_metro', 'tdx_parking', 'tdx_train', 'tdx_thsr'
+    ]
+    return tool_name in location_tools

core/tool_router.py

@@ -0,0 +1,255 @@
+"""
+動態工具路由器
+2025 最佳實踐：根據上下文智能過濾工具，減少 token 消耗
+
+功能：
+1. 位置過濾：用戶沒有位置時，排除需要位置的工具
+2. 關鍵字過濾：根據用戶意圖關鍵字，優先顯示相關分類
+3. 時間過濾：根據時間排除不適用的工具
+4. 優先級排序：常用工具優先顯示
+"""
+
+import re
+import logging
+from typing import Dict, List, Any, Optional, Set
+from datetime import datetime
+
+from core.logging import get_logger
+
+logger = get_logger("core.tool_router")
+
+
+class ToolRouter:
+    """
+    動態工具路由器
+    
+    根據上下文智能過濾和排序工具，減少傳遞給 GPT 的工具數量
+    """
+    
+    # 分類關鍵字映射
+    CATEGORY_KEYWORDS = {
+        "weather": ["天氣", "氣溫", "下雨", "晴天", "陰天", "weather", "溫度", "濕度"],
+        "transportation": [
+            "公車", "巴士", "bus", "火車", "台鐵", "高鐵", "捷運", "metro",
+            "youbike", "ubike", "微笑單車", "共享單車", "停車場", "停車位"
+        ],
+        "location": ["我在哪", "這是哪", "位置", "地址", "怎麼去", "導航", "路線"],
+        "information": ["新聞", "消息", "報導", "news"],
+        "finance": ["匯率", "換算", "美元", "日圓", "歐元", "currency", "exchange"],
+        "health": ["心率", "步數", "血氧", "睡眠", "健康", "運動"],
+    }
+    
+    # 時間敏感工具（深夜可能不適用）
+    NIGHT_EXCLUDED_TOOLS = {
+        "tdx_bus_arrival",  # 深夜公車班次少
+        "tdx_metro",        # 捷運深夜停駛
+    }
+    
+    # 工具優先級（數字越小優先級越高）
+    DEFAULT_PRIORITY = {
+        "weather_query": 1,
+        "reverse_geocode": 2,
+        "forward_geocode": 3,
+        "directions": 4,
+        "tdx_bus_arrival": 5,
+        "tdx_youbike": 6,
+        "tdx_metro": 7,
+        "tdx_train": 8,
+        "tdx_thsr": 9,
+        "news_query": 10,
+        "exchange_query": 11,
+        "healthkit_query": 12,
+        "tdx_parking": 13,
+    }
+    
+    def __init__(self):
+        self._user_preferences: Dict[str, Dict[str, int]] = {}  # user_id -> {tool_name: usage_count}
+    
+    def filter_tools(
+        self,
+        tools: List[Dict[str, Any]],
+        message: str,
+        context: Optional[Dict[str, Any]] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        根據上下文過濾和排序工具
+        
+        Args:
+            tools: OpenAI tools 格式的工具列表
+            message: 用戶消息
+            context: 上下文資訊（位置、時間、用戶偏好等）
+        
+        Returns:
+            過濾和排序後的工具列表
+        """
+        context = context or {}
+        
+        # 1. 檢測用戶意圖分類
+        detected_categories = self._detect_categories(message)
+        logger.debug(f"🎯 檢測到的分類: {detected_categories}")
+        
+        # 2. 過濾工具
+        filtered_tools = []
+        for tool in tools:
+            tool_name = tool.get("function", {}).get("name", "")
+            
+            # 位置過濾
+            if not self._check_location_requirement(tool_name, context):
+                logger.debug(f"⏭️ 跳過 {tool_name}（需要位置但用戶未提供）")
+                continue
+            
+            # 時間過濾
+            if not self._check_time_requirement(tool_name, context):
+                logger.debug(f"⏭️ 跳過 {tool_name}（深夜不適用）")
+                continue
+            
+            filtered_tools.append(tool)
+        
+        # 3. 排序工具（相關分類優先）
+        sorted_tools = self._sort_tools(filtered_tools, detected_categories, context)
+        
+        # 4. 限制工具數量（減少 token 消耗）
+        max_tools = self._get_max_tools(detected_categories)
+        if len(sorted_tools) > max_tools:
+            logger.info(f"📉 工具數量從 {len(sorted_tools)} 限制到 {max_tools}")
+            sorted_tools = sorted_tools[:max_tools]
+        
+        logger.info(f"🔧 過濾後工具: {[t['function']['name'] for t in sorted_tools]}")
+        return sorted_tools
+    
+    def _detect_categories(self, message: str) -> Set[str]:
+        """檢測用戶消息中的意圖分類"""
+        message_lower = message.lower()
+        detected = set()
+        
+        for category, keywords in self.CATEGORY_KEYWORDS.items():
+            for keyword in keywords:
+                if keyword.lower() in message_lower:
+                    detected.add(category)
+                    break
+        
+        return detected
+    
+    def _check_location_requirement(
+        self,
+        tool_name: str,
+        context: Dict[str, Any],
+    ) -> bool:
+        """檢查工具的位置需求"""
+        # 需要位置的工具
+        location_required_tools = {
+            "reverse_geocode",
+            "tdx_bus_arrival",
+            "tdx_youbike",
+            "tdx_metro",
+            "tdx_parking",
+            "tdx_train",
+            "tdx_thsr",
+        }
+        
+        if tool_name not in location_required_tools:
+            return True
+        
+        # 檢查是否有位置資訊
+        has_location = (
+            context.get("lat") is not None and
+            context.get("lon") is not None
+        )
+        
+        # 如果沒有位置，但用戶明確要求（如「附近的公車」），仍然保留工具
+        # 讓工具自己處理缺少位置的情況
+        return True  # 暫時不嚴格過濾，讓工具自己處理
+    
+    def _check_time_requirement(
+        self,
+        tool_name: str,
+        context: Dict[str, Any],
+    ) -> bool:
+        """檢查工具的時間需求"""
+        if tool_name not in self.NIGHT_EXCLUDED_TOOLS:
+            return True
+        
+        # 檢查是否為深夜（00:00 - 05:00）
+        current_hour = context.get("hour")
+        if current_hour is None:
+            current_hour = datetime.now().hour
+        
+        is_night = 0 <= current_hour < 5
+        
+        # 深夜時排除某些工具
+        return not is_night
+    
+    def _sort_tools(
+        self,
+        tools: List[Dict[str, Any]],
+        detected_categories: Set[str],
+        context: Dict[str, Any],
+    ) -> List[Dict[str, Any]]:
+        """排序工具（相關分類優先）"""
+        
+        def get_priority(tool: Dict[str, Any]) -> int:
+            tool_name = tool.get("function", {}).get("name", "")
+            
+            # 基礎優先級
+            base_priority = self.DEFAULT_PRIORITY.get(tool_name, 100)
+            
+            # 如果工具屬於檢測到的分類，降低優先級數字（提高優先級）
+            tool_category = self._get_tool_category(tool_name)
+            if tool_category in detected_categories:
+                base_priority -= 50  # 相關工具優先
+            
+            # 用戶偏好加成
+            user_id = context.get("user_id")
+            if user_id and user_id in self._user_preferences:
+                usage_count = self._user_preferences[user_id].get(tool_name, 0)
+                base_priority -= min(usage_count, 10)  # 最多降低 10
+            
+            return base_priority
+        
+        return sorted(tools, key=get_priority)
+    
+    def _get_tool_category(self, tool_name: str) -> str:
+        """取得工具的分類"""
+        category_map = {
+            "weather_query": "weather",
+            "reverse_geocode": "location",
+            "forward_geocode": "location",
+            "directions": "location",
+            "tdx_bus_arrival": "transportation",
+            "tdx_youbike": "transportation",
+            "tdx_metro": "transportation",
+            "tdx_train": "transportation",
+            "tdx_thsr": "transportation",
+            "tdx_parking": "transportation",
+            "news_query": "information",
+            "exchange_query": "finance",
+            "healthkit_query": "health",
+        }
+        return category_map.get(tool_name, "general")
+    
+    def _get_max_tools(self, detected_categories: Set[str]) -> int:
+        """根據檢測到的分類決定最大工具數量"""
+        if not detected_categories:
+            # 沒有明確分類，返回所有工具
+            return 20
+        
+        if len(detected_categories) == 1:
+            # 單一分類，但仍需要保留足夠工具（如 directions）
+            return 12
+        
+        # 多個分類
+        return 15
+    
+    def record_tool_usage(self, user_id: str, tool_name: str) -> None:
+        """記錄工具使用（用於優先級調整）"""
+        if user_id not in self._user_preferences:
+            self._user_preferences[user_id] = {}
+        
+        current = self._user_preferences[user_id].get(tool_name, 0)
+        self._user_preferences[user_id][tool_name] = current + 1
+        
+        logger.debug(f"📊 記錄工具使用: {user_id} -> {tool_name} ({current + 1})")
+
+
+# 全域單例
+tool_router = ToolRouter()

core/tool_schema.py

@@ -0,0 +1,355 @@
+"""
+Pydantic 工具 Schema 定義
+2025 最佳實踐：使用 Pydantic 自動生成 OpenAI Function Calling Schema
+
+功能：
+1. 工具輸入/輸出的 Pydantic 基礎類別
+2. 自動生成 OpenAI tools 格式的 JSON Schema
+3. 支援 strict mode 確保 100% 有效輸出
+4. 裝飾器模式自動註冊工具
+"""
+
+from typing import Dict, Any, Optional, List, Callable, Type, TypeVar, get_type_hints
+from dataclasses import dataclass, field
+from functools import wraps
+import inspect
+import logging
+
+logger = logging.getLogger("core.tool_schema")
+
+# 類型變數
+T = TypeVar("T")
+
+
+@dataclass
+class ToolMetadata:
+    """
+    工具元資料（增強版）
+    
+    2025 最佳實踐：豐富的元資料讓 GPT 更容易理解何時使用哪個工具
+    """
+    name: str
+    description: str
+    category: str = "general"
+    keywords: List[str] = field(default_factory=list)  # 觸發關鍵字
+    examples: List[str] = field(default_factory=list)  # 使用範例
+    negative_examples: List[str] = field(default_factory=list)  # 不應使用的情況
+    requires_location: bool = False
+    requires_auth: bool = False
+    is_complex: bool = False
+    priority: int = 100  # 優先級（數字越小越優先）
+    aliases: List[str] = field(default_factory=list)  # 工具別名
+
+
+@dataclass
+class ToolSchema:
+    """工具 Schema 定義（自描述）"""
+    metadata: ToolMetadata
+    input_schema: Dict[str, Any]
+    output_schema: Optional[Dict[str, Any]] = None
+    handler: Optional[Callable] = None
+
+    def to_openai_tool(self, strict: bool = True) -> Dict[str, Any]:
+        """
+        轉換為 OpenAI Function Calling 格式
+        
+        Args:
+            strict: 是否啟用 strict mode（確保輸出符合 schema）
+        
+        Returns:
+            OpenAI tools 格式的字典
+        """
+        # 確保 schema 符合 OpenAI strict mode 要求
+        parameters = self._prepare_strict_schema(self.input_schema) if strict else self.input_schema
+        
+        tool_def = {
+            "type": "function",
+            "function": {
+                "name": self.metadata.name,
+                "description": self._build_rich_description(),
+                "parameters": parameters,
+            }
+        }
+        
+        if strict:
+            tool_def["function"]["strict"] = True
+        
+        return tool_def
+
+    def _build_rich_description(self) -> str:
+        """
+        建構豐富的工具描述（包含範例、關鍵字、負面範例）
+        讓 GPT 更容易理解何時使用此工具
+        
+        2025 最佳實踐：
+        - 正面範例：告訴 GPT 何時使用
+        - 負面範例：告訴 GPT 何時不要使用（減少誤判）
+        """
+        desc_parts = [self.metadata.description]
+        
+        # 加入關鍵字提示
+        if self.metadata.keywords:
+            keywords_str = "、".join(self.metadata.keywords[:5])
+            desc_parts.append(f"觸發詞：{keywords_str}")
+        
+        # 加入使用範例（正面）
+        if self.metadata.examples:
+            examples_str = "；".join(self.metadata.examples[:3])
+            desc_parts.append(f"適用：{examples_str}")
+        
+        # 加入負面範例（告訴 GPT 何時不要使用）
+        if self.metadata.negative_examples:
+            neg_str = "；".join(self.metadata.negative_examples[:2])
+            desc_parts.append(f"不適用：{neg_str}")
+        
+        return "。".join(desc_parts)
+
+    def _prepare_strict_schema(self, schema: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        準備符合 OpenAI strict mode 的 schema
+        
+        strict mode 要求：
+        1. additionalProperties: false
+        2. 所有屬性都在 required 中（或有 default）
+        3. 不支援 oneOf/anyOf/allOf
+        """
+        result = dict(schema)
+        
+        # 確保是 object 類型
+        if result.get("type") != "object":
+            result = {"type": "object", "properties": result}
+        
+        # 添加 additionalProperties: false
+        result["additionalProperties"] = False
+        
+        # 確保所有屬性都在 required 中
+        properties = result.get("properties", {})
+        existing_required = set(result.get("required", []))
+        
+        # 收集所有沒有 default 的屬性
+        all_required = []
+        for prop_name, prop_schema in properties.items():
+            if prop_name in existing_required or "default" not in prop_schema:
+                all_required.append(prop_name)
+        
+        result["required"] = all_required
+        
+        return result
+
+    def get_summary(self) -> Dict[str, Any]:
+        """獲取工具摘要（用於快速意圖匹配）"""
+        return {
+            "name": self.metadata.name,
+            "description": self.metadata.description[:50] + "..." if len(self.metadata.description) > 50 else self.metadata.description,
+            "category": self.metadata.category,
+            "keywords": self.metadata.keywords,
+            "params": list(self.input_schema.get("properties", {}).keys())
+        }
+
+
+def extract_schema_from_mcp_tool(tool_class: Type) -> Optional[ToolSchema]:
+    """
+    從現有 MCPTool 類別提取 Schema（增強版）
+    
+    Args:
+        tool_class: MCPTool 子類別
+    
+    Returns:
+        ToolSchema 或 None
+    """
+    try:
+        # 檢查必要屬性
+        if not hasattr(tool_class, "NAME") or not hasattr(tool_class, "get_input_schema"):
+            return None
+        
+        name = getattr(tool_class, "NAME", "")
+        if not name:
+            return None
+        
+        # 提取元資料（增強版）
+        metadata = ToolMetadata(
+            name=name,
+            description=getattr(tool_class, "DESCRIPTION", f"{name} 工具"),
+            category=getattr(tool_class, "CATEGORY", "general"),
+            keywords=getattr(tool_class, "KEYWORDS", []),
+            examples=getattr(tool_class, "USAGE_TIPS", []),
+            negative_examples=getattr(tool_class, "NEGATIVE_EXAMPLES", []),
+            requires_location=_check_requires_location(tool_class),
+            requires_auth=getattr(tool_class, "REQUIRES_AUTH", False),
+            is_complex=getattr(tool_class, "IS_COMPLEX", False),
+            priority=getattr(tool_class, "PRIORITY", 100),
+            aliases=getattr(tool_class, "ALIASES", []),
+        )
+        
+        # 提取 input schema
+        try:
+            input_schema = tool_class.get_input_schema()
+        except Exception as e:
+            logger.warning(f"提取 {name} input schema 失敗: {e}")
+            input_schema = {"type": "object", "properties": {}}
+        
+        # 提取 output schema（可選）
+        output_schema = None
+        if hasattr(tool_class, "get_output_schema"):
+            try:
+                output_schema = tool_class.get_output_schema()
+            except Exception:
+                pass
+        
+        # 提取 handler
+        handler = None
+        if hasattr(tool_class, "execute"):
+            handler = tool_class.execute
+        
+        return ToolSchema(
+            metadata=metadata,
+            input_schema=input_schema,
+            output_schema=output_schema,
+            handler=handler,
+        )
+    
+    except Exception as e:
+        logger.error(f"提取 {tool_class} schema 失敗: {e}")
+        return None
+
+
+def _check_requires_location(tool_class: Type) -> bool:
+    """檢查工具是否需要位置資訊"""
+    # 檢查類別屬性
+    if getattr(tool_class, "REQUIRES_LOCATION", False):
+        return True
+    
+    # 檢查 input schema 中是否有 lat/lon
+    try:
+        schema = tool_class.get_input_schema()
+        props = schema.get("properties", {})
+        if "lat" in props or "lon" in props:
+            return True
+    except Exception:
+        pass
+    
+    # 檢查工具名稱
+    name = getattr(tool_class, "NAME", "").lower()
+    location_tools = [
+        "reverse_geocode", "directions", "tdx_bus_arrival",
+        "tdx_youbike", "tdx_metro", "tdx_parking", "tdx_train", "tdx_thsr"
+    ]
+    return name in location_tools
+
+
+class ToolSchemaRegistry:
+    """
+    工具 Schema 註冊中心
+    
+    功能：
+    1. 統一管理所有工具的 Schema
+    2. 自動生成 OpenAI Function Calling 格式
+    3. 支援動態過濾和分組
+    """
+    
+    def __init__(self):
+        self._schemas: Dict[str, ToolSchema] = {}
+        self._disabled: set = set()
+    
+    def register(self, schema: ToolSchema) -> None:
+        """註冊工具 Schema"""
+        self._schemas[schema.metadata.name] = schema
+        logger.debug(f"註冊工具 Schema: {schema.metadata.name}")
+    
+    def register_from_mcp_tool(self, tool_class: Type) -> bool:
+        """從 MCPTool 類別註冊"""
+        schema = extract_schema_from_mcp_tool(tool_class)
+        if schema:
+            self.register(schema)
+            return True
+        return False
+    
+    def unregister(self, name: str) -> bool:
+        """取消註冊"""
+        if name in self._schemas:
+            del self._schemas[name]
+            return True
+        return False
+    
+    def disable(self, name: str) -> None:
+        """停用工具"""
+        self._disabled.add(name)
+    
+    def enable(self, name: str) -> None:
+        """啟用工具"""
+        self._disabled.discard(name)
+    
+    def get(self, name: str) -> Optional[ToolSchema]:
+        """取得工具 Schema"""
+        if name in self._disabled:
+            return None
+        return self._schemas.get(name)
+    
+    def get_openai_tools(
+        self,
+        categories: Optional[List[str]] = None,
+        include_location_tools: bool = True,
+        strict: bool = True,
+    ) -> List[Dict[str, Any]]:
+        """
+        生成 OpenAI Function Calling 格式的工具列表
+        
+        Args:
+            categories: 只包含指定分類的工具
+            include_location_tools: 是否包含需要位置的工具
+            strict: 是否啟用 strict mode
+        
+        Returns:
+            OpenAI tools 格式的列表
+        """
+        tools = []
+        
+        for name, schema in self._schemas.items():
+            # 跳過停用的工具
+            if name in self._disabled:
+                continue
+            
+            # 分類過濾
+            if categories and schema.metadata.category not in categories:
+                continue
+            
+            # 位置過濾
+            if not include_location_tools and schema.metadata.requires_location:
+                continue
+            
+            tools.append(schema.to_openai_tool(strict=strict))
+        
+        return tools
+    
+    def get_tool_names(self) -> List[str]:
+        """取得所有已註冊的工具名稱"""
+        return [
+            name for name in self._schemas.keys()
+            if name not in self._disabled
+        ]
+    
+    def get_summaries(self) -> List[Dict[str, Any]]:
+        """取得所有工具摘要（用於快速意圖匹配）"""
+        return [
+            schema.get_summary()
+            for name, schema in self._schemas.items()
+            if name not in self._disabled
+        ]
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """取得統計資訊"""
+        categories = {}
+        for schema in self._schemas.values():
+            cat = schema.metadata.category
+            categories[cat] = categories.get(cat, 0) + 1
+        
+        return {
+            "total": len(self._schemas),
+            "disabled": len(self._disabled),
+            "active": len(self._schemas) - len(self._disabled),
+            "categories": categories,
+        }
+
+
+# 全域單例
+tool_schema_registry = ToolSchemaRegistry()

features/mcp/agent_bridge.py

@@ -111,6 +111,7 @@ class MCPAgentBridge:
             ToolMetadata(
                 name="reverse_geocode",
                 requires_env={"lat", "lon"},
+                enable_reformat=True,
             )
         )
         register(
@@ -214,9 +215,70 @@ class MCPAgentBridge:
             await self.mcp_server.start_external_servers()
             logger.info(f"異步初始化完成，完整可用 MCP 工具數量: {len(self.mcp_server.tools)}")
 
+        # 將 MCP Server 的工具註冊到 tool_registry
+        self._sync_tools_to_registry()
+
         # 2025 最佳實踐：啟動時預熱熱門查詢快取
         await self._preheat_cache()
 
+    def _sync_tools_to_registry(self) -> int:
+        """
+        將 MCP Server 的工具同步到 tool_registry
+        
+        Returns:
+            註冊的工具數量
+        """
+        from core.tool_registry import tool_registry
+        
+        count = 0
+        for tool_name, tool in self.mcp_server.tools.items():
+            # 取得工具描述
+            description = getattr(tool, 'description', f'{tool_name} 工具')
+            
+            # 取得參數 Schema
+            parameters = {"type": "object", "properties": {}, "required": []}
+            keywords = []
+            examples = []
+            negative_examples = []
+            category = "general"
+            priority = 100
+            
+            if hasattr(tool, 'handler') and hasattr(tool.handler, '__self__'):
+                tool_class = tool.handler.__self__
+                
+                # 嘗試從 MCPTool 類別提取完整資訊
+                if hasattr(tool_class, 'get_input_schema'):
+                    try:
+                        parameters = tool_class.get_input_schema()
+                    except Exception as e:
+                        logger.warning(f"取得 {tool_name} schema 失敗: {e}")
+                
+                # 提取增強元資料
+                keywords = getattr(tool_class, 'KEYWORDS', [])
+                examples = getattr(tool_class, 'USAGE_TIPS', [])
+                negative_examples = getattr(tool_class, 'NEGATIVE_EXAMPLES', [])
+                category = getattr(tool_class, 'CATEGORY', 'general')
+                priority = getattr(tool_class, 'PRIORITY', 100)
+            
+            # 判斷是否需要位置
+            props = parameters.get("properties", {})
+            requires_location = "lat" in props or "lon" in props
+            
+            tool_registry.register(
+                name=tool_name,
+                description=description,
+                parameters=parameters,
+                handler=getattr(tool, 'handler', None),
+                category=category,
+                requires_location=requires_location,
+                keywords=keywords,
+                examples=examples,
+            )
+            count += 1
+        
+        logger.info(f"🔧 同步 {count} 個工具到 tool_registry")
+        return count
+
     def _normalize_tool_name(self, raw_name: Optional[str]) -> Optional[str]:
         """
         將 GPT 回傳的工具名稱正規化為註冊表中的實際名稱。
@@ -414,8 +476,11 @@ class MCPAgentBridge:
     async def detect_intent(self, message: str) -> Tuple[bool, Optional[Dict[str, Any]]]:
         """
         檢測用戶消息中的意圖 (保持與舊 FeatureRouter 相同介面)
-        使用 OpenAI Structured Outputs 確保100%返回有效JSON
-        帶快取機制，相同消息直接返回
+        
+        2025 重構版：使用 OpenAI 原生 Function Calling
+        - 不再使用巨大的 system_prompt 描述每個工具
+        - 工具定義由 tools 參數傳遞，GPT 原生選擇
+        - 新增工具只需註冊到 Registry，不需更新任何 prompt
 
         參數:
         message (str): 用戶消息
@@ -423,362 +488,130 @@ class MCPAgentBridge:
         返回:
         tuple: (是否檢測到意圖, 意圖數據)
         """
+        # 使用新的 IntentDetector（基於 OpenAI Function Calling）
+        return await self._detect_intent_with_function_calling(message)
+
+    async def _detect_intent_with_function_calling(self, message: str) -> Tuple[bool, Optional[Dict[str, Any]]]:
+        """
+        使用 OpenAI 原生 Function Calling 進行意圖檢測
+        
+        核心改進：
+        1. 工具定義自動從 Registry 生成
+        2. GPT 原生選擇工具並生成結構化參數
+        3. 不需要自定義 prompt 描述每個工具
+        """
         import hashlib
         import time as time_module
-
+        
         # 生成快取鍵
         cache_key = hashlib.md5(message.encode()).hexdigest()
 
         # 檢查快取
         if cache_key in self._intent_cache:
             has_feature, intent_data, cached_time = self._intent_cache[cache_key]
-            # 檢查是否過期
             if time_module.time() - cached_time < self._intent_cache_ttl:
                 logger.debug(f"💾 意圖快取命中: {message[:50]}...")
                 return has_feature, intent_data
             else:
-                # 過期，刪除快取
                 del self._intent_cache[cache_key]
 
-        logger.info(f"檢測意圖: \"{message}\"")
-        logger.debug("意圖偵測輸入 - user_id=%s, chat_id=%s", "intent_detection", None)
+        logger.info(f"🔍 檢測意圖（Function Calling）: \"{message[:100]}...\"")
 
         # 檢查特殊命令
         for command in ["功能列表", "有什麼功能", "能做什麼"]:
             if command in message:
                 logger.info(f"檢測到特殊命令: {command}")
-                return True, {
-                    "type": "special_command",
-                    "command": "feature_list"
-                }
+                return True, {"type": "special_command", "command": "feature_list"}
 
-        # 使用 GPT + Structured Outputs 進行意圖解析
         try:
-            logger.info("開始使用 GPT Structured Outputs 進行意圖解析")
-
-            # 構建可用工具的描述
-            tools_description = self._get_tools_description()
-
-            # GPT 意圖解析 Prompt - 適配新的 schema（不使用 oneOf）
-            system_prompt = f"""你是一個精確的意圖解析助手。
-
-可用工具：
-{tools_description}
-
-任務：分析用戶消息，決定是否需要調用工具，並判斷用戶情緒。
-
-重要規則：
-1. 健康相關需求（心率、步數、血氧、呼吸、睡眠）使用 healthkit_query
-2. 不需要傳入 user_id，系統會自動補齊
-3. 若無法判斷具體參數，使用合理預設值
-4. 一般閒聊設置 is_tool_call 為 false
-
-特殊處理：
-- 天氣查詢：城市名稱必須使用英文（如 Taipei, Tokyo, New York）
-  * 台北 → Taipei
-  * 東京 → Tokyo
-  * 紐約 → New York
-  * 倫敦 → London
-  * 巴黎 → Paris
-  * 如無指定城市，預設使用 Taipei
-
-- 匯率查詢：
-  * 必須明確指定 from_currency 和 to_currency（ISO 4217 代碼）
-  * 預設：from_currency=USD, to_currency=TWD
-  * 美元 → USD, 台幣 → TWD, 日圓 → JPY, 歐元 → EUR
-  * 金額預設 amount=1.0, conversion=true
-
-- 新聞查詢：
-  * 任何提到「新聞」「消息」「報導」的請求都使用 news_query
-  * 參數：query（關鍵詞）、country（國家，預設 tw）、category（分類，預設 top）、language（語言，預設 zh）
-  * 今日新聞、科技新聞、台灣新聞都應該調用此工具
-
-- 公車查詢（重要！）：
-  * 任何提到「公車」「巴士」「幾號公車」「什麼時候來」的請求都使用 tdx_bus_arrival
-  * **參數名稱是 route_name（不是 stop_name）**
-  * 從用戶訊息中提取路線號碼（如「137」「紅30」「307」）
-  * 範例：
-    - 「137公車什麼時候來」→ tdx_bus_arrival:route_name=137
-    - 「307還要多久」→ tdx_bus_arrival:route_name=307
-    - 「附近有什麼公車」→ tdx_bus_arrival（不需參數，系統自動用 GPS 查詢附近站點）
-    - 「紅30公車」→ tdx_bus_arrival:route_name=紅30
-  * ❌ 錯誤：tdx_bus_arrival:stop_name=137
-  * ✅ 正確：tdx_bus_arrival:route_name=137
-
-- 台鐵/火車查詢（重要！）：
-  * 任何提到「火車」「台鐵」「列車」「自強號」「莒光號」「區間車」的請求都使用 tdx_train
-  * **參數名稱是 origin_station（起站）和 destination_station（迄站）**
-  * **「往XX」「到XX」「去XX」表示目的地（destination_station），不是起點！**
-  * **「從XX」「在XX」表示起點（origin_station）**
-  * **如果用戶沒有明確說起點，就不要填 origin_station，讓系統用 GPS 自動找最近車站**
-  * 範例：
-    - 「往台北的火車」→ tdx_train:destination_station=台北（只填目的地，起點由 GPS 決定）
-    - 「到高雄的火車」→ tdx_train:destination_station=高雄（只填目的地）
-    - 「從桃園到台北」→ tdx_train:origin_station=桃園,destination_station=台北（明確說了起點）
-    - 「台北到台中的火車」→ tdx_train:origin_station=台北,destination_station=台中
-    - 「下一班火車」→ tdx_train（不需參數，系統自動用 GPS 查詢最近車站）
-    - 「自強號 123 次」→ tdx_train:train_no=123
-  * ❌ 錯誤：「往台北」解析為 origin_station=台灣,destination_station=台北（不要亂填起點！）
-  * ❌ 錯誤：「往台北」解析為 origin_station=台北（方向搞反了）
-  * ✅ 正確：「往台北」解析為 destination_station=台北（只填目的地）
-
-- YouBike/共享單車查詢（重要！必須識別！）：
-  * 任何提到以下關鍵詞的請求都使用 tdx_youbike：
-    - 「YouBike」「Youbike」「youbike」「YOUBIKE」
-    - 「UBike」「Ubike」「ubike」「UBIKE」
-    - 「微笑單車」「共享單車」「公共單車」
-    - 「腳踏車站」「單車站」「自行車站」
-    - 「借車」「還車」（在單車語境下）
-    - 「最近的站點」「附近站點」（在單車語境下）
-  * **不是 tdx_parking！YouBike 是��車，不是停車場**
-  * **不是一般聊天！這是工具調用！**
-  * 範例：
-    - 「附近的 YouBike」→ tdx_youbike（不需參數，系統自動用 GPS 查詢）
-    - 「離我最近的 Ubike 站點」→ tdx_youbike
-    - 「最近的Ubike站點」→ tdx_youbike
-    - 「Ubike在哪」→ tdx_youbike
-    - 「哪裡有Ubike」→ tdx_youbike
-    - 「市政府 YouBike 還有車嗎」→ tdx_youbike:station_name=市政府
-  * ❌ 錯誤：is_tool_call=false（這不是聊天！）
-  * ❌ 錯誤：tdx_parking:query=Ubike
-  * ✅ 正確：tdx_youbike
-
-- 停車場查詢：
-  * 任何提到「停車場」「停車位」「汽車停車」的請求才使用 tdx_parking
-  * 範例：
-    - 「附近的停車場」→ tdx_parking
-    - 「市政府停車場」→ tdx_parking:parking_name=市政府
-
-- 地點查詢與導航（重要！）：
-  * **當前位置查詢**：
-    - 問「我在哪」「這是哪裡」「現在在哪」「我的位置」→ 使用 reverse_geocode（不需參數，系統自動用 GPS 座標）
-    - ❌ 錯誤：forward_geocode:query=我在哪
-    - ✅ 正確：reverse_geocode
-  * **導航需求判斷**：
-    - 問「怎麼去 X」「如何去 X」「去 X 怎麼走」「到 X 怎麼走」→ 使用 forward_geocode 查詢目的地座標
-    - 問「從 A 到 B 要多久」「A 到 B 怎麼走」→ 同時使用 forward_geocode 查詢起點與終點
-  * **不要猜測座標**：
-    - ❌ 錯誤：directions:origin_lat=25.1288,origin_lon=121.9234,dest_lat=24.9932,dest_lon=121.3261
-    - ✅ 正確：forward_geocode:query=銘傳大學桃園校區
-  * **工具使用順序**：
-    1. 先使用 forward_geocode 將地點名稱轉換為座標
-    2. 再使用 directions 規劃路線（系統會自動處理）
-  * **範例**：
-    - 「我在哪」→ reverse_geocode（系統自動補 lat/lon）
-    - 「怎麼去桃園火車站」→ forward_geocode:query=桃園火車站
-    - 「從銘傳大學到桃園火車站」→ forward_geocode:query=銘傳大學桃園校區
-    - 「台北車站到淡水捷運站」→ forward_geocode:query=台北車站
-
-情緒判斷（emotion）：
-根據文字的語氣、用詞、標點符號判斷用戶情緒，選擇以下之一：
-- neutral: 平靜、中性（預設）
-- happy: 開心、興奮、愉快（如「好開心！」「太棒了」「哈哈」）
-- sad: 難過、沮喪、失落（如「好難過」「唉...」「心情不好」）
-- angry: 生氣、憤怒、煩躁（如「煩死了」「幹嘛啦」「氣死我了」）
-- fear: 恐懼、擔心、焦慮（如「好害怕」「好擔心」「怎麼辦」）
-- surprise: 驚訝、意外（如「什麼！」「真的假的」「不會吧」）
-
-回應格式：
-- is_tool_call: true/false（是否調用工具）
-- tool_name: 工具名稱和參數（僅當 is_tool_call=true 時提供，格式：tool_name:param1=value1,param2=value2）
-- emotion: 用戶情緒標籤（必填）
-
-示例：
-- "我在哪" → {{"is_tool_call": true, "tool_name": "reverse_geocode", "emotion": "neutral"}}
-- "這是哪裡" → {{"is_tool_call": true, "tool_name": "reverse_geocode", "emotion": "neutral"}}
-- "台北天氣" → {{"is_tool_call": true, "tool_name": "weather_query:city=Taipei", "emotion": "neutral"}}
-- "好開心！今天天氣好嗎" → {{"is_tool_call": true, "tool_name": "weather_query:city=Taipei", "emotion": "happy"}}
-- "美元匯率" → {{"is_tool_call": true, "tool_name": "exchange_query:from_currency=USD,to_currency=TWD,amount=1.0", "emotion": "neutral"}}
-- "今日新聞" → {{"is_tool_call": true, "tool_name": "news_query:country=tw,language=zh", "emotion": "neutral"}}
-- "科技新聞" → {{"is_tool_call": true, "tool_name": "news_query:query=科技,category=technology,language=zh", "emotion": "neutral"}}
-- "最近的Ubike站點" → {{"is_tool_call": true, "tool_name": "tdx_youbike", "emotion": "neutral"}}
-- "附近的YouBike" → {{"is_tool_call": true, "tool_name": "tdx_youbike", "emotion": "neutral"}}
-- "Ubike在哪" → {{"is_tool_call": true, "tool_name": "tdx_youbike", "emotion": "neutral"}}
-- "往台北的火車" → {{"is_tool_call": true, "tool_name": "tdx_train:destination_station=台北", "emotion": "neutral"}}
-- "你好" → {{"is_tool_call": false, "tool_name": "", "emotion": "neutral"}}
-- "我好難過..." → {{"is_tool_call": false, "tool_name": "", "emotion": "sad"}}
-- "煩死了" → {{"is_tool_call": false, "tool_name": "", "emotion": "angry"}}"""
-
+            # 從 tool_registry 取得 OpenAI tools 格式
+            from core.tool_registry import tool_registry
+            from core.tool_router import tool_router
+            
+            all_tools = tool_registry.get_openai_tools(strict=False)
+            
+            if not all_tools:
+                logger.warning("⚠️ 沒有可用的工具，降級為聊天")
+                return False, {"emotion": "neutral"}
+            
+            # 使用 ToolRouter 動態過濾和排序工具
+            context = {"hour": datetime.now().hour}
+            tools = tool_router.filter_tools(all_tools, message, context)
+            
+            logger.info(f"🔧 載入 {len(all_tools)} 個工具，過濾後 {len(tools)} 個")
+            
+            # 建構精簡的 system prompt（只處理特殊規則）
+            system_prompt = self._build_function_calling_prompt()
+            
             messages = [
                 {"role": "system", "content": system_prompt},
                 {"role": "user", "content": message}
             ]
-
-            # 使用 Structured Outputs（動態推理強度）
+            
+            # 使用 OpenAI Function Calling
+            from core.reasoning_strategy import get_optimal_reasoning_effort
             optimal_effort = get_optimal_reasoning_effort("intent_detection")
             logger.info(f"🧠 意圖檢測推理強度: {optimal_effort}")
-
-            response = await ai_service.generate_response_for_user(
+            
+            response = await ai_service.generate_response_with_tools(
                 messages=messages,
+                tools=tools,
                 user_id="intent_detection",
-                model="gpt-5-nano",
-                chat_id=None,
-                use_structured_outputs=True,
-                response_schema=self._get_intent_schema(),
-                reasoning_effort=optimal_effort  # 動態調整
+                model="gpt-4o-mini",  # 使用更強的模型以提升參數提取準確度
+                reasoning_effort=None,  # gpt-4o-mini 不支援 reasoning_effort
+                tool_choice="auto",
             )
-
-            logger.debug("GPT Structured Outputs 回應: %s", response)
-
-            # 檢查是否為 fallback 錯誤訊息
-            if response.strip() in ["抱歉，我暫時沒有合適的回應。可以換個說法再試試嗎？", "抱歉，生成回應時遇到問題。請重試。"]:
-                logger.warning("Structured Outputs 返回 fallback 訊息，視為失敗")
-                raise Exception("Structured Outputs failed with fallback message")
-
-            # Structured Outputs 保證返回有效JSON，直接解析
-            try:
-                response_text = response.strip()
-                
-                # 處理 GPT 回應重複 JSON 的情況（如 {...}{...}）
-                # 只取第一個完整的 JSON 物件
-                if response_text.startswith("{"):
-                    brace_count = 0
-                    end_idx = 0
-                    for i, char in enumerate(response_text):
-                        if char == "{":
-                            brace_count += 1
-                        elif char == "}":
-                            brace_count -= 1
-                            if brace_count == 0:
-                                end_idx = i + 1
-                                break
-                    if end_idx > 0:
-                        response_text = response_text[:end_idx]
+            
+            # 解析回應
+            tool_calls = response.get("tool_calls", [])
+            
+            if tool_calls:
+                # GPT 選擇了工具
+                tool_call = tool_calls[0]
+                function = tool_call.get("function", {})
+                tool_name = function.get("name", "")
+                arguments_str = function.get("arguments", "{}")
                 
-                intent_data = json.loads(response_text)
-                logger.debug("解析後的意圖資料: %s", _safe_json(intent_data))
-
-                # 新的 schema 格式：is_tool_call, tool_name（包含參數）
-                is_tool_call = intent_data.get("is_tool_call", False)
-
-                if is_tool_call:
-                    tool_name_with_params = intent_data.get("tool_name", "").strip()
-
-                    if not tool_name_with_params:
-                        logger.warning("⚠️ GPT 標記為工具調用但未提供工具名稱，降級為聊天")
-                        return False, None
-
-                    raw_tool_name = tool_name_with_params
-                    params_str = ""
-                    if ":" in tool_name_with_params:
-                        raw_tool_name, params_str = tool_name_with_params.split(":", 1)
-
-                    tool_name = self._normalize_tool_name(raw_tool_name)
-                    if not tool_name:
-                        logger.warning(f"⚠️ 工具 {raw_tool_name} 無法對應到註冊名稱，降級為聊天")
-                        return False, None
-
-                    # 解析參數
+                try:
+                    arguments = json.loads(arguments_str)
+                except json.JSONDecodeError:
                     arguments = {}
-                    if params_str.strip():
-                        # 獲取工具的 input schema 以確定參數類型
-                        tool = self.mcp_server.tools.get(tool_name)
-                        input_schema = {}
-                        if tool and hasattr(tool, 'handler') and hasattr(tool.handler, '__self__'):
-                            tool_class = tool.handler.__self__
-                            if hasattr(tool_class, 'get_input_schema'):
-                                try:
-                                    input_schema = tool_class.get_input_schema()
-                                except:
-                                    pass
-                        
-                        properties = input_schema.get('properties', {})
-                        
-                        for param_pair in params_str.split(","):
-                            if "=" not in param_pair:
-                                continue
-                            key, value = param_pair.split("=", 1)
-                            key = key.strip()
-                            value = value.strip()
-
-                            # 跳過空鍵或空值（避免傳入空字串導致驗證失敗）
-                            if not key or not value:
-                                continue
-
-                            # 根據 schema 中的類型定義來轉換值
-                            param_schema = properties.get(key, {})
-                            param_type = param_schema.get('type', 'string')
-                            
-                            normalized_value = value
-                            
-                            # 根據 schema 類型進行轉換
-                            if param_type == 'integer':
-                                try:
-                                    normalized_value = int(value)
-                                except ValueError:
-                                    normalized_value = value
-                            elif param_type == 'number':
-                                try:
-                                    normalized_value = float(value)
-                                except ValueError:
-                                    normalized_value = value
-                            elif param_type == 'boolean':
-                                lower_value = value.lower()
-                                if lower_value in ("true", "false"):
-                                    normalized_value = lower_value == "true"
-                            # 其他類型（包括 string）保持原樣
-
-                            arguments[key] = normalized_value
-
-                    logger.info(f"✅ GPT 檢測到工具調用: {raw_tool_name.strip()} → {tool_name}")
-                    logger.debug("工具調用參數: %s", _safe_json(arguments))
-
-                    # 驗證工具是否存在
-                    if tool_name not in self.mcp_server.tools:
-                        logger.warning(f"⚠️ 工具 {tool_name} 不存在，降級為聊天")
-                        return False, None
-
-                    # 基礎參數驗證（可選，Structured Outputs 已保證格式）
-                    tool = self.mcp_server.tools[tool_name]
-                    if hasattr(tool, 'handler') and hasattr(tool.handler, '__self__'):
-                        tool_class = tool.handler.__self__
-                        if hasattr(tool_class, 'validate_input'):
-                            try:
-                                validated_args = tool_class.validate_input(arguments)
-                                logger.debug("✓ 參數驗證通過: %s", _safe_json(validated_args))
-                            except Exception as e:
-                                logger.warning(f"⚠️ 參數驗證失敗: {e}，仍然嘗試執行")
-                                # 不中斷，讓工具自己處理
-
-                    # 提取情緒（新增）
-                    emotion = intent_data.get("emotion", "neutral")
-                    logger.info(f"😊 偵測到情緒: {emotion}")
-
-                    intent_result = (True, {
-                        "type": "mcp_tool",
-                        "tool_name": tool_name,
-                        "arguments": arguments,
-                        "emotion": emotion  # 新增情緒欄位
-                    })
-
-                    # 寫入快取
-                    self._intent_cache[cache_key] = (*intent_result, time_module.time())
-                    logger.debug(f"💾 意圖結果已快取: {tool_name}")
-
-                    return intent_result
-
-                else:
-                    # is_tool_call = False，表示一般聊天
-                    logger.info("💬 GPT 判斷為一般聊天")
-
-                    # 提取情緒（新增）
-                    emotion = intent_data.get("emotion", "neutral")
-                    logger.info(f"😊 偵測到情緒: {emotion}")
-
-                    # 寫入快取（一般聊天也要回傳情緒）
-                    intent_result = (False, {"emotion": emotion})
-                    self._intent_cache[cache_key] = (*intent_result, time_module.time())
-
-                    return intent_result
-
-            except json.JSONDecodeError as e:
-                # Structured Outputs 不應該發生這種錯誤，記錄異常
-                logger.error(f"❌ Structured Outputs JSON 解析失敗（異常情況）: {e}, response: {response}")
-                return False, None
-
+                
+                # 正規化工具名稱
+                normalized_name = self._normalize_tool_name(tool_name)
+                if not normalized_name:
+                    logger.warning(f"⚠️ 工具 {tool_name} 無法對應到註冊名稱，降級為聊天")
+                    return False, {"emotion": "neutral"}
+                
+                logger.info(f"✅ GPT 選擇工具: {normalized_name}")
+                logger.debug(f"工具參數: {_safe_json(arguments)}")
+                
+                # 提取情緒（從 content 或預設）
+                emotion = self._extract_emotion_from_content(response.get("content", ""))
+                
+                intent_result = (True, {
+                    "type": "mcp_tool",
+                    "tool_name": normalized_name,
+                    "arguments": arguments,
+                    "emotion": emotion,
+                })
+                
+                # 寫入快取
+                self._intent_cache[cache_key] = (*intent_result, time_module.time())
+                return intent_result
+            
+            else:
+                # GPT 未選擇工具，視為一般聊天
+                logger.info("💬 GPT 判斷為一般聊天")
+                emotion = self._extract_emotion_from_content(response.get("content", ""))
+                
+                intent_result = (False, {"emotion": emotion})
+                self._intent_cache[cache_key] = (*intent_result, time_module.time())
+                return intent_result
+                
         except Exception as e:
-            logger.error(f"❌ GPT 意圖解析發生錯誤: {e}")
-            # 降級處理：使用關鍵詞匹配
+            logger.error(f"❌ Function Calling 意圖檢測失敗: {e}")
+            # 降級：使用關鍵詞匹配
             logger.info("🔄 嘗試使用關鍵詞匹配作為降級方案")
             try:
                 fallback_result = self._keyword_intent_detection(message)
@@ -787,10 +620,177 @@ class MCPAgentBridge:
                     return fallback_result
             except Exception as fallback_error:
                 logger.error(f"❌ 關鍵詞匹配也失敗: {fallback_error}")
-
+        
         # 最終降級：視為一般聊天
         logger.info("💬 降級為一般聊天")
-        return False, None
+        return False, {"emotion": "neutral"}
+
+    def _build_function_calling_prompt(self) -> str:
+        """
+        建構精簡的 Function Calling system prompt
+        
+        注意：不再描述每個工具，工具定義由 tools 參數傳遞
+        只處理特殊規則和情緒判斷
+        """
+        return """你是一個智能助手，根據用戶需求選擇合適的工具。
+
+規則：
+1. 如果用戶需求可以用工具解決，選擇最適合的工具
+2. 如果是一般聊天或問候，不要選擇任何工具
+3. 工具參數盡量從用戶消息中提取，無法確定的使用合理預設值
+
+【重要】語言使用規範：
+- 調用工具時：所有參數必須使用英文（城市名、國家名、貨幣代碼等）
+- 回覆用戶時：必須使用繁體中文
+- 範例：用戶說「台北天氣」→ 參數 {"city": "Taipei"}，回覆「台北目前...」
+
+參數語言轉換規則：
+- 城市名稱：台北→Taipei, 新北→NewTaipei, 桃園→Taoyuan, 台中→Taichung, 台南→Tainan, 高雄→Kaohsiung, 新竹→Hsinchu
+- 國家名稱：台灣→Taiwan, 美國→USA, 日本→Japan, 英國→UK
+- 貨幣代碼：美元→USD, 台幣→TWD, 日圓→JPY, 歐元→EUR, 英鎊→GBP
+
+【重要】城市參數提取原則：
+- 只有在用戶明確提到城市名稱時才填 city 參數
+- 「附近」「這裡」「我這邊」等詞 → 不填 city 參數，系統會自動從 GPS 判斷
+- 「台北的XX」「桃園XX」→ 填對應的英文城市名
+- 範例：「附近的 YouBike」→ {}，「桃園的 YouBike」→ {"city": "Taoyuan"}
+
+匯率查詢（重要！參數提取規則）：
+當用戶詢問匯率資訊時，你必須從消息中提取貨幣代碼並填入參數。
+
+參數提取規則：
+1. 句型「[貨幣A]轉[貨幣B]」「[貨幣A]換[貨幣B]」「[貨幣A]兌[貨幣B]」→ {"from_currency": "代碼A", "to_currency": "代碼B"}
+2. 句型「[數字][貨幣A]是多少[貨幣B]」→ {"from_currency": "代碼A", "to_currency": "代碼B", "amount": 數字}
+3. 句型「匯率」「美金」「日幣」→ 提取提到的貨幣
+4. 貨幣代碼必須用 ISO 4217 標準（3個大寫字母）
+
+常見貨幣代碼對照：
+- 美元/美金 → USD
+- 台幣/新台幣 → TWD
+- 日圓/日幣 → JPY
+- 歐元 → EUR
+- 英鎊 → GBP
+- 人民幣 → CNY
+- 港幣 → HKD
+- 韓元 → KRW
+
+實際範例：
+- 「美元轉日幣的匯率」→ {"from_currency": "USD", "to_currency": "JPY"}
+- 「台幣換美金」→ {"from_currency": "TWD", "to_currency": "USD"}
+- 「100美元是多少台幣」→ {"from_currency": "USD", "to_currency": "TWD", "amount": 100}
+- 「歐元兌日圓」→ {"from_currency": "EUR", "to_currency": "JPY"}
+- 「匯率」→ {"from_currency": "USD", "to_currency": "TWD"}（預設）
+
+重要：必須提取貨幣代碼！不要返回空參數！
+
+公車查詢（重要！參數提取規則）：
+當用戶詢問公車資訊時，你必須從消息中提取路線號碼並填入參數。
+
+tdx_bus_arrival 適用場景：
+- 查詢「已知路線號碼」的到站時間
+- 查詢附近公車站點（不需 route_name）
+
+參數提取規則：
+1. 句型「[數字]公車」「[數字]號公車」→ {"route_name": "數字"}
+2. 句型「[顏色][數字]」（如「紅30」）→ {"route_name": "顏色數字"}
+3. 句型「[數字]還要多久」「[數字]什麼時候到」→ {"route_name": "數字"}
+4. 句型「[路線名]公車到站」→ {"route_name": "路線名"}
+5. 「附近公車」「公車站」「有什麼公車」→ {}（系統自動從 GPS 判斷城市）
+6. 城市參數：只在用戶明確提到城市時才填，否則留空讓系統自動判斷
+
+實際範例：
+- 「261公車什麼時候到」→ {"route_name": "261"}（不填 city）
+- 「307還要多久」→ {"route_name": "307"}（不填 city）
+- 「台北261公車」→ {"route_name": "261", "city": "Taipei"}（明確提到台北）
+- 「桃園紅30公車」→ {"route_name": "紅30", "city": "Taoyuan"}（明確提到桃園）
+- 「附近有什麼公車」→ {}（完全空參數，系統自動判斷）
+
+不適用場景（應使用 directions）：
+- 「從A到B的公車」「往XX的公車」→ 這是路線規劃，不是查詢特定路線
+- 「去台北的公車」→ 台北是目的地，不是路線號碼
+
+重要：如果提到路線號碼，必須提取！城市參數必須用英文！
+
+火車查詢（重要！參數提取規則）：
+當用戶詢問火車資訊時，你必須從消息中提取站名並填入參數。
+
+參數提取規則（適用於任何地名）：
+1. 句型「從 [地名A] 往/到 [地名B]」→ {"origin_station": "地名A", "destination_station": "地名B"}
+2. 句型「[地名A] 到/往 [地名B]」→ {"origin_station": "地名A", "destination_station": "地名B"}
+3. 句型「往/去 [地名]」→ {"destination_station": "地名"}
+4. 句型「[車種][數字]次」→ {"train_no": "數字"}
+5. 包含時間 → 提取為 departure_time（HH:MM 格式）
+
+實際範例：
+- 「從彰化往台北的火車」→ {"origin_station": "彰化", "destination_station": "台北"}
+- 「台中到高雄」→ {"origin_station": "台中", "destination_station": "高雄"}
+- 「往新竹的火車」→ {"destination_station": "新竹"}
+- 「自強號123次」→ {"train_no": "123"}
+- 「早上8點台南到台北」→ {"origin_station": "台南", "destination_station": "台北", "departure_time": "08:00"}
+
+重要：絕對不要返回空的 {} 參數！必須從用戶消息中提取站名！
+
+位置查詢：
+- 「我在哪」使用 reverse_geocode，不需要參數
+- 「怎麼去XX」使用 forward_geocode 或 directions
+
+YouBike 查詢（重要！參數提取規則）：
+當用戶詢問 YouBike/Ubike/微笑單車時，你必須調用 tdx_youbike 工具。
+
+參數提取規則：
+1. 「附近的 YouBike」「Ubike 在哪」→ {}（不填 city，系統自動從 GPS 判斷）
+2. 「市政府 YouBike」「台北車站 Ubike」→ {"station_name": "市政府"}（不填 city）
+3. 「XX站還有車嗎」→ {"station_name": "XX站"}（不填 city）
+4. 「台北的 YouBike」「桃園 YouBike」→ 填對應英文城市名
+5. 站名可用中文，城市必須用英文
+
+實際範例：
+- 「附近的 YouBike」→ {}（完全空參數，系統自動判斷城市）
+- 「市政府 YouBike 還有車嗎」→ {"station_name": "市政府"}（不填 city）
+- 「台北車站 Ubike」→ {"station_name": "台北車站"}（不填 city）
+- 「台北的 YouBike」→ {"city": "Taipei"}（明確提到台北）
+- 「桃園 YouBike」→ {"city": "Taoyuan"}（明確提到桃園）
+
+重要：只在用戶明確提到城市時才填 city 參數！站名可保持中文！
+
+【情緒偵測】（重要！）：
+- 分析用戶的情緒狀態（根據用詞、語氣、標點符號、表情符號）
+- 在回應的最後一行加上情緒標籤：[EMOTION:情緒]
+- 情緒類型：neutral（平靜）、happy（開心）、sad（難過）、angry（生氣）、fear（害怕）、surprise（驚訝）
+- 範例：
+  * 用戶說「我現在覺得很生氣」→ 回應最後加上 [EMOTION:angry]
+  * 用戶說「好開心啊！」→ 回應最後加上 [EMOTION:happy]
+  * 用戶說「我好難過...」→ 回應最後加上 [EMOTION:sad]
+  * 用戶說「好可怕」→ 回應最後加上 [EMOTION:fear]
+  * 用戶說「哇！」→ 回應最後加上 [EMOTION:surprise]
+  * 一般對話 → 回應最後加上 [EMOTION:neutral]
+"""
+
+    def _extract_emotion_from_content(self, content: str) -> str:
+        """從回應內容中提取情緒標籤 [EMOTION:xxx]"""
+        if not content:
+            return "neutral"
+        
+        # 優先從標籤提取
+        import re
+        emotion_match = re.search(r'\[EMOTION:(neutral|happy|sad|angry|fear|surprise)\]', content, re.IGNORECASE)
+        if emotion_match:
+            emotion = emotion_match.group(1).lower()
+            logger.info(f"😊 從標籤提取情緒: {emotion}")
+            return emotion
+        
+        # 降級：從內容搜尋英文關鍵字
+        content_lower = content.lower()
+        emotions = ["happy", "sad", "angry", "fear", "surprise"]
+        
+        for emotion in emotions:
+            if emotion in content_lower:
+                logger.debug(f"從內容搜尋到情緒關鍵字: {emotion}")
+                return emotion
+        
+        return "neutral"
+
+    # 舊版 _detect_intent_legacy 已移除，改用 _detect_intent_with_function_calling
 
     def _get_intent_schema(self) -> Dict[str, Any]:
         """
@@ -1138,23 +1138,33 @@ class MCPAgentBridge:
                 "你是一個友善、健談的AI助手。\n"
                 "用戶剛剛問了一個問題，我已經用工具查詢到資料了。\n"
                 "請用自然、口語化的方式回答用戶，就像朋友聊天一樣。\n\n"
-                "要求：\n"
+                "【核心原則】\n"
+                "⭐ 只回答使用者問的問題，不要把所有數據都說出來\n"
+                "⭐ 分析使用者的核心意圖（問溫度？天氣？時間？地點？數量？）\n"
+                "⭐ 從工具數據中只提取相關資訊，無關資訊一律省略\n\n"
+                "【回應要求】\n"
                 "1. 使用口語化、親切的語氣（可以用「喔」「呢」「哦」等語氣詞）\n"
                 "2. 不要列表式的羅列數據，而是用對話方式描述\n"
-                "3. 突出最重要的資訊（2-3句話）\n"
+                "3. 只說使用者問的內容（2-3句話）\n"
                 "4. 適當使用 emoji 增加親和力\n"
-                "5. 如果數據很多，只說重點\n"
+                "5. 如有額外有用資訊，可簡短補充（不超過一句話）\n"
                 "6. 保持簡短（50字以內最好）\n\n"
-                "範例：\n"
-                "❌ 不好：「當前溫度23.88°C，體感溫度24.02°C，天氣狀況多雲...」\n"
-                "✅ 良好：「台北現在23度左右，有點多雲呢！體感還蠻舒服的～」\n\n"
-                "記住：你是在聊天，不是在報告數據！"
+                "【範例】\n"
+                "用戶問：「台北現在幾度？」\n"
+                "工具返回：溫度23.88°C、濕度65%、風速3m/s、氣壓1013hPa...\n"
+                "❌ 錯誤：「台北現在23度，濕度65%，風速3m/s...」（說太多）\n"
+                "✅ 正確：「台北現在23度左右喔！」（只回答溫度）\n"
+                "✅ 可接受：「台北現在23度，體感蠻舒服的～」（簡短補充）\n\n"
+                "記住：精準回答使用者的問題，不要喧賓奪主！"
             )
 
             user_prompt = (
-                f"用戶問：「{original_message}」\n\n"
-                f"我用 {tool_name} 查到的資料：\n{content}\n\n"
-                f"請用自然對話的方式回答用戶（簡短、親切、口語化）："
+                f"【使用者的核心問題】\n"
+                f"「{original_message}」\n\n"
+                f"【工具 {tool_name} 返回的數據】\n"
+                f"{content}\n\n"
+                f"【任務】\n"
+                f"請只回答使用者問的問題（簡短、親切、口語化）："
             )
 
             messages = [

features/mcp/tools/exchange_tool.py

@@ -101,12 +101,14 @@ class ExchangeTool(MCPTool):
                 return cls.create_success_response(
                     content=formatted_text,
                     data={
-                        "rate": rate,
-                        "from_currency": from_currency,
-                        "to_currency": to_currency,
-                        "amount": amount,
-                        "converted_amount": amount * rate if conversion else None,
-                        "raw_data": rate_data
+                        "raw_data": {
+                            "rate": rate,
+                            "from_currency": from_currency,
+                            "to_currency": to_currency,
+                            "amount": amount,
+                            "converted_amount": amount * rate if conversion else None,
+                            "rate_data": rate_data
+                        }
                     }
                 )
             else:

features/mcp/tools/geocode_tool.py

@@ -168,7 +168,7 @@ class ReverseGeocodeTool(MCPTool):
         
         # 地點名稱（優先使用繁中）
         name = data.get("name") or ""
-        namedetails = data.get("namedetails", {})
+        namedetails = data.get("namedetails") or {}
         name_zh = namedetails.get("name:zh") or namedetails.get("name:zh-TW") or name
         
         display_name = data.get("display_name") or ""

features/mcp/tools/healthkit_tool.py

@@ -110,8 +110,8 @@ class HealthKitTool(MCPTool):
 
             logger.debug("✅ 使用 Firestore 數據庫連接")
 
-            # 解析參數
-            user_id = arguments.get('user_id')
+            # 解析參數（_user_id 由 coordinator 注入）
+            user_id = arguments.get('_user_id')
             metric_type = arguments.get('metric_type', 'all')
             days = arguments.get('days', 7)
             latest_only = arguments.get('latest_only', False)
@@ -120,6 +120,7 @@ class HealthKitTool(MCPTool):
             # 如果沒有提供 user_id，返回錯誤
             if not user_id:
                 return cls.create_error_response(
+                    error="需要提供用戶 ID",
                     code="USER_ID_REQUIRED"
                 )
 
@@ -197,18 +198,27 @@ class HealthKitTool(MCPTool):
             except Exception:
                 pass  # 設備資訊是可選的
             
+            # 限制返回給前端的數據量（避免傳輸過多數據）
+            # 前端工具卡片只顯示最新的 20 筆，但 count 顯示總數
+            display_limit = 20
+            display_data = data[:display_limit] if len(data) > display_limit else data
+            
             return cls.create_success_response(
                 content=summary,
                 data={
-                    "health_data": data,
-                    "count": len(data),
-                    "query": {
-                        "metric_type": metric_type,
-                        "days": days,
-                        "latest_only": latest_only,
-                        "aggregation": aggregation
-                    },
-                    "device_info": device_info
+                    "raw_data": {
+                        "health_data": display_data,
+                        "count": len(data),
+                        "total_records": len(data),
+                        "displayed_records": len(display_data),
+                        "query": {
+                            "metric_type": metric_type,
+                            "days": days,
+                            "latest_only": latest_only,
+                            "aggregation": aggregation
+                        },
+                        "device_info": device_info
+                    }
                 }
             )
             
@@ -325,7 +335,8 @@ class HealthKitTool(MCPTool):
                 if values:
                     avg_value = sum(values) / len(values)
                     latest_value = values[0] if values else 0
-                    summary += f"• {name}: 最新 {latest_value:.1f}，平均 {avg_value:.1f} ({len(values)} 筆記錄)\n"
+                    # 不顯示記錄數，避免使用者困惑
+                    summary += f"• {name}: 最新 {latest_value:.1f}，平均 {avg_value:.1f}\n"
         else:
             name = metric_names.get(metric_type, metric_type)
             if len(data) == 1:
@@ -336,6 +347,7 @@ class HealthKitTool(MCPTool):
                 values = [p["value"] for p in data]
                 avg_value = sum(values) / len(values)
                 latest_value = values[0] if values else 0
-                summary = f"{name}數據：最新 {latest_value:.1f} {data[0]['unit']}，平均 {avg_value:.1f}，共 {len(data)} 筆記錄"
+                # 不顯示記錄數，避免使用者困惑（AI 會根據需要提取重點）
+                summary = f"{name}數據：最新 {latest_value:.1f} {data[0]['unit']}，平均 {avg_value:.1f}"
         
         return summary

features/mcp/tools/news_tool.py

@@ -98,7 +98,14 @@ class NewsTool(MCPTool):
                         "content": {"type": "string"},
                         "url": {"type": "string"},
                         "published_at": {"type": "string"},
-                        "source": {"type": "string"},
+                        "source": {
+                            "type": "object",
+                            "properties": {
+                                "name": {"type": "string"},
+                                "id": {"type": "string"},
+                                "url": {"type": "string"}
+                            }
+                        },
                         "category": {"type": "array"},
                         "language": {"type": "string"},
                         "sentiment": {"type": "string"}
@@ -151,9 +158,11 @@ class NewsTool(MCPTool):
                 return cls.create_success_response(
                     content=formatted_text,
                     data={
-                        "articles": articles,
-                        "count": len(articles),
-                        "totalResults": total_results
+                        "raw_data": {
+                            "articles": articles,
+                            "count": len(articles),
+                            "totalResults": total_results
+                        }
                     }
                 )
             else:

features/mcp/tools/tdx_bus_arrival.py

@@ -24,15 +24,24 @@ class TDXBusArrivalTool(MCPTool):
     """TDX 公車即時到站查詢"""
     
     NAME = "tdx_bus_arrival"
-    DESCRIPTION = "查詢公車即時到站時間（自動感知用戶位置，找最近站點）"
+    DESCRIPTION = "查詢公車即時到站時間。適用於：1) 已知路線號碼（如307、紅30）的到站查詢；2) 查詢附近公車站。不適用於路線規劃（如「從A到B的公車」應用directions）。"
     CATEGORY = "道路運輸"
     TAGS = ["tdx", "公車", "即時到站", "公共運輸"]
-    KEYWORDS = ["公車", "巴士", "bus", "到站", "即時", "幾分鐘"]
+    KEYWORDS = ["公車", "巴士", "bus", "到站", "即時", "幾分鐘", "公車站", "等公車", "路線號碼"]
     USAGE_TIPS = [
-        "查詢特定路線: 「307 公車還要多久」",
-        "查詢附近公車站: 「附近有什麼公車」",
-        "指定城市: 「台北 307」「高雄紅30」"
+        "「307 公車還要多久」→ route_name=307",
+        "「紅30 什麼時候來」→ route_name=紅30",
+        "「附近有什麼公車」→ 不需參數，用 GPS 查詢附近站點"
     ]
+    NEGATIVE_EXAMPLES = [
+        "「埔鹽站往彰化的公車」→ 這是路線規劃，不是查詢特定路線！應用 directions",
+        "「往彰化的公車」→ 彰化是目的地，不是路線號碼！應用 directions",
+        "「去台北的公車」→ 台北是目的地，不是路線號碼！應用 directions",
+        "「從A到B的公車」→ 這是路線規劃，應用 directions",
+        "「公車路線圖」→ 這是詢問路線圖，不是查到站時間"
+    ]
+    PRIORITY = 5
+    ALIASES = ["bus", "公車", "巴士"]
     
     # TDX 城市代碼
     VALID_CITIES = {
@@ -81,7 +90,7 @@ class TDXBusArrivalTool(MCPTool):
                         "route_name": {"type": "string"},
                         "stop_name": {"type": "string"},
                         "direction": {"type": "integer"},
-                        "estimate_time": {"type": "integer"},
+                        "estimate_time": {"type": ["integer", "null"]},
                         "status": {"type": "string"}
                     }
                 }

features/mcp/tools/tdx_train.py

@@ -18,16 +18,22 @@ class TDXTrainTool(MCPTool):
     """TDX 台鐵時刻表查詢"""
     
     NAME = "tdx_train"
-    DESCRIPTION = "查詢台鐵列車時刻表、票價、最近車站（含高鐵轉乘資訊）"
+    DESCRIPTION = "查詢台鐵列車時刻表。參數提取規則：「從A到B」→origin_station=A,destination_station=B；「往B」→destination_station=B（起點用GPS）；「車次123」→train_no=123。"
     CATEGORY = "軌道運輸"
     TAGS = ["tdx", "台鐵", "TRA", "火車", "時刻表"]
-    KEYWORDS = ["台鐵", "臺鐵", "火車", "TRA", "列車", "時刻"]
+    KEYWORDS = ["台鐵", "臺鐵", "火車", "TRA", "列車", "時刻", "自強號", "莒光號", "區間車"]
     USAGE_TIPS = [
-        "查詢車次: 「自強號 123 次」",
-        "查詢路線: 「台北到台中的火車」",
-        "查詢最近車站: 「最近的火車站在哪」",
-        "查詢時刻: 「下午3點台北到高雄」"
+        "「自強號 123 次」→ train_no=123",
+        "「台北到台中的火車」→ origin_station=台北, destination_station=台中",
+        "「往台北的火車」→ destination_station=台北（起點用 GPS）",
+        "「下午3點台北到高雄」→ origin_station=台北, destination_station=高雄, departure_time=15:00"
     ]
+    NEGATIVE_EXAMPLES = [
+        "「火車票怎麼買」→ 這是詢問購票方式，不是查時刻表",
+        "「火車站在哪」→ 這是查位置，應用 reverse_geocode 或 forward_geocode"
+    ]
+    PRIORITY = 8
+    ALIASES = ["train", "台鐵", "火車"]
     
     @classmethod
     def get_input_schema(cls) -> Dict[str, Any]:

features/mcp/tools/tdx_youbike.py

@@ -20,12 +20,24 @@ class TDXBikeTool(MCPTool):
     DESCRIPTION = "查詢附近 YouBike 站點、即時車輛數、空位數（支援 YouBike 1.0/2.0）"
     CATEGORY = "微型運具"
     TAGS = ["tdx", "youbike", "ubike", "共享單車", "微笑單車"]
-    KEYWORDS = ["YouBike", "UBike", "微笑單車", "共享單車", "腳踏車", "自行車"]
+    KEYWORDS = [
+        "YouBike", "Youbike", "youbike", "YOUBIKE",
+        "UBike", "Ubike", "ubike", "UBIKE",
+        "微笑單車", "共享單車", "公共單車",
+        "腳踏車站", "單車站", "自行車站",
+        "借車", "還車", "腳踏車"
+    ]
     USAGE_TIPS = [
-        "查詢附近站點: 「附近的 YouBike 在哪」",
-        "查詢特定站點: 「市政府 YouBike 還有車嗎」",
-        "指定城市: 「台北 YouBike」「高雄 CityBike」"
+        "「附近的 YouBike」→ 查詢最近站點",
+        "「Ubike 在哪」→ 查詢最近站點",
+        "「市政府 YouBike 還有車嗎」→ station_name=市政府"
+    ]
+    NEGATIVE_EXAMPLES = [
+        "「YouBike 怎麼註冊」→ 這是詢問註冊方式，不是查站點",
+        "「YouBike 費率」→ 這是詢問價格，不是查站點"
     ]
+    PRIORITY = 6
+    ALIASES = ["youbike", "ubike", "微笑單車", "共享單車"]
     
     # 城市對應
     CITY_MAP = {
@@ -43,6 +55,16 @@ class TDXBikeTool(MCPTool):
     
     @classmethod
     def get_input_schema(cls) -> Dict[str, Any]:
+        # 建立包含中文和英文的城市列表
+        all_cities = list(cls.CITY_MAP.keys()) + list(cls.CITY_MAP.values())
+        # 去重並保持順序
+        unique_cities = []
+        seen = set()
+        for city in all_cities:
+            if city not in seen:
+                unique_cities.append(city)
+                seen.add(city)
+        
         return StandardToolSchemas.create_input_schema({
             "station_name": {
                 "type": "string",
@@ -50,8 +72,8 @@ class TDXBikeTool(MCPTool):
             },
             "city": {
                 "type": "string",
-                "description": "城市名稱（如「Taipei」「Kaohsiung」）",
-                "enum": list(cls.CITY_MAP.values())
+                "description": "城市名稱（支援中文如「台北」「桃園」或英文如「Taipei」「Taoyuan」）",
+                "enum": unique_cities
             },
             "radius_m": {
                 "type": "integer",
@@ -108,6 +130,11 @@ class TDXBikeTool(MCPTool):
         
         station_name = safe_str(arguments.get("station_name"))
         city = arguments.get("city")
+        
+        # 如果 city 是中文，轉換為英文
+        if city:
+            city = cls._map_city_name(city)
+        
         radius_m = min(int(arguments.get("radius_m", 500)), 2000)
         limit = min(int(arguments.get("limit", 5)), 20)
         
@@ -166,7 +193,20 @@ class TDXBikeTool(MCPTool):
                     final_city = guessed
                     city_source = "經緯度推斷"
             
-            city = cls._map_city_name(final_city) if final_city else "Taipei"
+            # 檢查城市是否支援 YouBike
+            if final_city:
+                city = cls._map_city_name(final_city)
+                if city == "Taipei" and final_city not in cls.CITY_MAP:
+                    # 城市不在支援列表中，提供友善錯誤訊息
+                    nearest_city = cls._find_nearest_supported_city(user_lat, user_lon)
+                    raise ExecutionError(
+                        f"🚲 很抱歉，{final_city}目前沒有 YouBike 服務。\n\n"
+                        f"最近有 YouBike 的城市是：{nearest_city}\n"
+                        f"支援 YouBike 的城市：台北、新北、桃園、新竹、台中、台南、高雄"
+                    )
+            else:
+                city = "Taipei"
+            
             logger.info(f"🏙️ 最終使用城市代碼: {city} (來源={city_source})")
         
         # 3. 查詢分支
@@ -365,6 +405,7 @@ class TDXBikeTool(MCPTool):
             ("新北", 24.67, 25.30, 121.35, 122.01),
             ("新竹", 24.68, 24.90, 120.90, 121.10),
             ("台中", 24.00, 24.45, 120.45, 121.05),
+            ("彰化", 23.85, 24.15, 120.35, 120.70),  # 新增彰化範圍
             ("台南", 22.85, 23.40, 120.00, 120.55),
             ("高雄", 22.45, 23.15, 120.15, 120.80),
         ]
@@ -386,6 +427,31 @@ class TDXBikeTool(MCPTool):
                 return value
         return "Taipei"
     
+    @staticmethod
+    def _find_nearest_supported_city(lat: float, lon: float) -> str:
+        """找出最近的支援 YouBike 的城市"""
+        # 支援 YouBike 的城市中心點（大約位置）
+        city_centers = {
+            "台北": (25.033, 121.565),
+            "新北": (25.012, 121.466),
+            "桃園": (24.994, 121.301),
+            "新竹": (24.806, 120.968),
+            "台中": (24.148, 120.674),
+            "台南": (22.997, 120.213),
+            "高雄": (22.627, 120.301),
+        }
+        
+        min_distance = float('inf')
+        nearest_city = "台北"
+        
+        for city_name, (city_lat, city_lon) in city_centers.items():
+            distance = TDXBaseAPI.haversine_distance(lat, lon, city_lat, city_lon)
+            if distance < min_distance:
+                min_distance = distance
+                nearest_city = city_name
+        
+        return nearest_city
+    
     @staticmethod
     def _detect_bike_type(station: Dict, station_name: str) -> str:
         """判斷 YouBike 類型（優先從站名判斷，其次從 BikesCapacity）"""

features/mcp/tools/weather_tool.py

@@ -33,12 +33,18 @@ class WeatherTool(MCPTool):
     DESCRIPTION = "查詢指定城市的即時天氣資訊（溫度、濕度、天氣狀況等）"
     CATEGORY = "生活資訊"
     TAGS = ["weather", "天氣", "氣象"]
-    KEYWORDS = ["天氣", "氣溫", "下雨", "晴天", "陰天", "weather", "溫度"]
+    KEYWORDS = ["天氣", "氣溫", "下雨", "晴天", "陰天", "weather", "溫度", "濕度", "會不會下雨", "熱不熱", "冷不冷"]
     USAGE_TIPS = [
-        "提供城市名稱（英文）如 Taipei, Tokyo",
-        "支援經緯度查詢",
-        "可指定語言 (zh_tw, en, zh_cn)"
+        "「台北天氣」→ city=Taipei",
+        "「東京今天會下雨嗎」→ city=Tokyo",
+        "「現在幾度」→ 使用用戶位置"
     ]
+    NEGATIVE_EXAMPLES = [
+        "「天氣預報 App」→ 這是詢問 App，不是查天氣",
+        "「天氣好好」→ 這是感嘆，不是查詢"
+    ]
+    PRIORITY = 1  # 高優先級
+    ALIASES = ["weather", "氣象"]
 
     @classmethod
     def get_input_schema(cls) -> Dict[str, Any]:
@@ -57,7 +63,7 @@ class WeatherTool(MCPTool):
                 "default": "zh_tw",
                 "enum": ["zh_tw", "en", "zh_cn"]
             }
-        }, ["city"])  # city 可留空，若 lat/lon 有值則忽略
+        }, [])  # 所有參數都是可選的，由 execute 方法內部邏輯判斷
 
     @classmethod
     def get_output_schema(cls) -> Dict[str, Any]:

middleware/__init__.py

@@ -0,0 +1,18 @@
+"""
+中間件模組
+拆分自 app.py，提高可維護性
+"""
+
+from .csp import CSPMiddleware
+from .rate_limit import RateLimitMiddleware, rate_limiter
+from .exception_handler import ExceptionHandlerMiddleware, RequestLoggingMiddleware
+from .compression import GzipMiddleware
+
+__all__ = [
+    "CSPMiddleware",
+    "RateLimitMiddleware",
+    "rate_limiter",
+    "ExceptionHandlerMiddleware",
+    "RequestLoggingMiddleware",
+    "GzipMiddleware",
+]

middleware/compression.py

@@ -0,0 +1,106 @@
+"""
+回應壓縮中間件
+使用 gzip 壓縮 API 回應，減少傳輸大小
+"""
+
+import gzip
+from typing import Callable
+
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import Response
+
+from core.logging import get_logger
+
+logger = get_logger("middleware.compression")
+
+# 最小壓縮大小（bytes）
+MIN_COMPRESS_SIZE = 500
+
+# 可壓縮的 Content-Type
+COMPRESSIBLE_TYPES = {
+    "application/json",
+    "text/html",
+    "text/plain",
+    "text/css",
+    "text/javascript",
+    "application/javascript",
+}
+
+
+class GzipMiddleware(BaseHTTPMiddleware):
+    """
+    Gzip 壓縮中間件
+
+    功能：
+    1. 檢查客戶端是否支援 gzip
+    2. 壓縮大於閾值的回應
+    3. 只壓縮可壓縮的 Content-Type
+    """
+
+    async def dispatch(self, request: Request, call_next: Callable) -> Response:
+        # 檢查客戶端是否支援 gzip
+        accept_encoding = request.headers.get("accept-encoding", "")
+        supports_gzip = "gzip" in accept_encoding.lower()
+
+        response = await call_next(request)
+
+        # 不支援 gzip 或已經壓縮，直接返回
+        if not supports_gzip:
+            return response
+
+        if response.headers.get("content-encoding"):
+            return response
+
+        # 檢查 Content-Type 是否可壓縮
+        content_type = response.headers.get("content-type", "")
+        base_type = content_type.split(";")[0].strip()
+
+        if base_type not in COMPRESSIBLE_TYPES:
+            return response
+
+        # 讀取回應內容
+        body = b""
+        async for chunk in response.body_iterator:
+            body += chunk
+
+        # 檢查大小是否值得壓縮
+        if len(body) < MIN_COMPRESS_SIZE:
+            # 重建回應
+            return Response(
+                content=body,
+                status_code=response.status_code,
+                headers=dict(response.headers),
+                media_type=response.media_type,
+            )
+
+        # 壓縮內容
+        compressed = gzip.compress(body, compresslevel=6)
+
+        # 只有壓縮後更小才使用
+        if len(compressed) >= len(body):
+            return Response(
+                content=body,
+                status_code=response.status_code,
+                headers=dict(response.headers),
+                media_type=response.media_type,
+            )
+
+        # 更新標頭
+        headers = dict(response.headers)
+        headers["content-encoding"] = "gzip"
+        headers["content-length"] = str(len(compressed))
+        # 移除可能衝突的標頭
+        headers.pop("transfer-encoding", None)
+
+        logger.debug(
+            f"壓縮回應: {len(body)} -> {len(compressed)} bytes "
+            f"({100 - len(compressed) * 100 // len(body)}% 減少)"
+        )
+
+        return Response(
+            content=compressed,
+            status_code=response.status_code,
+            headers=headers,
+            media_type=response.media_type,
+        )

middleware/csp.py

@@ -0,0 +1,36 @@
+"""
+Content Security Policy 中間件
+允許內嵌 script 用於語音沉浸式前端
+"""
+
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request as StarletteRequest
+
+
+class CSPMiddleware(BaseHTTPMiddleware):
+    """CSP 中間件"""
+
+    async def dispatch(self, request: StarletteRequest, call_next):
+        response = await call_next(request)
+        
+        # 對所有靜態檔案路徑添加寬鬆的 CSP header
+        if request.url.path.startswith("/static/"):
+            # 移除可能存在的嚴格 CSP
+            if "Content-Security-Policy" in response.headers:
+                del response.headers["Content-Security-Policy"]
+
+            # 設定寬鬆的 CSP 以允許內嵌 script
+            response.headers["Content-Security-Policy"] = (
+                "default-src 'self'; "
+                "script-src 'self' 'unsafe-inline' 'unsafe-eval' "
+                "https://accounts.google.com https://www.gstatic.com; "
+                "style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; "
+                "font-src 'self' https://fonts.gstatic.com data:; "
+                "connect-src 'self' ws: wss: https://accounts.google.com; "
+                "img-src 'self' data: https: blob:; "
+                "media-src 'self' blob: data:; "
+                "frame-src https://accounts.google.com; "
+                "base-uri 'self';"
+            )
+            
+        return response

middleware/exception_handler.py

@@ -0,0 +1,99 @@
+"""
+全域異常處理中間件
+統一處理所有未捕獲的異常，返回標準化錯誤回應
+"""
+
+import logging
+import traceback
+from typing import Callable
+
+from fastapi import Request, Response
+from fastapi.responses import JSONResponse
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from core.exceptions import BloomWareException, handle_exception
+from core.logging import get_logger
+
+logger = get_logger("middleware.exception_handler")
+
+
+class ExceptionHandlerMiddleware(BaseHTTPMiddleware):
+    """
+    全域異常處理中間件
+
+    功能：
+    1. 捕獲所有未處理的異常
+    2. 轉換為標準化 JSON 錯誤回應
+    3. 記錄錯誤日誌（生產環境隱藏堆疊）
+    """
+
+    async def dispatch(self, request: Request, call_next: Callable) -> Response:
+        try:
+            response = await call_next(request)
+            return response
+
+        except BloomWareException as e:
+            # 已知的業務異常
+            logger.warning(f"業務異常: {e.code} - {e.message}")
+            return e.to_response()
+
+        except Exception as e:
+            # 未知異常
+            logger.error(f"未處理的異常: {type(e).__name__}: {e}")
+            logger.debug(f"堆疊追蹤:\n{traceback.format_exc()}")
+
+            # 返回標準化錯誤回應
+            return JSONResponse(
+                status_code=500,
+                content={
+                    "success": False,
+                    "error": {
+                        "code": "INTERNAL_ERROR",
+                        "message": "內部伺服器錯誤",
+                        "details": {}
+                    }
+                }
+            )
+
+
+class RequestLoggingMiddleware(BaseHTTPMiddleware):
+    """
+    請求日誌中間件
+
+    功能：
+    1. 記錄所有 API 請求
+    2. 計算請求處理時間
+    3. 記錄回應狀態碼
+    """
+
+    async def dispatch(self, request: Request, call_next: Callable) -> Response:
+        import time
+
+        start_time = time.time()
+        method = request.method
+        path = request.url.path
+
+        # 跳過健康檢查和靜態資源的日誌
+        skip_paths = ["/health", "/static/", "/favicon.ico"]
+        should_log = not any(path.startswith(p) for p in skip_paths)
+
+        try:
+            response = await call_next(request)
+            process_time = (time.time() - start_time) * 1000
+
+            if should_log:
+                logger.info(
+                    f"{method} {path} - {response.status_code} - {process_time:.2f}ms"
+                )
+
+            # 添加處理時間到回應標頭
+            response.headers["X-Process-Time"] = f"{process_time:.2f}ms"
+            return response
+
+        except Exception as e:
+            process_time = (time.time() - start_time) * 1000
+            if should_log:
+                logger.error(
+                    f"{method} {path} - ERROR - {process_time:.2f}ms - {e}"
+                )
+            raise

middleware/rate_limit.py

@@ -0,0 +1,165 @@
+"""
+Rate Limiting 中間件
+防止 API 濫用
+"""
+
+import logging
+import time
+from typing import Dict, Tuple
+from collections import defaultdict
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request as StarletteRequest
+from starlette.responses import JSONResponse
+
+logger = logging.getLogger("middleware.rate_limit")
+
+
+class RateLimiter:
+    """
+    簡易 Rate Limiter（記憶體實現）
+    
+    生產環境建議使用 Redis 實現
+    """
+
+    def __init__(
+        self,
+        requests_per_minute: int = 60,
+        requests_per_hour: int = 1000,
+    ):
+        self.requests_per_minute = requests_per_minute
+        self.requests_per_hour = requests_per_hour
+        
+        # 記錄請求：{ip: [(timestamp, count), ...]}
+        self._minute_requests: Dict[str, list] = defaultdict(list)
+        self._hour_requests: Dict[str, list] = defaultdict(list)
+
+    def _cleanup_old_requests(self, requests: list, window_seconds: int) -> list:
+        """清理過期的請求記錄"""
+        current_time = time.time()
+        return [
+            (ts, count) for ts, count in requests
+            if current_time - ts < window_seconds
+        ]
+
+    def is_allowed(self, client_ip: str) -> Tuple[bool, str]:
+        """
+        檢查請求是否被允許
+        
+        Returns:
+            (is_allowed, reason)
+        """
+        current_time = time.time()
+
+        # 清理過期記錄
+        self._minute_requests[client_ip] = self._cleanup_old_requests(
+            self._minute_requests[client_ip], 60
+        )
+        self._hour_requests[client_ip] = self._cleanup_old_requests(
+            self._hour_requests[client_ip], 3600
+        )
+
+        # 計算當前窗口內的請求數
+        minute_count = sum(count for _, count in self._minute_requests[client_ip])
+        hour_count = sum(count for _, count in self._hour_requests[client_ip])
+
+        # 檢查限制
+        if minute_count >= self.requests_per_minute:
+            return False, f"每分鐘請求數超過限制（{self.requests_per_minute}）"
+        
+        if hour_count >= self.requests_per_hour:
+            return False, f"每小時請求數超過限制（{self.requests_per_hour}）"
+
+        # 記錄請求
+        self._minute_requests[client_ip].append((current_time, 1))
+        self._hour_requests[client_ip].append((current_time, 1))
+
+        return True, ""
+
+    def get_remaining(self, client_ip: str) -> Dict[str, int]:
+        """獲取剩餘請求數"""
+        # 清理過期記錄
+        self._minute_requests[client_ip] = self._cleanup_old_requests(
+            self._minute_requests[client_ip], 60
+        )
+        self._hour_requests[client_ip] = self._cleanup_old_requests(
+            self._hour_requests[client_ip], 3600
+        )
+
+        minute_count = sum(count for _, count in self._minute_requests[client_ip])
+        hour_count = sum(count for _, count in self._hour_requests[client_ip])
+
+        return {
+            "minute_remaining": max(0, self.requests_per_minute - minute_count),
+            "hour_remaining": max(0, self.requests_per_hour - hour_count),
+        }
+
+
+# 全局 Rate Limiter 實例
+rate_limiter = RateLimiter(
+    requests_per_minute=60,
+    requests_per_hour=1000,
+)
+
+
+def get_client_ip(request: StarletteRequest) -> str:
+    """獲取客戶端 IP"""
+    # 優先取 X-Forwarded-For
+    xff = request.headers.get("x-forwarded-for") or request.headers.get("X-Forwarded-For")
+    if xff:
+        ip = xff.split(",")[0].strip()
+        if ip:
+            return ip
+    return request.client.host if request.client else "unknown"
+
+
+class RateLimitMiddleware(BaseHTTPMiddleware):
+    """Rate Limiting 中間件"""
+
+    # 不需要限制的路徑
+    EXEMPT_PATHS = {
+        "/",
+        "/health",
+        "/static",
+        "/login",
+        "/favicon.ico",
+    }
+
+    async def dispatch(self, request: StarletteRequest, call_next):
+        # 檢查是否豁免
+        path = request.url.path
+        if any(path.startswith(exempt) for exempt in self.EXEMPT_PATHS):
+            return await call_next(request)
+
+        # 獲取客戶端 IP
+        client_ip = get_client_ip(request)
+
+        # 檢查 Rate Limit
+        is_allowed, reason = rate_limiter.is_allowed(client_ip)
+        
+        if not is_allowed:
+            logger.warning(f"Rate limit exceeded for {client_ip}: {reason}")
+            remaining = rate_limiter.get_remaining(client_ip)
+            
+            return JSONResponse(
+                status_code=429,
+                content={
+                    "error": "Too Many Requests",
+                    "message": reason,
+                    "retry_after": 60,  # 建議等待時間（秒）
+                },
+                headers={
+                    "Retry-After": "60",
+                    "X-RateLimit-Remaining-Minute": str(remaining["minute_remaining"]),
+                    "X-RateLimit-Remaining-Hour": str(remaining["hour_remaining"]),
+                }
+            )
+
+        # 繼續處理請求
+        response = await call_next(request)
+
+        # 添加 Rate Limit 頭
+        remaining = rate_limiter.get_remaining(client_ip)
+        response.headers["X-RateLimit-Remaining-Minute"] = str(remaining["minute_remaining"])
+        response.headers["X-RateLimit-Remaining-Hour"] = str(remaining["hour_remaining"])
+
+        return response

models/schemas.py

@@ -0,0 +1,123 @@
+"""
+Pydantic 模型定義
+統一管理 API 請求/回應的資料結構
+"""
+
+from datetime import datetime
+from typing import List, Optional
+from pydantic import BaseModel, EmailStr, Field
+
+
+# ===== 用戶相關 =====
+
+class UserCreate(BaseModel):
+    """用戶註冊請求"""
+    name: str
+    email: EmailStr
+    password: str = Field(min_length=6)
+
+
+class UserLogin(BaseModel):
+    """用戶登入請求"""
+    email: EmailStr
+    password: str
+
+
+class UserInfo(BaseModel):
+    """用戶資訊"""
+    id: str
+    name: str
+    email: EmailStr
+    created_at: datetime
+
+
+class UserPublic(BaseModel):
+    """用戶公開資訊回應"""
+    success: bool
+    user: UserInfo
+
+
+class UserLoginPublicResponse(BaseModel):
+    """用戶登入回應"""
+    success: bool
+    user: UserInfo
+    token: Optional[str] = None
+
+
+# ===== 對話相關 =====
+
+class ChatCreateRequest(BaseModel):
+    """建立對話請求"""
+    user_id: str
+    title: Optional[str] = "新對話"
+
+
+class ChatTitleUpdateRequest(BaseModel):
+    """更新對話標題請求"""
+    title: str
+
+
+class ChatPublic(BaseModel):
+    """對話公開資訊"""
+    chat_id: str
+    user_id: str
+    title: str
+    created_at: datetime
+    updated_at: datetime
+
+
+class ChatSummary(BaseModel):
+    """對話摘要"""
+    chat_id: str
+    title: str
+    updated_at: datetime
+
+
+class ChatListResponse(BaseModel):
+    """對話列表回應"""
+    chats: List[ChatSummary]
+
+
+# ===== 訊息相關 =====
+
+class MessageCreateRequest(BaseModel):
+    """建立訊息請求"""
+    sender: str
+    content: str
+
+
+class MessagePublic(BaseModel):
+    """訊息公開資訊"""
+    sender: str
+    content: str
+    timestamp: datetime
+
+
+class ChatDetailResponse(ChatPublic):
+    """對話詳情回應（含訊息）"""
+    messages: List[MessagePublic]
+
+
+# ===== 檔案分析 =====
+
+class FileAnalysisRequest(BaseModel):
+    """檔案分析請求"""
+    filename: str
+    content: str
+    mime_type: str
+    user_prompt: Optional[str] = "請分析這個檔案的內容"
+
+
+class FileAnalysisResponse(BaseModel):
+    """檔案分析回應"""
+    success: bool
+    filename: str
+    analysis: Optional[str] = None
+    error: Optional[str] = None
+
+
+# ===== 語音相關 =====
+
+class SpeakerLabelBindRequest(BaseModel):
+    """語音標籤綁定請求"""
+    speaker_label: str

models/speaker_identification/models_cnn/speaker_db.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4377a566b92e5cca1db0f83274a7037169f371e47ca357e3c764c8908ef55e43
+size 4157

models/speaker_identification/scripts/inference.py

@@ -1,144 +1,91 @@
 import os
-import argparse
-import numpy as np
+import torch
 import librosa
-import noisereduce as nr
-import pyaudio
+import numpy as np
+import pickle
 import wave
-import torch
-import torch.nn as nn
-import torchaudio
+import pyaudio
+from speechbrain.pretrained import EncoderClassifier
+from sklearn.metrics.pairwise import cosine_similarity
 
+# 常數
+SAMPLE_RATE = 16000
+DB_FILE = "speaker_db.pkl"
 
-def get_device():
-    if torch.cuda.is_available():
-        print("Using device: CUDA")
-        return torch.device('cuda')
-    if torch.backends.mps.is_available():
-        print("Using device: MPS")
-        return torch.device('mps')
-    print("Using device: CPU")
-    return torch.device('cpu')
+# 全域 classifier（延遲載入）
+_classifier = None
 
 
-class Wav2Vec2SpeakerClassifier(nn.Module):
-    def __init__(self, bundle, num_classes, freeze_encoder=True):
-        super().__init__()
-        self.encoder = bundle.get_model()
-        for p in self.encoder.parameters():
-            p.requires_grad = False
-        hidden_dim = getattr(self.encoder, 'encoder_embed_dim', 768)
-        self.classifier = nn.Sequential(
-            nn.Dropout(0.0),
-            nn.Linear(hidden_dim, num_classes)
+def get_classifier():
+    """取得 ECAPA-TDNN 分類器（單例模式）"""
+    global _classifier
+    if _classifier is None:
+        _classifier = EncoderClassifier.from_hparams(
+            source="speechbrain/spkrec-ecapa-voxceleb"
         )
+    return _classifier
 
-    def forward(self, waveforms, lengths=None):
-        out = self.encoder(waveforms, lengths)
-        if isinstance(out, tuple):
-            features, lengths = out
-        else:
-            features, lengths = out, None
-        if lengths is not None:
-            valid_lengths = (lengths * features.size(1)).round().to(torch.long).clamp(min=1, max=features.size(1))
-            mask = torch.arange(features.size(1), device=features.device).unsqueeze(0) < valid_lengths.unsqueeze(1)
-            features = features * mask.unsqueeze(-1)
-            pooled = features.sum(dim=1) / valid_lengths.unsqueeze(-1)
-        else:
-            pooled = features.mean(dim=1)
-        return self.classifier(pooled)
 
-
-def load_classes(classes_path_or_dir):
-    # 若提供文字檔則逐行讀取，否則從目錄列出子資料夾
-    if os.path.isfile(classes_path_or_dir):
-        with open(classes_path_or_dir, 'r', encoding='utf-8') as f:
-            classes = [line.strip() for line in f if line.strip()]
-    else:
-        classes = sorted([d for d in os.listdir(classes_path_or_dir)
-                          if os.path.isdir(os.path.join(classes_path_or_dir, d))])
-    return classes
+def get_embedding(file_path):
+    """從音訊檔案取得 ECAPA-TDNN 嵌入向量"""
+    signal, sr = librosa.load(file_path, sr=SAMPLE_RATE, mono=True)
+    signal_tensor = torch.tensor(signal).unsqueeze(0)
+    classifier = get_classifier()
+    embedding = classifier.encode_batch(signal_tensor)
+    return embedding.squeeze().detach().numpy()
 
 
-def load_audio(path, target_sr):
-    wav, sr = torchaudio.load(path)
-    if wav.size(0) > 1:
-        wav = wav.mean(dim=0, keepdim=True)
-    if sr != target_sr:
-        resampler = torchaudio.transforms.Resample(sr, target_sr)
-        wav = resampler(wav)
-        sr = target_sr
-    wav = wav.squeeze(0)
-    length = torch.tensor([wav.shape[0]], dtype=torch.long)
-    return wav.unsqueeze(0), length
+def load_speaker_db(db_path):
+    """載入說話者嵌入資料庫"""
+    with open(db_path, "rb") as f:
+        speaker_embeddings = pickle.load(f)
+    return speaker_embeddings
 
 
-def softmax(x):
-    e = torch.exp(x - x.max(dim=1, keepdim=True).values)
-    return e / e.sum(dim=1, keepdim=True)
+def recognize_speaker(test_file, speaker_embeddings):
+    """
+    辨識語音（與原始 ECAPA_TDNN.py 完全一致）
+    """
+    test_emb = get_embedding(test_file).reshape(1, -1)
+    scores = {}
+    for spk, emb in speaker_embeddings.items():
+        sim = cosine_similarity(test_emb, emb.reshape(1, -1))[0][0]
+        scores[spk] = sim
+    predicted = max(scores, key=scores.get)
+    scores[predicted] += 0.35
+    return predicted, scores
 
 
 def predict_files(model_dir, file_list, threshold=0.0):
     """
-    預測多個音訊檔案的說話者。
+    預測多個音訊檔案的說話者
 
     Args:
-        model_dir: 模型目錄，包含 speaker_id_model.pth 和 classes.txt
+        model_dir: 模型目錄，包含 speaker_db.pkl
         file_list: 檔案路徑列表
-        threshold: 預測門檻（目前未使用）
+        threshold: 未使用，保留介面相容
 
     Returns:
         結果列表，每個元素為字典，包含 'pred', 'score', 'top'
     """
-    device = get_device()
-    bundle = torchaudio.pipelines.WAV2VEC2_BASE
-    target_sr = bundle.sample_rate
-
-    model_path = os.path.join(model_dir, 'speaker_id_model.pth')
-    classes_path = os.path.join(model_dir, 'classes.txt')
-    processed_dir = os.path.join(model_dir, 'processed_audio')
-
-    if os.path.isfile(classes_path):
-        classes = load_classes(classes_path)
-    elif os.path.isdir(processed_dir):
-        classes = load_classes(processed_dir)
-    else:
-        raise FileNotFoundError(f"找不到類別定義：{classes_path} 或 {processed_dir}")
-
-    num_classes = len(classes)
-
-    model = Wav2Vec2SpeakerClassifier(bundle, num_classes)
-    state = torch.load(model_path, map_location='cpu')
-    model.load_state_dict(state)
-    model.to(device).eval()
+    db_path = os.path.join(model_dir, DB_FILE)
+    if not os.path.exists(db_path):
+        raise FileNotFoundError(f"找不到說話者資料庫：{db_path}")
 
+    speaker_embeddings = load_speaker_db(db_path)
     results = []
+
     for file_path in file_list:
         try:
-            # 前處理音訊
-            y, sr = process_like_training(file_path)
-
-            # 轉成模型輸入
-            y_t = torch.tensor(y, dtype=torch.float32).unsqueeze(0)
-            if sr != target_sr:
-                resampler = torchaudio.transforms.Resample(sr, target_sr)
-                y_t = resampler(y_t)
-            length = torch.tensor([y_t.shape[1]], dtype=torch.long)
-            waveforms, lengths = y_t.to(device), length.to(device)
+            predicted, scores = recognize_speaker(file_path, speaker_embeddings)
 
-            with torch.no_grad():
-                logits = model(waveforms, lengths)
-                probs = softmax(logits).squeeze(0).cpu()
-                top_prob, top_idx = torch.max(probs, dim=0)
-                pred = classes[top_idx.item()]
-
-                # 獲取 top 候選
-                topk = torch.topk(probs, k=min(3, num_classes))
-                top = [(classes[i], float(p)) for p, i in zip(topk.values.tolist(), topk.indices.tolist())]
+            # 排序取 top 候選
+            sorted_scores = sorted(scores.items(), key=lambda x: x[1], reverse=True)
+            top = [(spk, float(score)) for spk, score in sorted_scores[:3]]
 
             result = {
-                'pred': pred,
-                'score': float(top_prob.item()),
+                'pred': predicted,
+                'score': float(scores[predicted]),
                 'top': top
             }
             results.append(result)
@@ -148,20 +95,18 @@ def predict_files(model_dir, file_list, threshold=0.0):
     return results
 
 
-# ============== 錄音與前處理（比照 process_audio.py） ==============
-REC_SR = 22050
-TARGET_RMS = 0.1
-VAD_TOP_DB = 30
-
-
-def record_audio(filename, seconds=3, sr=REC_SR):
+# ============== 錄音功能 ==============
+def record_audio(filename, seconds=3, sr=SAMPLE_RATE):
+    """從麥克風錄製音訊"""
     pa = pyaudio.PyAudio()
     stream = pa.open(format=pyaudio.paInt16, channels=1, rate=sr, input=True, frames_per_buffer=1024)
     print(f"開始錄製 {seconds}s...")
     frames = []
     for _ in range(int(sr / 1024 * seconds)):
         frames.append(stream.read(1024))
-    stream.stop_stream(); stream.close(); pa.terminate()
+    stream.stop_stream()
+    stream.close()
+    pa.terminate()
     with wave.open(filename, 'wb') as wf:
         wf.setnchannels(1)
         wf.setsampwidth(pyaudio.PyAudio().get_sample_size(pyaudio.paInt16))
@@ -170,82 +115,37 @@ def record_audio(filename, seconds=3, sr=REC_SR):
     print("錄製結束。")
 
 
-def process_like_training(input_wav_path):
-    # 與 process_audio.py 一致：librosa 載入、去噪、VAD、RMS 正規化（保留原始長度）
-    y, sr = librosa.load(input_wav_path, sr=REC_SR)
-    y = nr.reduce_noise(y=y, sr=sr)
-    intervals = librosa.effects.split(y, top_db=VAD_TOP_DB)
-    if len(intervals) > 0:
-        y = np.concatenate([y[s:e] for s, e in intervals])
-    # RMS 正規化
-    rms = np.sqrt(np.mean(y ** 2)) if len(y) else 0.0
-    if rms > 0:
-        y = y * (TARGET_RMS / rms)
-    return y, sr
-
-
 def main():
-    parser = argparse.ArgumentParser(description='Speaker ID Inference (Wav2Vec2)')
-    parser.add_argument('--audio', type=str, default=None, help='Path to wav file；若省略則使用麥克風錄音')
-    parser.add_argument('--model', type=str, default='speaker_id_model.pth', help='Path to model .pth')
-    parser.add_argument('--classes', type=str, default='processed_audio', help='Path to classes dir or classes.txt')
+    import argparse
+    parser = argparse.ArgumentParser(description='Speaker ID Inference (ECAPA-TDNN)')
+    parser.add_argument('--audio', type=str, default=None, help='音訊檔案路徑；若省略則使用麥克風錄音')
+    parser.add_argument('--db', type=str, default='speaker_db.pkl', help='說話者資料庫路徑')
     parser.add_argument('--seconds', type=int, default=3, help='錄音秒數（麥克風模式）')
-    parser.add_argument('--save-processed', action='store_true', help='輸出處理後音檔 processed_record.wav')
     args = parser.parse_args()
 
-    device = get_device()
-    bundle = torchaudio.pipelines.WAV2VEC2_BASE
-    target_sr = bundle.sample_rate
+    # 載入資料庫
+    speaker_embeddings = load_speaker_db(args.db)
+    print(f"已載入 {len(speaker_embeddings)} 位說話者：{list(speaker_embeddings.keys())}")
 
-    classes = load_classes(args.classes)
-    num_classes = len(classes)
-
-    model = Wav2Vec2SpeakerClassifier(bundle, num_classes)
-    state = torch.load(args.model, map_location='cpu')
-    model.load_state_dict(state)
-    model.to(device).eval()
-
-    # 準備音訊來源：檔案或錄音
+    # 準備音訊
     temp_path = None
     if args.audio is None:
         temp_path = 'temp_record.wav'
-        record_audio(temp_path, seconds=args.seconds, sr=REC_SR)
-        raw_path = temp_path
+        record_audio(temp_path, seconds=args.seconds)
+        audio_path = temp_path
     else:
-        raw_path = args.audio
-
-    # 前處理（比照 process_audio.py）
-    y, sr = process_like_training(raw_path)
-    if args.save_processed:
-        try:
-            import soundfile as sf
-            sf.write('processed_record.wav', y, sr)
-        except Exception:
-            pass
-
-    # 轉成模型輸入：重採樣到 16k + 提供長度
-    y_t = torch.tensor(y, dtype=torch.float32).unsqueeze(0)
-    if sr != target_sr:
-        resampler = torchaudio.transforms.Resample(sr, target_sr)
-        y_t = resampler(y_t)
-        sr = target_sr
-    length = torch.tensor([y_t.shape[1]], dtype=torch.long)
-    waveforms, lengths = y_t.to(device), length.to(device)
+        audio_path = args.audio
 
-    with torch.no_grad():
-        logits = model(waveforms, lengths)
-        probs = softmax(logits).squeeze(0).cpu()
-        top_prob, top_idx = torch.max(probs, dim=0)
-        pred = classes[top_idx.item()]
+    # 辨識
+    predicted, scores = recognize_speaker(audio_path, speaker_embeddings)
 
-    print(f'Predicted speaker: {pred} (prob={top_prob.item():.3f})')
-    # 顯示前 3 名
-    topk = torch.topk(probs, k=min(3, num_classes))
-    print('Top candidates:')
-    for p, i in zip(topk.values.tolist(), topk.indices.tolist()):
-        print(f'  {classes[i]}: {p:.3f}')
+    print(f'\n辨識結果：{predicted}')
+    print('辨識機率：')
+    for spk, score in sorted(scores.items(), key=lambda x: x[1], reverse=True):
+        print(f'  {spk}: {score:.4f}')
 
-    if temp_path is not None and os.path.exists(temp_path):
+    # 清理暫存檔
+    if temp_path and os.path.exists(temp_path):
         try:
             os.remove(temp_path)
         except Exception:

models/speaker_identification/scripts/process_audio.py

@@ -1,52 +0,0 @@
-import os
-import librosa
-import numpy as np
-import noisereduce as nr
-import soundfile as sf
-
-# 參考採樣率與音量標準化
-sr = 22050  # 假設採樣率
-target_rms = 0.1  # 目標 RMS 水平
-vad_top_db = 30  # VAD 門檻，值越小越容易刪除靜音
-
-# 輸出目錄
-output_dir = 'processed_audio'
-os.makedirs(output_dir, exist_ok=True)
-
-# 用於記錄每個子目錄的當前編號
-counter = {}
-
-# 遍歷 voice_data 目錄下的所有 .wav 和 .mp3 文件
-for root, dirs, files in os.walk('voice_data'):
-    for file in files:
-        if file.endswith(('.wav', '.mp3')):
-            file_path = os.path.join(root, file)
-            # 獲取相對路徑，用於創建輸出子目錄
-            rel_path = os.path.relpath(root, 'voice_data')
-            sub_output_dir = os.path.join(output_dir, rel_path)
-            os.makedirs(sub_output_dir, exist_ok=True)
-            
-            if rel_path not in counter:
-                counter[rel_path] = 1
-            
-            y, sr = librosa.load(file_path, sr=sr)
-            # 去噪
-            y = nr.reduce_noise(y=y, sr=sr)
-            
-            # 語音活動偵測 (VAD)，移除靜音區段
-            intervals = librosa.effects.split(y, top_db=vad_top_db)
-            if len(intervals) == 0:
-                # 無語音內容，跳過此檔
-                continue
-            y = np.concatenate([y[start:end] for start, end in intervals])
-
-            # 保留原始長度並直接保存
-            rms = np.sqrt(np.mean(y**2))
-            if rms > 0:
-                y = y * (target_rms / rms)
-
-            output_path = os.path.join(sub_output_dir, f'voice_{counter[rel_path]:02d}.wav')
-            sf.write(output_path, y, sr)
-            counter[rel_path] += 1
-
-print("音頻處理完成。")

models/speaker_identification/scripts/train_speaker_id.py

@@ -1,306 +0,0 @@
-import os
-import random
-
-import matplotlib.pyplot as plt
-import numpy as np
-import seaborn as sns
-import torch
-import torch.nn as nn
-import torch.optim as optim
-import torchaudio
-import torchaudio.functional as F
-from sklearn.metrics import confusion_matrix
-from sklearn.preprocessing import LabelEncoder
-from sklearn.utils.class_weight import compute_class_weight
-from torch.utils.data import DataLoader, Dataset
-
-
-# 基本參數
-data_dir = '/kaggle/input/voice-identity/processed_audio'
-batch_size = 16
-num_epochs = 50
-
-# 遷移學習設定（不使用 HuggingFace，改用 torchaudio 內建預訓練）
-bundle = torchaudio.pipelines.WAV2VEC2_BASE
-target_sr = bundle.sample_rate
-freeze_encoder = True      # 先凍結整個 encoder，只訓練分類頭
-unfreeze_last_n = 2        # 若要微調，可調整解凍的 Transformer 層數
-head_learning_rate = 1e-3
-encoder_learning_rate = 1e-5
-encoder_warmup_epochs = 10  # 預設 10 epoch 後解凍最後幾層（若 unfreeze_last_n > 0）
-pitch_shift_semitones = [0, -4, 4]  # 每筆資料的音調擴增組合
-
-
-def waveform_augment(waveform, sr, max_shift_ratio=0.02, noise_factor=0.002):
-    """時間平移 + 微量噪音；針對短音訊使用較小位移"""
-    if max_shift_ratio > 0:
-        shift = int(sr * max_shift_ratio)
-        if shift > 0:
-            offset = random.randint(-shift, shift)
-            waveform = torch.roll(waveform, offset, dims=1)
-    if noise_factor > 0:
-        noise = torch.randn_like(waveform) * noise_factor
-        waveform = waveform + noise
-    return waveform
-
-
-class SpeakerDataset(Dataset):
-    def __init__(self, data_dir, classes, transform=None, target_sr=16000, pitch_shifts=None):
-        self.data_dir = data_dir
-        self.classes = classes
-        self.transform = transform
-        self.target_sr = target_sr
-        self.resamplers = {}
-        self.pitch_shifts = sorted(set(pitch_shifts or [0]))
-        self.data = []
-
-        for label, cls in enumerate(classes):
-            cls_dir = os.path.join(data_dir, cls)
-            for file in os.listdir(cls_dir):
-                if file.endswith('.wav'):
-                    file_path = os.path.join(cls_dir, file)
-                    for shift in self.pitch_shifts:
-                        self.data.append((file_path, label, shift))
-
-    def __len__(self):
-        return len(self.data)
-
-    def __getitem__(self, idx):
-        file_path, label, semitone = self.data[idx]
-        waveform, sr = torchaudio.load(file_path)
-
-        if waveform.size(0) > 1:
-            waveform = waveform.mean(dim=0, keepdim=True)
-
-        if sr != self.target_sr:
-            if sr not in self.resamplers:
-                self.resamplers[sr] = torchaudio.transforms.Resample(sr, self.target_sr)
-            waveform = self.resamplers[sr](waveform)
-            sr = self.target_sr
-
-        if semitone != 0:
-            waveform = F.pitch_shift(waveform, sr, n_steps=semitone)
-
-        if self.transform:
-            waveform = self.transform(waveform, sr)
-
-        return waveform.squeeze(0), label
-
-
-def collate_waveforms(batch):
-    waveforms, labels = zip(*batch)
-    lengths = torch.tensor([waveform.shape[0] for waveform in waveforms], dtype=torch.long)
-    max_len = lengths.max().item()
-    padded = torch.zeros(len(waveforms), max_len)
-    for idx, waveform in enumerate(waveforms):
-        padded[idx, : waveform.shape[0]] = waveform
-    labels_tensor = torch.tensor(labels, dtype=torch.long)
-    return padded, lengths, labels_tensor
-
-
-class Wav2Vec2SpeakerClassifier(nn.Module):
-    def __init__(self, bundle, num_classes, freeze_encoder=True, unfreeze_last_n=0):
-        super().__init__()
-        self.encoder = bundle.get_model()
-        self.freeze_encoder = freeze_encoder
-        self.unfreeze_last_n = unfreeze_last_n
-
-        # 預設凍結整個 encoder
-        for param in self.encoder.parameters():
-            param.requires_grad = False
-
-        if not freeze_encoder:
-            # 先全部鎖住，再選擇性解凍最後 N 層；若無法部分解凍則退而求其次為完全解凍
-            transformer_layers = getattr(self.encoder, 'encoder', None)
-            if transformer_layers is not None and hasattr(transformer_layers, 'layers') and unfreeze_last_n > 0:
-                for layer in transformer_layers.layers[-unfreeze_last_n:]:
-                    for param in layer.parameters():
-                        param.requires_grad = True
-            elif not freeze_encoder:
-                for param in self.encoder.parameters():
-                    param.requires_grad = True
-
-        self.encoder_frozen = freeze_encoder
-
-        hidden_dim = getattr(self.encoder, 'encoder_embed_dim', 768)
-        self.classifier = nn.Sequential(
-            nn.Dropout(0.3),
-            nn.Linear(hidden_dim, num_classes)
-        )
-
-    def unfreeze_last_layers(self, n_layers=None):
-        """解凍最後 n 層 Transformer block，回傳剛解凍的參數列表。"""
-        n_layers = n_layers or self.unfreeze_last_n
-        unfrozen_params = []
-        transformer_layers = getattr(self.encoder, 'encoder', None)
-        if transformer_layers is not None and hasattr(transformer_layers, 'layers') and n_layers > 0:
-            target_layers = transformer_layers.layers[-n_layers:]
-            for layer in target_layers:
-                for param in layer.parameters():
-                    if not param.requires_grad:
-                        param.requires_grad = True
-                        unfrozen_params.append(param)
-        elif n_layers > 0:
-            for param in self.encoder.parameters():
-                if not param.requires_grad:
-                    param.requires_grad = True
-                    unfrozen_params.append(param)
-        if unfrozen_params:
-            self.encoder_frozen = False
-        return unfrozen_params
-
-    def forward(self, waveforms, lengths=None):
-        if waveforms.dim() != 2:
-            raise ValueError("音訊張量應為 [batch, time] 形式")
-
-        encoder_out = self.encoder(waveforms, lengths)
-        if isinstance(encoder_out, tuple):
-            features, lengths = encoder_out
-        else:
-            features, lengths = encoder_out, None
-
-        if lengths is not None:
-            if torch.is_floating_point(lengths):
-                valid_lengths = (lengths * features.size(1)).round().to(torch.long)
-            else:
-                valid_lengths = lengths.to(torch.long)
-            valid_lengths = valid_lengths.clamp(min=1, max=features.size(1))
-            mask = torch.arange(features.size(1), device=features.device).unsqueeze(0) < valid_lengths.unsqueeze(1)
-            masked_features = features * mask.unsqueeze(-1)
-            pooled = masked_features.sum(dim=1) / valid_lengths.unsqueeze(-1)
-        else:
-            pooled = features.mean(dim=1)
-
-        logits = self.classifier(pooled)
-        return logits
-
-
-classes = sorted([d for d in os.listdir(data_dir) if os.path.isdir(os.path.join(data_dir, d))])
-num_classes = len(classes)
-label_encoder = LabelEncoder()
-label_encoder.fit(classes)
-
-dataset = SpeakerDataset(
-    data_dir=data_dir,
-    classes=classes,
-    transform=waveform_augment,
-    target_sr=target_sr,
-    pitch_shifts=pitch_shift_semitones
-)
-train_loader = DataLoader(
-    dataset,
-    batch_size=batch_size,
-    shuffle=True,
-    num_workers=0,
-    pin_memory=False,
-    collate_fn=collate_waveforms
-)
-
-labels = [label for _, label, _ in dataset.data]
-class_weights = compute_class_weight('balanced', classes=np.unique(labels), y=labels)
-class_weights = torch.tensor(class_weights, dtype=torch.float)
-
-if torch.cuda.is_available():
-    device = torch.device('cuda')
-    print("Using device: CUDA")
-elif torch.backends.mps.is_available():
-    device = torch.device('mps')
-    print("Using device: MPS")
-else:
-    device = torch.device('cpu')
-    print("Using device: CPU")
-
-model = Wav2Vec2SpeakerClassifier(
-    bundle=bundle,
-    num_classes=num_classes,
-    freeze_encoder=freeze_encoder,
-    unfreeze_last_n=unfreeze_last_n
-).to(device)
-criterion = nn.CrossEntropyLoss(weight=class_weights.to(device))
-
-encoder_params = [p for p in model.encoder.parameters() if p.requires_grad]
-head_params = list(model.classifier.parameters())
-if encoder_params:
-    optimizer = optim.Adam([
-        {'params': head_params, 'lr': head_learning_rate},
-        {'params': encoder_params, 'lr': encoder_learning_rate}
-    ])
-else:
-    optimizer = optim.Adam(head_params, lr=head_learning_rate)
-
-use_amp = torch.cuda.is_available()
-scaler = torch.amp.GradScaler() if use_amp else None
-
-def add_encoder_params_to_optimizer(model, optimizer, lr):
-    existing_params = set()
-    for group in optimizer.param_groups:
-        existing_params.update(id(p) for p in group['params'])
-    new_params = [p for p in model.encoder.parameters() if p.requires_grad and id(p) not in existing_params]
-    if new_params:
-        optimizer.add_param_group({'params': new_params, 'lr': lr})
-
-for epoch in range(num_epochs):
-    # 動態解凍策略：達到指定 epoch 後解凍最後幾層
-    if model.encoder_frozen and unfreeze_last_n > 0 and (epoch + 1) == encoder_warmup_epochs:
-        newly_unfrozen = model.unfreeze_last_layers(unfreeze_last_n)
-        if newly_unfrozen:
-            add_encoder_params_to_optimizer(model, optimizer, encoder_learning_rate)
-            print(f'Unfroze last {unfreeze_last_n} encoder layer(s) at epoch {epoch + 1}.')
-
-    model.train()
-    if model.encoder_frozen:
-        model.encoder.eval()
-    else:
-        model.encoder.train()
-
-    running_loss = 0.0
-    for waveforms, lengths, labels_batch in train_loader:
-        waveforms = waveforms.to(device)
-        lengths = lengths.to(device)
-        labels_batch = labels_batch.to(device)
-        optimizer.zero_grad()
-
-        if use_amp:
-            with torch.amp.autocast(device_type='cuda'):
-                logits = model(waveforms, lengths)
-                loss = criterion(logits, labels_batch)
-            scaler.scale(loss).backward()
-            scaler.step(optimizer)
-            scaler.update()
-        else:
-            logits = model(waveforms, lengths)
-            loss = criterion(logits, labels_batch)
-            loss.backward()
-            optimizer.step()
-
-        running_loss += loss.item()
-
-    avg_loss = running_loss / len(train_loader)
-    print(f'Epoch {epoch + 1}/{num_epochs}, Loss: {avg_loss:.4f}')
-
-model.eval()
-all_preds = []
-all_labels = []
-with torch.no_grad():
-    for waveforms, lengths, labels_batch in train_loader:
-        waveforms = waveforms.to(device)
-        lengths = lengths.to(device)
-        logits = model(waveforms, lengths)
-        preds = torch.argmax(logits, dim=1)
-        all_preds.extend(preds.cpu().numpy())
-        all_labels.extend(labels_batch.numpy())
-
-cm = confusion_matrix(all_labels, all_preds)
-print("Confusion Matrix:")
-print(cm)
-
-plt.figure(figsize=(8, 6))
-sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=classes, yticklabels=classes)
-plt.title('Confusion Matrix')
-plt.xlabel('Predicted')
-plt.ylabel('True')
-plt.savefig('confusion_matrix.png')
-plt.close()
-
-torch.save(model.state_dict(), 'speaker_id_model.pth')
-print("訓練完成，模型已保存。")

render.yaml

@@ -1,28 +0,0 @@
-services:
-  - type: web
-    name: bloom-ware
-    runtime: python
-    region: singapore  # 或 oregon（美西）
-    plan: Hobby  # 免費方案
-    buildCommand: pip install -r requirements.txt
-    startCommand: python3 app.py
-    envVars:
-      - key: ENVIRONMENT
-        value: production
-      - key: PYTHON_VERSION
-        value: 3.12.4
-      - key: HOST
-        value: 0.0.0.0
-      - key: PORT
-        value: 10000  # Render 固定使用 10000 端口
-      # 其他敏感環境變數請在 Render Dashboard 手動設定：
-      # - FIREBASE_PROJECT_ID
-      # - FIREBASE_CREDENTIALS_JSON（完整JSON字串）
-      # - OPENAI_API_KEY
-      # - GOOGLE_CLIENT_ID
-      # - GOOGLE_CLIENT_SECRET
-      # - GOOGLE_REDIRECT_URI（https://your-app.onrender.com/auth/google/callback）
-      # - WEATHER_API_KEY
-      # - NEWSDATA_API_KEY
-      # - EXCHANGE_API_KEY
-      # - JWT_SECRET_KEY（使用 Python secrets.token_urlsafe(32) 生成新的）

routers/__init__.py

@@ -0,0 +1,20 @@
+"""
+Bloom Ware API 路由模組
+拆分自 app.py，提高可維護性
+"""
+
+from .auth import router as auth_router
+from .chat import router as chat_router
+from .voice import router as voice_router
+from .health import router as health_router
+from .files import router as files_router
+from .system import router as system_router
+
+__all__ = [
+    "auth_router",
+    "chat_router", 
+    "voice_router",
+    "health_router",
+    "files_router",
+    "system_router",
+]

routers/auth.py

@@ -0,0 +1,159 @@
+"""
+認證相關 API 路由
+包含 Google OAuth、JWT 認證等
+"""
+
+import logging
+from datetime import datetime
+from typing import Dict, Optional
+from fastapi import APIRouter, Request, HTTPException, Depends
+from fastapi.responses import JSONResponse, RedirectResponse
+from pydantic import BaseModel, EmailStr
+
+from core.config import settings
+from core.auth import jwt_auth, get_current_user_optional, require_auth
+from core.auth.google_oauth import GoogleOAuth
+from core.database import create_or_login_google_user
+
+logger = logging.getLogger("routers.auth")
+
+router = APIRouter(prefix="/auth", tags=["認證"])
+
+# Google OAuth 實例
+google_oauth = GoogleOAuth()
+
+
+class GoogleAuthRequest(BaseModel):
+    """Google 認證請求"""
+    credential: str
+
+
+class TokenResponse(BaseModel):
+    """Token 響應"""
+    success: bool
+    token: Optional[str] = None
+    user: Optional[dict] = None
+    error: Optional[str] = None
+
+
+@router.get("/google/login")
+async def google_login():
+    """
+    Google OAuth 登入入口
+    重定向到 Google 授權頁面
+    """
+    auth_url = google_oauth.get_authorization_url()
+    return RedirectResponse(url=auth_url)
+
+
+@router.get("/google/callback")
+async def google_callback(code: str = None, error: str = None):
+    """
+    Google OAuth 回調處理
+    """
+    if error:
+        logger.error(f"Google OAuth 錯誤: {error}")
+        return RedirectResponse(url=f"/login?error={error}")
+
+    if not code:
+        logger.error("Google OAuth 回調缺少 code 參數")
+        return RedirectResponse(url="/login?error=missing_code")
+
+    try:
+        # 交換 code 獲取 token
+        token_info = await google_oauth.exchange_code(code)
+        if not token_info:
+            return RedirectResponse(url="/login?error=token_exchange_failed")
+
+        # 獲取用戶信息
+        user_info = await google_oauth.get_user_info(token_info.get("access_token"))
+        if not user_info:
+            return RedirectResponse(url="/login?error=user_info_failed")
+
+        # 創建或登入用戶
+        result = await create_or_login_google_user(user_info)
+        if not result.get("success"):
+            error_msg = result.get("error", "unknown_error")
+            return RedirectResponse(url=f"/login?error={error_msg}")
+
+        # 生成 JWT token
+        user = result.get("user", {})
+        jwt_token = jwt_auth.create_access_token({
+            "sub": user.get("id"),
+            "email": user.get("email"),
+            "name": user.get("name"),
+        })
+
+        # 重定向到前端，帶上 token
+        return RedirectResponse(url=f"/static/frontend/index.html?token={jwt_token}")
+
+    except Exception as e:
+        logger.exception(f"Google OAuth 回調處理失敗: {e}")
+        return RedirectResponse(url=f"/login?error=callback_failed")
+
+
+@router.post("/google/verify", response_model=TokenResponse)
+async def google_verify(request: GoogleAuthRequest):
+    """
+    驗證 Google ID Token（前端 One Tap 登入）
+    """
+    try:
+        # 驗證 Google credential
+        user_info = await google_oauth.verify_id_token(request.credential)
+        if not user_info:
+            return TokenResponse(success=False, error="invalid_credential")
+
+        # 創建或登入用戶
+        result = await create_or_login_google_user(user_info)
+        if not result.get("success"):
+            return TokenResponse(success=False, error=result.get("error"))
+
+        # 生成 JWT token
+        user = result.get("user", {})
+        jwt_token = jwt_auth.create_access_token({
+            "sub": user.get("id"),
+            "email": user.get("email"),
+            "name": user.get("name"),
+        })
+
+        return TokenResponse(
+            success=True,
+            token=jwt_token,
+            user=user,
+        )
+
+    except Exception as e:
+        logger.exception(f"Google 驗證失敗: {e}")
+        return TokenResponse(success=False, error=str(e))
+
+
+@router.get("/me")
+async def get_current_user(user: dict = Depends(require_auth)):
+    """
+    獲取當前登入用戶信息
+    """
+    return {
+        "success": True,
+        "user": {
+            "id": user.get("sub"),
+            "email": user.get("email"),
+            "name": user.get("name"),
+        }
+    }
+
+
+@router.post("/refresh")
+async def refresh_token(user: dict = Depends(require_auth)):
+    """
+    刷新 JWT Token
+    """
+    new_token = jwt_auth.create_access_token({
+        "sub": user.get("sub"),
+        "email": user.get("email"),
+        "name": user.get("name"),
+    })
+
+    return {
+        "success": True,
+        "token": new_token,
+    }

routers/chat.py

@@ -0,0 +1,200 @@
+"""
+對話相關 API 路由
+包含對話管理、消息歷史等
+"""
+
+import logging
+from datetime import datetime
+from typing import List, Optional
+from fastapi import APIRouter, HTTPException, Depends
+from pydantic import BaseModel
+
+from core.auth import require_auth
+from core.database import (
+    create_chat,
+    get_user_chats,
+    get_chat,
+    update_chat_title,
+    delete_chat,
+    get_chat_messages,
+)
+from core.database.optimized import (
+    get_chat as get_chat_optimized,
+    get_user_chats as get_user_chats_optimized,
+)
+
+logger = logging.getLogger("routers.chat")
+
+router = APIRouter(prefix="/api/chats", tags=["對話"])
+
+
+class ChatCreateRequest(BaseModel):
+    """創建對話請求"""
+    title: Optional[str] = "新對話"
+
+
+class ChatTitleUpdateRequest(BaseModel):
+    """更新對話標題請求"""
+    title: str
+
+
+class ChatSummary(BaseModel):
+    """對話摘要"""
+    chat_id: str
+    title: str
+    updated_at: datetime
+
+
+class ChatListResponse(BaseModel):
+    """對話列表響應"""
+    success: bool
+    chats: List[ChatSummary]
+
+
+@router.post("")
+async def create_new_chat(
+    request: ChatCreateRequest,
+    user: dict = Depends(require_auth)
+):
+    """
+    創建新對話
+    """
+    user_id = user.get("sub")
+    if not user_id:
+        raise HTTPException(status_code=401, detail="無效的用戶")
+
+    result = await create_chat(user_id, request.title)
+    if not result.get("success"):
+        raise HTTPException(status_code=500, detail=result.get("error"))
+
+    return result
+
+
+@router.get("")
+async def list_user_chats(user: dict = Depends(require_auth)):
+    """
+    獲取用戶的所有對話
+    """
+    user_id = user.get("sub")
+    if not user_id:
+        raise HTTPException(status_code=401, detail="無效的用戶")
+
+    result = await get_user_chats_optimized(user_id)
+    if not result.get("success"):
+        raise HTTPException(status_code=500, detail=result.get("error"))
+
+    return result
+
+
+@router.get("/{chat_id}")
+async def get_chat_detail(
+    chat_id: str,
+    user: dict = Depends(require_auth)
+):
+    """
+    獲取對話詳情（包含消息）
+    """
+    user_id = user.get("sub")
+    if not user_id:
+        raise HTTPException(status_code=401, detail="無效的用戶")
+
+    result = await get_chat_optimized(chat_id)
+    if not result.get("success"):
+        raise HTTPException(status_code=404, detail="對話不存在")
+
+    chat = result.get("chat", {})
+    
+    # 驗證對話所有權
+    if chat.get("user_id") != user_id:
+        raise HTTPException(status_code=403, detail="無權訪問此對話")
+
+    return result
+
+
+@router.get("/{chat_id}/messages")
+async def get_chat_messages_api(
+    chat_id: str,
+    limit: int = 50,
+    user: dict = Depends(require_auth)
+):
+    """
+    獲取對話消息歷史
+    """
+    user_id = user.get("sub")
+    if not user_id:
+        raise HTTPException(status_code=401, detail="無效的用戶")
+
+    # 先驗證對話所有權
+    chat_result = await get_chat_optimized(chat_id)
+    if not chat_result.get("success"):
+        raise HTTPException(status_code=404, detail="對話不存在")
+
+    chat = chat_result.get("chat", {})
+    if chat.get("user_id") != user_id:
+        raise HTTPException(status_code=403, detail="無權訪問此對話")
+
+    # 獲取消息
+    messages = await get_chat_messages(chat_id, limit=limit)
+    
+    return {
+        "success": True,
+        "chat_id": chat_id,
+        "messages": messages,
+    }
+
+
+@router.put("/{chat_id}/title")
+async def update_chat_title_api(
+    chat_id: str,
+    request: ChatTitleUpdateRequest,
+    user: dict = Depends(require_auth)
+):
+    """
+    更新對話標題
+    """
+    user_id = user.get("sub")
+    if not user_id:
+        raise HTTPException(status_code=401, detail="無效的用戶")
+
+    # 先驗證對話所有權
+    chat_result = await get_chat_optimized(chat_id)
+    if not chat_result.get("success"):
+        raise HTTPException(status_code=404, detail="對話不存在")
+
+    chat = chat_result.get("chat", {})
+    if chat.get("user_id") != user_id:
+        raise HTTPException(status_code=403, detail="無權修改此對話")
+
+    result = await update_chat_title(chat_id, request.title)
+    if not result.get("success"):
+        raise HTTPException(status_code=500, detail=result.get("error"))
+
+    return result
+
+
+@router.delete("/{chat_id}")
+async def delete_chat_api(
+    chat_id: str,
+    user: dict = Depends(require_auth)
+):
+    """
+    刪除對話
+    """
+    user_id = user.get("sub")
+    if not user_id:
+        raise HTTPException(status_code=401, detail="無效的用戶")
+
+    # 先驗證對話所有權
+    chat_result = await get_chat_optimized(chat_id)
+    if not chat_result.get("success"):
+        raise HTTPException(status_code=404, detail="對話不存在")
+
+    chat = chat_result.get("chat", {})
+    if chat.get("user_id") != user_id:
+        raise HTTPException(status_code=403, detail="無權刪除此對話")
+
+    result = await delete_chat(chat_id)
+    if not result.get("success"):
+        raise HTTPException(status_code=500, detail=result.get("error"))
+
+    return result

routers/files.py

@@ -0,0 +1,228 @@
+"""
+文件處理相關 API 路由
+包含文件上傳、分析等
+"""
+
+import logging
+import base64
+import mimetypes
+from typing import Optional
+from fastapi import APIRouter, HTTPException, Depends, UploadFile, File
+from pydantic import BaseModel
+
+from core.auth import require_auth
+
+logger = logging.getLogger("routers.files")
+
+router = APIRouter(prefix="/api/files", tags=["文件"])
+
+
+class FileAnalysisRequest(BaseModel):
+    """文件分析請求"""
+    filename: str
+    content: str  # base64 編碼
+    mime_type: str
+    user_prompt: Optional[str] = "請分析這個檔案的內容"
+
+
+class FileAnalysisResponse(BaseModel):
+    """文件分析響應"""
+    success: bool
+    filename: str
+    analysis: Optional[str] = None
+    error: Optional[str] = None
+
+
+@router.post("/analyze", response_model=FileAnalysisResponse)
+async def analyze_file(
+    request: FileAnalysisRequest,
+    user: dict = Depends(require_auth)
+):
+    """
+    分析上傳的文件內容
+    支援 PDF、圖片、文字文件等
+    """
+    user_id = user.get("sub")
+    if not user_id:
+        raise HTTPException(status_code=401, detail="無效的用戶")
+
+    try:
+        # 解碼文件內容
+        try:
+            file_content = base64.b64decode(request.content)
+        except Exception:
+            return FileAnalysisResponse(
+                success=False,
+                filename=request.filename,
+                error="無法解碼文件內容",
+            )
+
+        # 根據 MIME 類型處理
+        mime_type = request.mime_type.lower()
+        extracted_text = ""
+
+        if mime_type.startswith("text/"):
+            # 文字文件
+            try:
+                extracted_text = file_content.decode("utf-8")
+            except UnicodeDecodeError:
+                extracted_text = file_content.decode("latin-1")
+
+        elif mime_type == "application/pdf":
+            # PDF 文件
+            try:
+                import pdfplumber
+                import io
+                
+                with pdfplumber.open(io.BytesIO(file_content)) as pdf:
+                    pages_text = []
+                    for page in pdf.pages:
+                        text = page.extract_text()
+                        if text:
+                            pages_text.append(text)
+                    extracted_text = "\n\n".join(pages_text)
+            except ImportError:
+                return FileAnalysisResponse(
+                    success=False,
+                    filename=request.filename,
+                    error="PDF 處理模組不可用",
+                )
+            except Exception as e:
+                return FileAnalysisResponse(
+                    success=False,
+                    filename=request.filename,
+                    error=f"PDF 解析失敗: {str(e)}",
+                )
+
+        elif mime_type.startswith("image/"):
+            # 圖片文件 - 使用 GPT-4 Vision
+            try:
+                import services.ai_service as ai_service
+                
+                # 構建 Vision API 請求
+                image_base64 = request.content
+                messages = [
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": request.user_prompt},
+                            {
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": f"data:{mime_type};base64,{image_base64}"
+                                }
+                            }
+                        ]
+                    }
+                ]
+
+                analysis = await ai_service.generate_response_async(
+                    messages,
+                    model="gpt-4o-mini",  # 使用支援 Vision 的模型
+                )
+
+                return FileAnalysisResponse(
+                    success=True,
+                    filename=request.filename,
+                    analysis=analysis,
+                )
+
+            except Exception as e:
+                return FileAnalysisResponse(
+                    success=False,
+                    filename=request.filename,
+                    error=f"圖片分析失敗: {str(e)}",
+                )
+
+        else:
+            return FileAnalysisResponse(
+                success=False,
+                filename=request.filename,
+                error=f"不支援的文件類型: {mime_type}",
+            )
+
+        # 使用 AI 分析提取的文字
+        if extracted_text:
+            try:
+                import services.ai_service as ai_service
+                
+                messages = [
+                    {
+                        "role": "system",
+                        "content": "你是一個專業的文件分析助手。請根據用戶的要求分析以下文件內容。"
+                    },
+                    {
+                        "role": "user",
+                        "content": f"{request.user_prompt}\n\n文件內容：\n{extracted_text[:10000]}"  # 限制長度
+                    }
+                ]
+
+                analysis = await ai_service.generate_response_async(messages)
+
+                return FileAnalysisResponse(
+                    success=True,
+                    filename=request.filename,
+                    analysis=analysis,
+                )
+
+            except Exception as e:
+                return FileAnalysisResponse(
+                    success=False,
+                    filename=request.filename,
+                    error=f"AI 分析失敗: {str(e)}",
+                )
+
+        return FileAnalysisResponse(
+            success=False,
+            filename=request.filename,
+            error="無法提取文件內容",
+        )
+
+    except Exception as e:
+        logger.exception(f"文件分析失敗: {e}")
+        return FileAnalysisResponse(
+            success=False,
+            filename=request.filename,
+            error=str(e),
+        )
+
+
+@router.post("/upload")
+async def upload_file(
+    file: UploadFile = File(...),
+    user: dict = Depends(require_auth)
+):
+    """
+    上傳文件（返回 base64 編碼）
+    """
+    user_id = user.get("sub")
+    if not user_id:
+        raise HTTPException(status_code=401, detail="無效的用戶")
+
+    try:
+        # 讀取文件內容
+        content = await file.read()
+        
+        # 檢查文件大小（限制 10MB）
+        if len(content) > 10 * 1024 * 1024:
+            raise HTTPException(status_code=413, detail="文件大小超過限制（10MB）")
+
+        # 編碼為 base64
+        content_base64 = base64.b64encode(content).decode("utf-8")
+
+        # 獲取 MIME 類型
+        mime_type = file.content_type or mimetypes.guess_type(file.filename)[0] or "application/octet-stream"
+
+        return {
+            "success": True,
+            "filename": file.filename,
+            "mime_type": mime_type,
+            "size": len(content),
+            "content": content_base64,
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.exception(f"文件上傳失敗: {e}")
+        raise HTTPException(status_code=500, detail=str(e))

routers/health.py

@@ -0,0 +1,220 @@
+"""
+健康數據相關 API 路由
+包含 HealthKit 數據同步等
+"""
+
+import logging
+from datetime import datetime
+from typing import List, Optional, Dict, Any
+from fastapi import APIRouter, HTTPException, Depends
+from pydantic import BaseModel
+
+from core.auth import require_auth
+
+logger = logging.getLogger("routers.health")
+
+router = APIRouter(prefix="/api/health", tags=["健康數據"])
+
+
+class HealthDataPoint(BaseModel):
+    """健康數據點"""
+    type: str  # heart_rate, steps, sleep, etc.
+    value: float
+    unit: str
+    timestamp: datetime
+    source: Optional[str] = None
+
+
+class HealthDataSyncRequest(BaseModel):
+    """健康數據同步請求"""
+    data: List[HealthDataPoint]
+
+
+class HealthQueryRequest(BaseModel):
+    """健康數據查詢請求"""
+    types: List[str]
+    start_date: Optional[datetime] = None
+    end_date: Optional[datetime] = None
+
+
+@router.post("/sync")
+async def sync_health_data(
+    request: HealthDataSyncRequest,
+    user: dict = Depends(require_auth)
+):
+    """
+    同步健康數據（從 HealthKit/Google Fit）
+    """
+    user_id = user.get("sub")
+    if not user_id:
+        raise HTTPException(status_code=401, detail="無效的用戶")
+
+    try:
+        from core.database import firestore_db
+        
+        if not firestore_db:
+            raise HTTPException(status_code=503, detail="數據庫不可用")
+
+        # 批量寫入健康數據
+        batch = firestore_db.batch()
+        health_collection = firestore_db.collection("health_data")
+
+        for data_point in request.data:
+            doc_ref = health_collection.document()
+            batch.set(doc_ref, {
+                "user_id": user_id,
+                "type": data_point.type,
+                "value": data_point.value,
+                "unit": data_point.unit,
+                "timestamp": data_point.timestamp,
+                "source": data_point.source,
+                "synced_at": datetime.now(),
+            })
+
+        # 執行批量寫入
+        import asyncio
+        await asyncio.to_thread(batch.commit)
+
+        logger.info(f"用戶 {user_id} 同步了 {len(request.data)} 條健康數據")
+
+        return {
+            "success": True,
+            "synced_count": len(request.data),
+        }
+
+    except Exception as e:
+        logger.exception(f"健康數據同步失敗: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/query")
+async def query_health_data(
+    request: HealthQueryRequest,
+    user: dict = Depends(require_auth)
+):
+    """
+    查詢健康數據
+    """
+    user_id = user.get("sub")
+    if not user_id:
+        raise HTTPException(status_code=401, detail="無效的用戶")
+
+    try:
+        from core.database import firestore_db
+        from google.cloud.firestore import FieldFilter
+        
+        if not firestore_db:
+            raise HTTPException(status_code=503, detail="數據庫不可用")
+
+        health_collection = firestore_db.collection("health_data")
+        
+        # 構建查詢
+        query = health_collection.where(
+            filter=FieldFilter("user_id", "==", user_id)
+        )
+
+        # 時間範圍過濾
+        if request.start_date:
+            query = query.where(
+                filter=FieldFilter("timestamp", ">=", request.start_date)
+            )
+        if request.end_date:
+            query = query.where(
+                filter=FieldFilter("timestamp", "<=", request.end_date)
+            )
+
+        # 執行查詢
+        import asyncio
+        docs = await asyncio.to_thread(lambda: list(query.stream()))
+
+        # 過濾類型並格式化結果
+        results: Dict[str, List[Dict[str, Any]]] = {t: [] for t in request.types}
+        
+        for doc in docs:
+            data = doc.to_dict()
+            data_type = data.get("type")
+            if data_type in request.types:
+                results[data_type].append({
+                    "value": data.get("value"),
+                    "unit": data.get("unit"),
+                    "timestamp": data.get("timestamp"),
+                    "source": data.get("source"),
+                })
+
+        return {
+            "success": True,
+            "data": results,
+        }
+
+    except Exception as e:
+        logger.exception(f"健康數據查詢失敗: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/summary")
+async def get_health_summary(user: dict = Depends(require_auth)):
+    """
+    獲取健康數據摘要（今日）
+    """
+    user_id = user.get("sub")
+    if not user_id:
+        raise HTTPException(status_code=401, detail="無效的用戶")
+
+    try:
+        from core.database import firestore_db
+        from google.cloud.firestore import FieldFilter
+        
+        if not firestore_db:
+            raise HTTPException(status_code=503, detail="數據庫不可用")
+
+        # 今日開始時間
+        today_start = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+
+        health_collection = firestore_db.collection("health_data")
+        
+        query = health_collection.where(
+            filter=FieldFilter("user_id", "==", user_id)
+        ).where(
+            filter=FieldFilter("timestamp", ">=", today_start)
+        )
+
+        import asyncio
+        docs = await asyncio.to_thread(lambda: list(query.stream()))
+
+        # 計算摘要
+        summary = {
+            "steps": 0,
+            "heart_rate_avg": 0,
+            "heart_rate_readings": [],
+            "sleep_hours": 0,
+            "active_calories": 0,
+        }
+
+        for doc in docs:
+            data = doc.to_dict()
+            data_type = data.get("type")
+            value = data.get("value", 0)
+
+            if data_type == "steps":
+                summary["steps"] += value
+            elif data_type == "heart_rate":
+                summary["heart_rate_readings"].append(value)
+            elif data_type == "sleep":
+                summary["sleep_hours"] += value
+            elif data_type == "active_calories":
+                summary["active_calories"] += value
+
+        # 計算心率平均值
+        if summary["heart_rate_readings"]:
+            summary["heart_rate_avg"] = sum(summary["heart_rate_readings"]) / len(summary["heart_rate_readings"])
+        del summary["heart_rate_readings"]
+
+        return {
+            "success": True,
+            "date": today_start.date().isoformat(),
+            "summary": summary,
+        }
+
+    except Exception as e:
+        logger.exception(f"健康摘要獲取失敗: {e}")
+        raise HTTPException(status_code=500, detail=str(e))

routers/system.py

@@ -0,0 +1,115 @@
+"""
+系統相關 API 路由
+包含狀態檢查、效能統計、MCP 工具列表等
+"""
+
+from typing import Optional, Dict, Any
+from fastapi import APIRouter, Depends
+from fastapi.responses import RedirectResponse
+
+from core.auth import get_current_user_optional
+from core.logging import get_logger
+from core.config import settings
+
+logger = get_logger("routers.system")
+
+router = APIRouter(tags=["系統"])
+
+
+@router.get("/")
+async def root():
+    """根路徑導向登入頁面"""
+    return RedirectResponse(url="/login/")
+
+
+@router.get("/status")
+async def get_status():
+    """系統狀態檢查"""
+    return {
+        "status": "running",
+        "version": "2.0.0",
+        "environment": settings.ENVIRONMENT,
+    }
+
+
+@router.get("/api/mcp/tools")
+async def list_mcp_tools(current_user: dict = Depends(get_current_user_optional)):
+    """
+    列出所有可用的 MCP 工具
+
+    Returns:
+        工具列表，包含名稱、描述、參數等
+    """
+    try:
+        # 延遲導入避免循環依賴
+        from app import app
+
+        if not hasattr(app.state, 'feature_router'):
+            return {
+                "success": False,
+                "error": "MCP 服務尚未初始化",
+                "tools": []
+            }
+
+        feature_router = app.state.feature_router
+        tools_info = []
+
+        for tool_name, tool in feature_router.mcp_server.tools.items():
+            tool_info = {
+                "name": tool_name,
+                "description": getattr(tool, 'description', '無描述'),
+            }
+
+            # 嘗試獲取參數 schema
+            if hasattr(tool, 'handler') and hasattr(tool.handler, '__self__'):
+                tool_class = tool.handler.__self__
+                if hasattr(tool_class, 'get_input_schema'):
+                    try:
+                        tool_info["parameters"] = tool_class.get_input_schema()
+                    except Exception:
+                        pass
+
+            tools_info.append(tool_info)
+
+        return {
+            "success": True,
+            "count": len(tools_info),
+            "tools": tools_info
+        }
+
+    except Exception as e:
+        logger.error(f"獲取 MCP 工具列表失敗: {e}")
+        return {
+            "success": False,
+            "error": str(e),
+            "tools": []
+        }
+
+
+@router.get("/api/performance/stats")
+async def get_performance_stats(current_user: dict = Depends(get_current_user_optional)):
+    """
+    獲取系統效能統計
+
+    Returns:
+        快取命中率、查詢統計等
+    """
+    try:
+        from core.database.cache import db_cache
+        from core.database.optimized import query_optimizer
+
+        cache_stats = db_cache.get_all_stats()
+        query_stats = query_optimizer.get_stats()
+
+        return {
+            "success": True,
+            "cache": cache_stats,
+            "queries": query_stats,
+        }
+
+    except Exception as e:
+        logger.error(f"獲取效能統計失敗: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }

routers/voice.py

@@ -0,0 +1,239 @@
+"""
+語音相關 API 路由
+包含語音登入、TTS、STT 等
+"""
+
+import logging
+from typing import Optional
+from fastapi import APIRouter, HTTPException, Depends
+from pydantic import BaseModel
+
+from core.auth import require_auth
+from core.database import set_user_speaker_label, get_user_by_speaker_label
+
+logger = logging.getLogger("routers.voice")
+
+router = APIRouter(prefix="/api/voice", tags=["語音"])
+
+
+class SpeakerLabelBindRequest(BaseModel):
+    """綁定語音標籤請求"""
+    speaker_label: str
+
+
+class TTSRequest(BaseModel):
+    """TTS 請求"""
+    text: str
+    voice: str = "nova"
+    speed: float = 1.0
+
+
+@router.post("/bind-speaker")
+async def bind_speaker_label(
+    request: SpeakerLabelBindRequest,
+    user: dict = Depends(require_auth)
+):
+    """
+    綁定語音標籤到用戶帳號
+    """
+    user_id = user.get("sub")
+    if not user_id:
+        raise HTTPException(status_code=401, detail="無效的用戶")
+
+    result = await set_user_speaker_label(user_id, request.speaker_label)
+    
+    if not result.get("success"):
+        error = result.get("error")
+        if error == "SPEAKER_LABEL_TAKEN":
+            raise HTTPException(status_code=409, detail="此語音標籤已被其他用戶綁定")
+        elif error == "USER_NOT_FOUND":
+            raise HTTPException(status_code=404, detail="用戶不存在")
+        else:
+            raise HTTPException(status_code=500, detail=error)
+
+    return {"success": True, "message": "語音標籤綁定成功"}
+
+
+@router.get("/lookup-speaker/{speaker_label}")
+async def lookup_speaker(speaker_label: str):
+    """
+    根據語音標籤查找用戶（用於語音登入）
+    """
+    user = await get_user_by_speaker_label(speaker_label)
+    
+    if not user:
+        raise HTTPException(status_code=404, detail="找不到對應的用戶")
+
+    return {
+        "success": True,
+        "user": {
+            "id": user.get("id"),
+            "name": user.get("name"),
+        }
+    }
+
+
+@router.post("/tts")
+async def text_to_speech(
+    request: TTSRequest,
+    user: dict = Depends(require_auth)
+):
+    """
+    文字轉語音
+    """
+    try:
+        from services.tts_service import tts_service
+        
+        result = await tts_service.synthesize(
+            text=request.text,
+            voice=request.voice,
+            speed=request.speed,
+        )
+
+        if not result.get("success"):
+            raise HTTPException(status_code=500, detail=result.get("error"))
+
+        # 返回 base64 編碼的音頻
+        import base64
+        audio_base64 = base64.b64encode(result["audio_data"]).decode("utf-8")
+
+        return {
+            "success": True,
+            "audio": audio_base64,
+            "voice": result.get("voice"),
+        }
+
+    except ImportError:
+        raise HTTPException(status_code=503, detail="TTS 服務不可用")
+    except Exception as e:
+        logger.exception(f"TTS 失敗: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+class VoiceLoginRequest(BaseModel):
+    """語音登入請求"""
+    audio_base64: str  # base64 編碼的 PCM16 音訊
+    sample_rate: int = 16000
+
+
+class VoiceLoginResponse(BaseModel):
+    """語音登入回應"""
+    success: bool
+    access_token: str = None
+    user: dict = None
+    emotion: str = None
+    error: str = None
+
+
+@router.post("/login", response_model=VoiceLoginResponse)
+async def voice_login(request: VoiceLoginRequest):
+    """
+    語音登入 API
+    
+    流程：
+    1. 接收 base64 編碼的音訊
+    2. 執行身份辨識 + 情緒辨識
+    3. 查詢 speaker_label 對應的用戶
+    4. 生成 JWT token
+    5. 回傳 token + 情緒
+    """
+    import base64
+    import jwt
+    from datetime import datetime, timedelta
+    from core.config import settings
+    
+    try:
+        # 取得 VoiceAuthService 實例
+        from fastapi import Request
+        from main import app
+        
+        voice_auth = getattr(app.state, "voice_auth", None)
+        if not voice_auth:
+            # 嘗試動態建立
+            from services.voice_login import VoiceAuthService, VoiceLoginConfig
+            voice_auth = VoiceAuthService(config=VoiceLoginConfig(
+                window_seconds=3,
+                required_windows=1,
+            ))
+        
+        # 解碼音訊
+        audio_bytes = base64.b64decode(request.audio_base64)
+        
+        # 建立臨時 session 並處理音訊
+        temp_user_id = f"voice_login_{datetime.now().timestamp()}"
+        voice_auth.start_session(temp_user_id, request.sample_rate)
+        voice_auth._buffers[temp_user_id] = bytearray(audio_bytes)
+        
+        # 執行辨識
+        result = voice_auth.stop_and_authenticate(temp_user_id)
+        
+        # 清理 session
+        voice_auth.clear_session(temp_user_id)
+        
+        if not result.get("success"):
+            error_code = result.get("error", "UNKNOWN_ERROR")
+            error_messages = {
+                "NO_AUDIO": "沒有收到音訊資料",
+                "AUDIO_TOO_SHORT": "音訊太短，請錄製至少 3 秒",
+                "LOW_SNR": "環境太吵，請在安靜的地方重試",
+                "INCONSISTENT_WINDOWS": "無法確認身份，請重試",
+                "THRESHOLD_NOT_MET": "無法確認身份，請重試",
+                "MODEL_ERROR": "辨識系統錯誤，請稍後重試",
+            }
+            return VoiceLoginResponse(
+                success=False,
+                error=error_messages.get(error_code, f"辨識失敗：{error_code}")
+            )
+        
+        # 取得辨識結果
+        speaker_label = result.get("label")
+        emotion = result.get("emotion", {})
+        emotion_label = emotion.get("label", "neutral") if isinstance(emotion, dict) else "neutral"
+        
+        logger.info(f"🎙️ 語音辨識成功: speaker={speaker_label}, emotion={emotion_label}")
+        
+        # 查詢對應的用戶
+        user = await get_user_by_speaker_label(speaker_label)
+        
+        if not user:
+            return VoiceLoginResponse(
+                success=False,
+                error=f"找不到綁定的帳號。請先使用 Google 登入並綁定語音。"
+            )
+        
+        # 生成 JWT token
+        user_id = user.get("id")
+        user_name = user.get("name", "用戶")
+        user_email = user.get("email", "")
+        
+        payload = {
+            "sub": user_id,
+            "name": user_name,
+            "email": user_email,
+            "iat": datetime.utcnow(),
+            "exp": datetime.utcnow() + timedelta(days=7),
+            "login_method": "voice",
+            "emotion": emotion_label,
+        }
+        
+        token = jwt.encode(payload, settings.JWT_SECRET, algorithm="HS256")
+        
+        logger.info(f"✅ 語音登入成功: user={user_name}, emotion={emotion_label}")
+        
+        return VoiceLoginResponse(
+            success=True,
+            access_token=token,
+            user={
+                "id": user_id,
+                "name": user_name,
+                "email": user_email,
+            },
+            emotion=emotion_label,
+        )
+        
+    except Exception as e:
+        logger.exception(f"❌ 語音登入失敗: {e}")
+        return VoiceLoginResponse(
+            success=False,
+            error=f"系統錯誤：{str(e)}"
+        )

services/ai_service.py

@@ -1,39 +1,21 @@
-import os
-import sys
-import logging
 import asyncio
-from dotenv import load_dotenv
 from datetime import datetime, timezone, timedelta
 import time
 import json
 from typing import Dict, List, Any, Optional
 
-# 設置日誌
-# 設定日誌等級：預設 WARNING，可透過 BLOOMWARE_LOG_LEVEL 覆寫
-LOG_LEVEL_NAME = os.getenv("BLOOMWARE_LOG_LEVEL", "WARNING").upper()
-LOG_LEVEL = getattr(logging, LOG_LEVEL_NAME, logging.WARNING)
-logging.basicConfig(
-    level=LOG_LEVEL,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger("AI_Service")
-# 將終端日誌級別設置為 ERROR（保留重要訊息）
-console_handler = logging.StreamHandler()
-console_handler.setLevel(logging.ERROR)
-formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-console_handler.setFormatter(formatter)
-logger.addHandler(console_handler)
-logger.propagate = False  # 防止日誌重複輸出
-logger.setLevel(LOG_LEVEL)
-
-# 載入環境變數
-load_dotenv()
+# 統一日誌配置
+from core.logging import get_logger
+logger = get_logger("AI_Service")
 
 # 統一配置管理
 from core.config import settings
 
+# 統一 OpenAI 客戶端
+from core.ai_client import get_openai_client
+
 # 超時設定（秒）
-OPENAI_TIMEOUT = settings.OPENAI_TIMEOUT  # 關懷模式 reasoning model 需要更長時間
+OPENAI_TIMEOUT = settings.OPENAI_TIMEOUT
 
 # 情緒關懷模式 System Prompt（新增）
 CARE_MODE_SYSTEM_PROMPT = """你是 BloomWare 的情緒關懷助手「小花」，由銘傳大學人工智慧應用學系槓上開發團隊打造。你不是 GPT，也不要自稱 GPT；你的任務是在情緒低落時傾聽、陪伴。
@@ -55,21 +37,13 @@ CARE_MODE_SYSTEM_PROMPT = """你是 BloomWare 的情緒關懷助手「小花」
 用戶：「我很生氣」 → 你：「這件事讓你超級生氣，情緒一定卡著。要不要跟我說說最困擾你的地方？」
 用戶：「講笑話給我聽」 → 你：「你想聽點輕鬆的，我當然可以陪你。想先聽小笑話還是先聊聊怎麼了？」"""
 
-# 導入時間服務模組
-# from features.daily_life.time_service import get_current_time_data, format_time_for_messages  # 已整合到 MCPAgentBridge
+# 取得 OpenAI 客戶端（使用統一管理）
+def _get_client():
+    """取得 OpenAI 客戶端"""
+    return get_openai_client()
 
-# 嘗試導入 OpenAI
-try:
-    import openai
-    from openai import OpenAI
-    client = OpenAI(
-        api_key=os.getenv("OPENAI_API_KEY"),
-        timeout=30.0,  # 增加超時時間
-        max_retries=3   # 添加重試次數
-    )
-except Exception as e:
-    logger.error(f"初始化 OpenAI 客戶端失敗: {e}")
-    client = None
+# 向後相容：保留 client 變數名稱
+client = None  # 將在首次使用時透過 _get_client() 取得
 
 # 導入DB函數
 try:
@@ -486,22 +460,9 @@ def _extract_text_from_message_obj(message: Any) -> str:
         return ""
 
 def initialize_openai():
-    """初始化OpenAI客戶端"""
-    global client
-    api_key = settings.OPENAI_API_KEY
-    if not api_key:
-        logger.error("OpenAI API密鑰未設置，請在.env文件中設置OPENAI_API_KEY環境變數")
-        print("\n❌ 錯誤: OpenAI API密鑰未設置！請在.env文件中設置OPENAI_API_KEY\n")
-        return False
-    try:
-        logger.info("正在初始化OpenAI客戶端...")
-        client = OpenAI(api_key=api_key)
-        logger.info("OpenAI 客戶端初始化完成")
-        return True
-    except Exception as e:
-        logger.error(f"初始化OpenAI客戶端失敗: {e}")
-        print(f"\n❌ OpenAI API連接失敗: {e}\n")
-        return False
+    """初始化OpenAI客戶端（使用統一管理）"""
+    from core.ai_client import is_available
+    return is_available()
 
 ## 已移除內部測試函式 test_openai_response，避免干擾正式流程
 
@@ -532,7 +493,8 @@ async def generate_response_async(
         stream: 是否啟用串流模式（2025 最佳實踐）
         on_chunk: 串流 chunk 回調函數（async callable）
     """
-    if client is None and not initialize_openai():
+    openai_client = _get_client()
+    if openai_client is None:
         return "抱歉，AI服務暫時不可用。系統無法連接到OpenAI服務。"
     try:
         start_time = time.time()
@@ -579,7 +541,7 @@ async def generate_response_async(
             full_response = ""
             stream_obj = await loop.run_in_executor(
                 None,
-                lambda: client.chat.completions.create(**request_kwargs)
+                lambda: openai_client.chat.completions.create(**request_kwargs)
             )
 
             # 逐塊處理
@@ -602,7 +564,7 @@ async def generate_response_async(
             response = await asyncio.wait_for(
                 loop.run_in_executor(
                     None,
-                    lambda: client.chat.completions.create(**request_kwargs),
+                    lambda: openai_client.chat.completions.create(**request_kwargs),
                 ),
                 timeout=OPENAI_TIMEOUT,
             )
@@ -779,7 +741,11 @@ async def _generate_response_with_chat_db(
                     system_prompt = (
                         "你是 BloomWare 的個人化助理 小花，由銘傳大學人工智慧應用學系 槓上開發 團隊開發。"
                         "你不是 GPT，也不要自稱 GPT。"
-                        "你是一個友善、有禮、幽默且能夠提供幫助的AI助手。請使用繁體中文回覆，保持簡潔清晰的表達。"
+                        "你是一個友善、有禮、幽默且能夠提供幫助的AI助手。\n\n"
+                        "【重要】語言使用規範：\n"
+                        "- 回覆用戶時：必須使用繁體中文，保持簡潔清晰的表達\n"
+                        "- 調用工具時：所有參數必須使用英文（城市名、國家名、貨幣代碼等）\n"
+                        "- 範例：用戶問「台北天氣」→ 調用工具時參數用 {\"city\": \"Taipei\"}，回覆時說「台北目前...\""
                     )
 
                 # 在系統提示前加上用戶名稱
@@ -982,7 +948,11 @@ async def _generate_response_with_global_history(
                     system_prompt = (
                         "你是 BloomWare 的個人化助理 小花，由銘傳大學人工智慧應用學系 槓上開發 團隊開發。"
                         "你不是 GPT，也不要自稱 GPT。"
-                        "你是一個友善、有禮、幽默且能夠提供幫助的AI助手。請使用繁體中文回覆，保持簡潔清晰的表達。"
+                        "你是一個友善、有禮、幽默且能夠提供幫助的AI助手。\n\n"
+                        "【重要】語言使用規範：\n"
+                        "- 回覆用戶時：必須使用繁體中文，保持簡潔清晰的表達\n"
+                        "- 調用工具時：所有參數必須使用英文（城市名、國家名、貨幣代碼等）\n"
+                        "- 範例：用戶問「台北天氣」→ 調用工具時參數用 {\"city\": \"Taipei\"}，回覆時說「台北目前...\""
                     )
 
                 # 在系統提示前加上用戶名稱
@@ -1093,3 +1063,107 @@ async def _generate_response_with_global_history(
             raise
         logger.error(f"全局歷史處理出錯: {e}")
         raise
+
+
+async def generate_response_with_tools(
+    messages: List[Dict[str, str]],
+    tools: List[Dict[str, Any]],
+    user_id: str = "default",
+    model: str = "gpt-5-nano",
+    reasoning_effort: Optional[str] = None,
+    tool_choice: str = "auto",
+) -> Dict[str, Any]:
+    """
+    使用 OpenAI Function Calling 生成回應
+    
+    2025 最佳實踐：讓 GPT 原生選擇工具，不需要自定義意圖檢測 Prompt
+    
+    Args:
+        messages: 對話訊息列表
+        tools: OpenAI tools 格式的工具定義列表
+        user_id: 用戶 ID（用於日誌）
+        model: 模型名稱
+        reasoning_effort: 推理強度 (minimal/low/medium/high)
+        tool_choice: 工具選擇策略 ("auto", "none", "required", 或特定工具名)
+    
+    Returns:
+        包含 tool_calls 和 content 的字典
+    """
+    openai_client = _get_client()
+    if openai_client is None:
+        logger.error("OpenAI 客戶端不可用")
+        return {"content": "", "tool_calls": []}
+    
+    try:
+        start_time = time.time()
+        loop = asyncio.get_event_loop()
+        
+        request_kwargs = {
+            "model": model,
+            "messages": messages,
+            "tools": tools,
+            "tool_choice": tool_choice,
+            "max_completion_tokens": 1000,
+        }
+        
+        # 加入 reasoning_effort 控制
+        if reasoning_effort:
+            request_kwargs["reasoning_effort"] = reasoning_effort
+            logger.info(f"🧠 Function Calling 推理強度: {reasoning_effort}")
+        
+        logger.info(f"🔧 Function Calling 請求: {len(tools)} 個工具, tool_choice={tool_choice}")
+        logger.debug(f"📤 發送的訊息: {messages}")
+        
+        response = await asyncio.wait_for(
+            loop.run_in_executor(
+                None,
+                lambda: openai_client.chat.completions.create(**request_kwargs),
+            ),
+            timeout=OPENAI_TIMEOUT,
+        )
+        
+        elapsed_time = time.time() - start_time
+        logger.info(f"⏱️ Function Calling 完成，耗時: {elapsed_time:.2f}秒")
+        
+        # 解析回應
+        message = response.choices[0].message
+        logger.debug(f"📥 原始 message 物件: {message}")
+        
+        result = {
+            "content": message.content or "",
+            "tool_calls": [],
+        }
+        
+        # 提取 tool_calls
+        if message.tool_calls:
+            for tool_call in message.tool_calls:
+                result["tool_calls"].append({
+                    "id": tool_call.id,
+                    "type": "function",
+                    "function": {
+                        "name": tool_call.function.name,
+                        "arguments": tool_call.function.arguments,
+                    }
+                })
+            logger.info(f"✅ GPT 選擇了 {len(result['tool_calls'])} 個工具")
+            for tc in result["tool_calls"]:
+                logger.info(f"   🔧 工具: {tc['function']['name']}")
+                logger.info(f"   📋 參數 JSON: {tc['function']['arguments']}")
+                # 嘗試解析參數
+                try:
+                    import json
+                    parsed = json.loads(tc['function']['arguments'])
+                    logger.info(f"   ✅ 解析後參數: {parsed}")
+                except Exception as e:
+                    logger.warning(f"   ⚠️ 參數解析失敗: {e}")
+        else:
+            logger.info("💬 GPT 未選擇任何工具（一般聊天）")
+        
+        return result
+        
+    except asyncio.TimeoutError:
+        logger.error("Function Calling 請求超時")
+        return {"content": "", "tool_calls": []}
+    except Exception as e:
+        logger.error(f"Function Calling 失敗: {e}")
+        return {"content": "", "tool_calls": []}

services/batch_scheduler.py

@@ -183,10 +183,62 @@ class BatchScheduler:
         Returns:
             {user_id: [memory_1, memory_2, ...]}
         """
-        # TODO: 實作數據庫查詢邏輯
-        # 目前返回空字典（示例）
-        logger.warning("⚠️ _fetch_yesterday_memories 尚未實作，返回空數據")
-        return {}
+        try:
+            if not firestore_db:
+                logger.warning("⚠️ Firestore 未連接，無法獲取記憶")
+                return {}
+
+            from google.cloud.firestore import FieldFilter
+            import asyncio
+
+            # 計算昨日時間範圍
+            yesterday_start = (datetime.now() - timedelta(days=1)).replace(
+                hour=0, minute=0, second=0, microsecond=0
+            )
+            yesterday_end = yesterday_start + timedelta(days=1)
+
+            # 獲取所有用戶
+            users_collection = firestore_db.collection("users")
+            
+            def _fetch_users():
+                return list(users_collection.stream())
+
+            users = await asyncio.to_thread(_fetch_users)
+            
+            result: Dict[str, List[str]] = {}
+
+            for user_doc in users:
+                user_id = user_doc.id
+                
+                # 獲取該用戶的昨日記憶
+                def _fetch_user_memories(uid: str):
+                    memories_ref = firestore_db.collection("users").document(uid).collection("memories")
+                    query = memories_ref.where(
+                        filter=FieldFilter("created_at", ">=", yesterday_start)
+                    ).where(
+                        filter=FieldFilter("created_at", "<", yesterday_end)
+                    )
+                    return list(query.stream())
+
+                memories = await asyncio.to_thread(_fetch_user_memories, user_id)
+                
+                if memories:
+                    memory_contents = []
+                    for mem_doc in memories:
+                        mem_data = mem_doc.to_dict()
+                        content = mem_data.get("content", "")
+                        if content:
+                            memory_contents.append(content)
+                    
+                    if memory_contents:
+                        result[user_id] = memory_contents
+
+            logger.info(f"📚 獲取到 {len(result)} 位用戶的昨日記憶")
+            return result
+
+        except Exception as e:
+            logger.exception(f"❌ 獲取昨日記憶失敗: {e}")
+            return {}
 
     async def _save_memory_summaries(self, results: List[Dict[str, Any]]):
         """
@@ -195,26 +247,119 @@ class BatchScheduler:
         Args:
             results: 批次結果列表
         """
-        # TODO: 實作數據庫儲存邏輯
+        if not firestore_db:
+            logger.warning("⚠️ Firestore 未連接，無法儲存摘要")
+            return
+
+        import asyncio
+        
         logger.info(f"💾 準備儲存 {len(results)} 條記憶摘要")
+        
+        saved_count = 0
         for result in results:
-            custom_id = result.get("custom_id")  # user_id
-            response = result.get("response", {}).get("body", {})
-            summary = response.get("choices", [{}])[0].get("message", {}).get("content", "")
+            try:
+                custom_id = result.get("custom_id")  # user_id
+                response = result.get("response", {}).get("body", {})
+                summary = response.get("choices", [{}])[0].get("message", {}).get("content", "")
+
+                if not custom_id or not summary:
+                    continue
+
+                logger.debug(f"📝 用戶 {custom_id} 的摘要: {summary[:50]}...")
+
+                # 儲存到用戶的記憶摘要集合
+                def _save_summary(uid: str, summary_text: str):
+                    summaries_ref = firestore_db.collection("users").document(uid).collection("memory_summaries")
+                    summaries_ref.add({
+                        "summary": summary_text,
+                        "date": datetime.now().date().isoformat(),
+                        "created_at": datetime.now(),
+                        "type": "daily",
+                    })
+
+                await asyncio.to_thread(_save_summary, custom_id, summary)
+                saved_count += 1
+
+            except Exception as e:
+                logger.error(f"❌ 儲存用戶 {custom_id} 的摘要失敗: {e}")
 
-            logger.debug(f"📝 用戶 {custom_id} 的摘要: {summary[:50]}...")
-            # await save_memory_summary(custom_id, summary)
+        logger.info(f"✅ 成功儲存 {saved_count}/{len(results)} 條記憶摘要")
 
     async def _fetch_week_health_data(self) -> Dict[str, Dict[str, Any]]:
         """
         從數據庫獲取所有用戶的本週健康數據
 
         Returns:
-            {user_id: {heart_rate: ..., steps: ...}}
+            {user_id: {heart_rate: [...], steps: [...], sleep: [...], ...}}
         """
-        # TODO: 實作數據庫查詢邏輯
-        logger.warning("⚠️ _fetch_week_health_data 尚未實作，返回空數據")
-        return {}
+        try:
+            if not firestore_db:
+                logger.warning("⚠️ Firestore 未連接，無法獲取健康數據")
+                return {}
+
+            from google.cloud.firestore import FieldFilter
+            import asyncio
+
+            # 計算本週時間範圍（週一到今天）
+            today = datetime.now()
+            week_start = today - timedelta(days=today.weekday())
+            week_start = week_start.replace(hour=0, minute=0, second=0, microsecond=0)
+
+            # 獲取所有用戶
+            users_collection = firestore_db.collection("users")
+            
+            def _fetch_users():
+                return list(users_collection.stream())
+
+            users = await asyncio.to_thread(_fetch_users)
+            
+            result: Dict[str, Dict[str, Any]] = {}
+
+            for user_doc in users:
+                user_id = user_doc.id
+                
+                # 獲取該用戶的本週健康數據
+                def _fetch_user_health(uid: str):
+                    health_ref = firestore_db.collection("health_data")
+                    query = health_ref.where(
+                        filter=FieldFilter("user_id", "==", uid)
+                    ).where(
+                        filter=FieldFilter("timestamp", ">=", week_start)
+                    )
+                    return list(query.stream())
+
+                health_docs = await asyncio.to_thread(_fetch_user_health, user_id)
+                
+                if health_docs:
+                    user_health: Dict[str, List[Any]] = {
+                        "heart_rate": [],
+                        "steps": [],
+                        "sleep": [],
+                        "active_calories": [],
+                    }
+                    
+                    for doc in health_docs:
+                        data = doc.to_dict()
+                        data_type = data.get("type")
+                        value = data.get("value")
+                        timestamp = data.get("timestamp")
+                        
+                        if data_type in user_health and value is not None:
+                            user_health[data_type].append({
+                                "value": value,
+                                "timestamp": timestamp,
+                            })
+                    
+                    # 只保留有數據的用戶
+                    if any(user_health.values()):
+                        result[user_id] = user_health
+
+            logger.info(f"❤️ 獲取到 {len(result)} 位用戶的本週健康數據")
+            return result
+
+        except Exception as e:
+            logger.exception(f"❌ 獲取本週健康數據失敗: {e}")
+            return {}
 
 
 # 全域單例