feat: overhaul MCP architecture with structured tool schemas, comprehensive care-mode skill definitions, and enhanced test coverage for pipelines and service integration.

.env.example

@@ -0,0 +1,83 @@
+# Bloom Ware environment variables
+# Copy to .env and fill real values locally. Do not commit real secrets.
+
+# ===== Application Runtime =====
+ENVIRONMENT=development
+HOST=0.0.0.0
+PORT=7860
+CORS_ORIGINS=*
+
+# ===== Authentication =====
+JWT_SECRET_KEY=replace-with-random-secret
+ACCESS_TOKEN_EXPIRE_MINUTES=30
+
+# ===== Firebase / Firestore =====
+FIREBASE_PROJECT_ID=your-firebase-project-id
+FIREBASE_CREDENTIALS_JSON=
+FIREBASE_SERVICE_ACCOUNT_JSON_BASE64=
+FIREBASE_SERVICE_ACCOUNT_PATH=
+
+# ===== Google OAuth =====
+GOOGLE_CLIENT_ID=your-google-oauth-client-id.apps.googleusercontent.com
+GOOGLE_CLIENT_SECRET=your-google-oauth-client-secret
+GOOGLE_REDIRECT_URI=http://localhost:8080/auth/google/callback
+
+# ===== Google Cloud 語音（STT/TTS）— 與 Firebase、OAuth 登入「不同專案／不同憑證」=====
+#
+# 三種 Google 身分請分開設定，勿混用：
+#   (1) Firebase / Firestore     → FIREBASE_PROJECT_ID + FIREBASE_* 服務帳戶
+#   (2) Google OAuth（網站登入）→ GOOGLE_CLIENT_ID / GOOGLE_CLIENT_SECRET
+#   (3) 語音 GCP（Speech + TTS）→ 專案 ID 字串例：supervisor-project；控制台「專案編號」僅供對照，API 請用專案 ID
+#
+# 已啟用 API：Cloud Speech-to-Text、Cloud Text-to-Speech。
+#   - TTS（REST）：使用 GOOGLE_TTS_API_KEY 或 GOOGLE_SPEECH_API_KEY（與 GOOGLE_API_KEY 可同一支）
+#   - STT v2「串流」：官方為 gRPC，必須使用「語音專案」的服務帳戶 OAuth（GOOGLE_SPEECH_*）；僅 API Key 無法走現有串流實作
+#
+# 語音專案 STT 必備（擇一）：GOOGLE_SPEECH_CREDENTIALS_JSON / GOOGLE_SPEECH_SERVICE_ACCOUNT_JSON_BASE64 / GOOGLE_SPEECH_SERVICE_ACCOUNT_PATH
+GOOGLE_SPEECH_PROJECT_ID=supervisor-project
+GOOGLE_SPEECH_CREDENTIALS_JSON=
+GOOGLE_SPEECH_SERVICE_ACCOUNT_JSON_BASE64=
+GOOGLE_SPEECH_SERVICE_ACCOUNT_PATH=
+# 語音專案預設 ID（未單獨設 GOOGLE_SPEECH_PROJECT_ID 時亦會參考）；勿只填專案「編號」
+GOOGLE_CLOUD_PROJECT_ID=supervisor-project
+GOOGLE_STT_ACCESS_TOKEN=
+GOOGLE_API_KEY=your-google-api-key-for-tts-and-rest
+GOOGLE_SPEECH_API_KEY=
+GOOGLE_TTS_API_KEY=
+GOOGLE_STT_LOCATION=global
+GOOGLE_STT_RECOGNIZER_ID=_
+GOOGLE_STT_AUTO_LANGUAGE_CODES=cmn-Hant-TW,en-US,ja-JP
+GOOGLE_TTS_LANGUAGE_CODE=cmn-TW
+GOOGLE_TTS_DEFAULT_VOICE=cmn-TW-Wavenet-A
+
+# ===== OpenAI Agent =====
+OPENAI_API_KEY=your-openai-api-key
+OPENAI_BASE_URL=https://sub2api.flowatelier.com
+OPENAI_MODEL=gpt-5.4
+OPENAI_TIMEOUT=30
+OPENAI_RESPONSES_TIMEOUT=90
+OPENAI_USE_RESPONSES=true
+OPENAI_MODEL_CONTEXT_WINDOW=1000000
+OPENAI_MODEL_AUTO_COMPACT_TOKEN_LIMIT=900000
+OPENAI_ENABLE_WEB_SEARCH=true
+OPENAI_ENABLE_REMOTE_MCP=true
+OPENAI_REMOTE_MCP_SERVERS_JSON=[]
+OPENAI_ENABLE_SKILLS=true
+USE_GPT_INTENT=true
+GPT_INTENT_MODEL=gpt-5.4
+
+# ===== External Data APIs =====
+WEATHER_API_KEY=your-weather-api-key
+TAVILY_API_KEY=your-newsdata-api-key
+EXCHANGE_API_KEY=your-exchange-api-key
+OPENROUTESERVICE_API_KEY=your-openrouteservice-api-key
+TDX_CLIENT_ID=your-tdx-client-id
+TDX_CLIENT_SECRET=your-tdx-client-secret
+
+# ===== Background Jobs =====
+ENABLE_BACKGROUND_JOBS=true
+
+# ===== Environment Context =====
+ENV_CONTEXT_DISTANCE_THRESHOLD=100
+ENV_CONTEXT_HEADING_THRESHOLD=25
+ENV_CONTEXT_TTL_SECONDS=300

.gitignore

@@ -1,5 +1,7 @@
 # Python
 __pycache__/
+.pytest_cache/
+.benchmarks/
 *.py[cod]
 *$py.class
 *.so
@@ -33,6 +35,7 @@ MANIFEST
 # Firebase credentials (JSON files)
 *-firebase-adminsdk-*.json
 bloomware-*.json
+supervisor-project*.json
 
 # IDE
 .vscode/
@@ -174,4 +177,4 @@ celerybeat.pid
 dmypy.json
 
 # Pyre type checker
-.pyre/
+.pyre/

AGENTS.md

@@ -1,74 +0,0 @@
-# AGENTS.md
-
-## 介紹
-
-你是 白東衢的狗。主要語言 Python。可用 MCP：context7、feedback-enhanced、filesystem、huggingface、playwright、sequential-thinking。所有思考與回覆皆用繁體中文。先思考再行動。
-
-## 全域原則
-
-- 所有 MCP 工具逾時一律 60 分鐘。
-- 非框架情境：以最少檔案完成任務，避免過度模組化。
-- 框架情境：依框架慣例放置檔案。
-- 禁止產生非目的文件：說明文件、依賴清單、README、requirements.txt 等。
-- 禁止要求以命令列參數輸入業務值；業務參數以程式內常數或互動式輸入處理。
-- 需新知時主動檢索：優先從網際網路獲取資訊並使用 huggingface（paper_search、model_search、dataset_search、hf_doc_search）與 context7進行輔佐。
-- playwright 僅用於前端樣式檢查、UI 互動測試、E2E 視覺驗證與截圖，禁止做爬蟲或搜尋。
-- 僅在規定節點使用 feedback-enhanced，禁止重複寒暄。
-
-## 環境與執行限制
-
-- 不得假設環境缺失而自動安裝任何套件或修改系統環境變數。
-- 不得建立或使用任何虛擬環境（venv、conda、poetry 等）。
-- 一律使用當前系統 Python 版本執行與相容（可於程式內讀取 sys.version 僅作紀錄，不觸碰安裝行為）。
-- 不輸出或修改 requirements.txt、pyproject.toml、環境設定檔。
-
-## 框架情境的工作區確認
-
-偵測到整合型框架或既有專案結構時：
-
-- 先用 sequential-thinking 規劃「要改哪些模組、檔名、路徑與測試位置」。
-- 接著必須以一次 feedback-enhanced.interactive_feedback 與使用者確認「基準工作區路徑、允許寫入子資料夾與檔名慣例」。
-- 未獲確認前不得寫入專案根目錄。確認後依框架慣例生成或修改檔案。
-- 非框架情境可寫根目錄，但仍以最小檔案集為原則。
-
-## 思考與行動流程
-
-- sequential-thinking：輸出「目標 → 步驟 → 決策準則 → 風險與驗證」。
-- 取證：context7、huggingface。
-- 產出：filesystem 建立或修改檔案；必要時用 playwright 做 UI 驗證。
-- 回覆內容：只含思考計畫、行動步驟、關鍵程式碼、測試摘要、後續建議。
-
-## 測試與驗證政策
-
-- 為每個新增或修改模組撰寫單元測試與關鍵整合測試。
-- 測試檔命名 test_*.py；框架專案依其慣例放置。
-- 執行方式以終端 Python3 或 Pytest：python3 -m pytest -q 或 pytest -q。
-- 回報測試摘要：通過數、失敗數、失敗案例與原因、可能回歸點、下一步。
-
-## 錯誤處理與互動節奏
-
-發生錯誤或接獲失敗回報時：
-
-- 先以 sequential-thinking 分析根因、解法選項與取捨與影響。
-- 再以一次 feedback-enhanced.interactive_feedback 與使用者對齊解法與影響面。
-- 然後修改程式與測試並重跑驗證。除上述節點外避免重複呼叫 feedback。
-
-## 產出規範
-
-- 預設單檔或少量檔案即可完成任務；框架專案依其結構放置。
-- 程式需具明確進入點：
-  ```
-  if __name__ == "__main__":
-      main()
-  ```
-- 檔案一律透過 filesystem 操作並回報路徑與成功訊息。
-- 不硬編 API 金鑰或密碼；輸出時遮罩敏感資訊。
-- 外部資源不可用時，提出替代方案與自我修正步驟，仍不得觸發安裝或改環境行為。
-
-## 禁止事項總表
-
-- 自動安裝或升降版本、修改環境變數、建立/使用虛擬環境。
-- 產出說明文件、依賴清單或其他非目的文件。
-- 使用命令列參數傳遞業務值。
-- 用 playwright 做爬蟲或搜尋。
-- 無限制地反覆呼叫 feedback-enhanced。

DEPLOY.md

@@ -1,173 +0,0 @@
-# 🚀 Bloom Ware Render 部署指南
-
-## 📋 前置準備
-
-### 1. 生成新的 JWT Secret（生產環境專用）
-```bash
-python3 -c "import secrets; print(secrets.token_urlsafe(32))"
-```
-複製輸出的字串，稍後會用到。
-
-### 2. 將 Firebase JSON 轉為單行字串
-```bash
-cat your-firebase-credentials.json | python3 -m json.tool --compact | pbcopy
-```
-（macOS 會自動複製到剪貼簿）
-
----
-
-## 🔧 Render 部署步驟
-
-### 步驟 1：推送程式碼到 GitHub
-```bash
-git add .
-git commit -m "準備 Render 部署：統一配置管理 + Firebase 環境變數化"
-git push origin main
-```
-
-### 步驟 2：在 Render 建立 Web Service
-1. 登入 [Render](https://render.com/)
-2. 點擊 **New** → **Web Service**
-3. 連接 GitHub 倉庫：選擇 `bloom-ware`
-4. 設定：
-   - **Name**: `bloom-ware`（或自訂名稱）
-   - **Region**: `Singapore` 或 `Oregon`
-   - **Branch**: `main`
-   - **Runtime**: `Python 3`
-   - **Build Command**: `pip install -r requirements.txt`
-   - **Start Command**: `python app.py`
-
-### 步驟 3：設定環境變數
-在 Render Dashboard → Environment 頁面，新增以下環境變數：
-
-#### 必要環境變數（16 項）
-
-| 變數名 | 值 | 說明 |
-|--------|-----|------|
-| `ENVIRONMENT` | `production` | 環境識別 |
-| `FIREBASE_PROJECT_ID` | `your-firebase-project-id` | Firebase 專案 ID |
-| `FIREBASE_CREDENTIALS_JSON` | `{"type":"service_account",...}` | **完整 JSON 字串（單行）** |
-| `OPENAI_API_KEY` | `sk-proj-...` | OpenAI API Key |
-| `OPENAI_MODEL` | `gpt-5-nano` | 模型名稱 |
-| `OPENAI_TIMEOUT` | `30` | 超時秒數 |
-| `GOOGLE_CLIENT_ID` | `your-google-client-id.apps.googleusercontent.com` | Google OAuth Client ID |
-| `GOOGLE_CLIENT_SECRET` | `GOCSPX-...` | Google OAuth Secret |
-| `GOOGLE_REDIRECT_URI` | `https://your-app.onrender.com/auth/google/callback` | **OAuth 回調 URI** |
-| `WEATHER_API_KEY` | `your-weather-api-key` | OpenWeatherMap Key |
-| `NEWSDATA_API_KEY` | `pub_xxxxx` | NewsData.io Key |
-| `EXCHANGE_API_KEY` | `your-exchange-api-key` | ExchangeRate Key |
-| `JWT_SECRET_KEY` | `YOUR_NEW_SECRET` | **新生成的 Secret** |
-| `ACCESS_TOKEN_EXPIRE_MINUTES` | `30` | Token 有效期 |
-| `HOST` | `0.0.0.0` | 監聽主機 |
-| `PORT` | `10000` | Render 固定端口 |
-
-### 步驟 4：部署
-點擊 **Create Web Service**，Render 會自動：
-1. 執行 `pip install -r requirements.txt`
-2. 啟動 `python app.py`
-3. 提供 HTTPS URL（例如：`https://bloom-ware-xxxx.onrender.com`）
-
----
-
-## 🔗 Google OAuth 回調 URI 更新
-
-### 1. 前往 Google Cloud Console
-https://console.cloud.google.com/apis/credentials
-
-### 2. 選擇你的 OAuth 2.0 客戶端
-
-### 3. 新增「已授權的重新導向 URI」
-```
-https://bloom-ware-xxxx.onrender.com/auth/google/callback
-```
-（替換為你的實際 Render 網址）
-
-### 4. 儲存變更
-
-### 5. 更新 Render 環境變數
-回到 Render Dashboard → Environment，更新：
-```
-GOOGLE_REDIRECT_URI=https://bloom-ware-xxxx.onrender.com/auth/google/callback
-```
-
----
-
-## ✅ 驗證部署
-
-### 1. 檢查 Logs
-在 Render Dashboard → Logs 查看：
-```
-✅ Firebase Firestore連接成功！專案ID：your-project-id
-✅ OpenAI 客戶端初始化完成
-🚀 Bloom Ware 後端服務器啟動中...
-```
-
-### 2. 測試連接
-訪問：`https://your-app.onrender.com`
-應該看到前端登入頁面
-
-### 3. 測試 Google 登入
-1. 點擊「使用 Google 登入」
-2. 授權後應該成功跳轉並登入
-
----
-
-## 🐛 常見問題
-
-### 問題 1：Firebase 憑證錯誤
-**錯誤訊息**：`Firebase 憑證載入失敗`
-
-**解決方式**：
-- 確認 `FIREBASE_CREDENTIALS_JSON` 是**單行字串**（無換行符）
-- 檢查 JSON 格式是否正確（使用 `python3 -m json.tool` 驗證）
-
-### 問題 2：Google OAuth 回調失敗
-**錯誤訊息**：`redirect_uri_mismatch`
-
-**解決方式**：
-- 確認 Google Cloud Console 已新增 Render 回調 URI
-- 確認 `GOOGLE_REDIRECT_URI` 環境變數正確
-
-### 問題 3：應用休眠（免費方案）
-**現象**：閒置 15 分鐘後，首次訪問需等待 30 秒
-
-**解決方式**：
-- 升級到付費方案（$7/月）
-- 或使用 UptimeRobot 定期 ping（每 14 分鐘）
-
----
-
-## 📝 部署後清單
-
-- [ ] 測試 Google 登入流程
-- [ ] 測試 WebSocket 連接
-- [ ] 測試語音功能（錄音 + TTS）
-- [ ] 測試 MCP 工具（天氣、新聞、匯率）
-- [ ] 檢查 Firebase Firestore 資料寫入
-- [ ] 監控 Render Logs 是否有錯誤
-
----
-
-## 🔄 更新部署
-
-每次程式碼更新後：
-```bash
-git add .
-git commit -m "更新功能"
-git push origin main
-```
-
-Render 會自動檢測並重新部署（約 2-3 分鐘）。
-
----
-
-## 📞 支援
-
-遇到問題？檢查：
-1. Render Dashboard → Logs
-2. Render Dashboard → Events
-3. GitHub Actions（如有設定 CI/CD）
-
----
-
-**🎉 恭喜！Bloom Ware 已成功部署到 Render！**

app.py

@@ -1,3 +1,4 @@
+# BloomWare Application - Confidence-Driven Agent Loop
 import os
 import json
 import time
@@ -6,6 +7,7 @@ import mimetypes
 import logging
 import secrets
 import jwt
+import unicodedata
 from datetime import datetime
 from typing import List, Dict, Optional, Any
 
@@ -76,6 +78,7 @@ from core.memory_system import memory_manager
 # 環境 Context 寫入 API
 from core.database import set_user_env_current, add_user_env_snapshot
 from core.environment import EnvironmentContextService
+from middleware import CSPMiddleware
 
 
 # -----------------------------
@@ -109,6 +112,77 @@ def serialize_for_json(obj: Any) -> Any:
         except Exception:
             return None
 
+
+def _normalize_bcp47_language_tag(tag: Optional[str]) -> Optional[str]:
+    raw = str(tag or "").strip()
+    if not raw:
+        return None
+    normalized = raw.replace("_", "-")
+    parts = [part for part in normalized.split("-") if part]
+    if not parts:
+        return None
+
+    language = parts[0].lower()
+    rest: List[str] = []
+    for part in parts[1:]:
+        if len(part) == 4 and part.isalpha():
+            rest.append(part.title())
+        elif len(part) in {2, 3} and part.isalpha():
+            rest.append(part.upper())
+        else:
+            rest.append(part)
+    return "-".join([language, *rest])
+
+
+def _preferred_language_from_text(text: str) -> Optional[str]:
+    script_counts: Dict[str, int] = {}
+    for ch in str(text or ""):
+        if ch.isspace():
+            continue
+        try:
+            name = unicodedata.name(ch)
+        except ValueError:
+            continue
+        for script in ("HIRAGANA", "KATAKANA", "HANGUL", "CJK UNIFIED IDEOGRAPH", "LATIN", "CYRILLIC", "THAI"):
+            if script in name:
+                script_counts[script] = script_counts.get(script, 0) + 1
+                break
+
+    if script_counts.get("HIRAGANA", 0) or script_counts.get("KATAKANA", 0):
+        return "ja-JP"
+    if script_counts.get("HANGUL", 0):
+        return "ko-KR"
+    if script_counts.get("THAI", 0):
+        return "th-TH"
+    if script_counts.get("CYRILLIC", 0):
+        return "ru-RU"
+    if script_counts.get("LATIN", 0) and not script_counts.get("CJK UNIFIED IDEOGRAPH", 0):
+        return "en-US"
+    if script_counts.get("CJK UNIFIED IDEOGRAPH", 0):
+        return "zh-TW"
+    return None
+
+
+def _resolve_conversation_language(
+    user_message: str,
+    requested_language: Optional[str],
+    locale_hint: Optional[str] = None,
+) -> str:
+    explicit = _normalize_bcp47_language_tag(requested_language)
+    if explicit and explicit.lower() != "auto":
+        return explicit
+
+    inferred = _preferred_language_from_text(user_message)
+    if inferred:
+        return inferred
+
+    locale_tag = _normalize_bcp47_language_tag(locale_hint)
+    if locale_tag and locale_tag.lower() != "auto":
+        return locale_tag
+
+    return "zh-TW"
+
+
 # -----------------------------
 # Pydantic 模型（從統一模組導入）
 # -----------------------------
@@ -322,33 +396,6 @@ app.add_middleware(
 )
 
 # CSP Middleware（允許內嵌 script 用於語音沉浸式前端）
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request as StarletteRequest
-from starlette.responses import Response
-
-class CSPMiddleware(BaseHTTPMiddleware):
-    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
-
 app.add_middleware(CSPMiddleware)
 
 # 掛載靜態檔案目錄（語音沉浸式前端）
@@ -495,6 +542,18 @@ async def websocket_endpoint_with_jwt(
 
                 td = app.state.feature_router.get_current_time_data()
                 # 使用語音登入傳遞的情緒（如果有）
+                
+                # 如果登入情緒是極端情緒，自動啟動關懷模式
+                is_care_active = False
+                if emotion in ["sad", "angry", "fear"]:
+                    from core.emotion_care_manager import EmotionCareManager
+                    # 使用 force=True 確保從登入情緒直接進入，不需等待連續偵測
+                    is_care_active = EmotionCareManager.check_and_enter_care_mode(
+                        user_id, emotion, chat_id=current_chat_id, force=True
+                    )
+                    if is_care_active:
+                        logger.info(f"💙 偵測到登入情緒 [{emotion}]，自動啟動關懷模式 (user_id={user_id})")
+
                 welcome_msg = compose_welcome(
                     user_name=user_info.get('name'),
                     time_data=td,
@@ -506,19 +565,35 @@ async def websocket_endpoint_with_jwt(
                 welcome_msg = f"歡迎回來，{user_info['name']}！"
 
             # 發送歡迎訊息，並附帶 chat_id
+            # 通知前端當前情緒與關懷模式狀態
+            await websocket.send_json({
+                "type": "emotion_detected",
+                "emotion": emotion or "neutral",
+                "care_mode": is_care_active if 'is_care_active' in locals() else False
+            })
+
             await websocket.send_json({
                 "type": "system",
                 "message": welcome_msg,
-                "chat_id": current_chat_id
+                "chat_id": current_chat_id,
+                "care_mode": is_care_active if 'is_care_active' in locals() else False
             })
 
         while True:
-            data = await websocket.receive_text()
+            try:
+                # 🎯 2026 穩定性優化：加入 WebSocket 心跳 (Ping) 機制，防止長思考工具調用導致連線中斷
+                data = await asyncio.wait_for(websocket.receive_text(), timeout=30.0)
+            except asyncio.TimeoutError:
+                try:
+                    await websocket.send_json({"type": "ping", "timestamp": time.time()})
+                    continue
+                except Exception:
+                    break # 連線已失效
+            
             try:
                 message_data = json.loads(data)
                 message_type_raw = message_data.get("type", "")
                 message_type = (message_type_raw or "").strip().lower()
-
                 # 更新最後活動時間
                 manager.user_sessions[user_id]["last_activity"] = datetime.now()
 
@@ -527,6 +602,7 @@ async def websocket_endpoint_with_jwt(
                     if not user_message:
                         await manager.send_message("收到空消息", user_id, "error")
                         continue
+                    message_language = message_data.get("language") or "auto"
 
                     chat_id = message_data.get("chat_id", None)
 
@@ -573,9 +649,8 @@ async def websocket_endpoint_with_jwt(
                             "content": (
                                 "你是一個友善、有禮且能夠提供幫助的AI助手。\n\n"
                                 "【重要】語言使用規範：\n"
-                                "- 回覆用戶時：必須使用繁體中文，保持簡潔清晰的表達\n"
+                                "- 回覆用戶時：必須使用對應的語言，保持簡潔清晰的表達\n"
                                 "- 調用工具時：所有參數必須使用英文（城市名、國家名、貨幣代碼等）\n\n"
-                                "另外，請勿自稱為 GPT-4 或其他版本。若需要自我介紹，請表述為 '基於 gpt-5-nano 模型'。"
                             ),
                         },
                         {"role": "user", "content": user_message},
@@ -588,7 +663,28 @@ async def websocket_endpoint_with_jwt(
                         try:
                             logger.info(f"🚀 開始處理訊息: user_id={user_id}, chat_id={chat_id}")
                             
-                            async def _on_text_emotion(em: str, cm: bool):
+                            async def _on_text_emotion(em: str, cm: bool, payload: Optional[Dict[str, Any]] = None):
+                                if em == "__bot_delta__" and payload:
+                                    await websocket.send_json({
+                                        "type": "bot_delta",
+                                        "message_id": payload.get("message_id"),
+                                        "delta": payload.get("delta", ""),
+                                        "text": payload.get("text", ""),
+                                        "temporary": True,
+                                        "phase": payload.get("phase", "answering"),
+                                        "timestamp": time.time(),
+                                    })
+                                    return
+                                if em == "__bot_status__" and payload:
+                                    await websocket.send_json({
+                                        "type": "bot_status",
+                                        "status": payload.get("status", "processing"),
+                                        "message": payload.get("message", "正在處理..."),
+                                        "temporary": True,
+                                        "phase": payload.get("phase", payload.get("status", "processing")),
+                                        "timestamp": time.time(),
+                                    })
+                                    return
                                 logger.info(f"📤 [即時回調] 發送 text emotion_detected: {em}, care_mode={cm}")
                                 await websocket.send_json({
                                     "type": "emotion_detected",
@@ -596,7 +692,7 @@ async def websocket_endpoint_with_jwt(
                                     "care_mode": cm
                                 })
 
-                            response = await handle_message(user_message, user_id, chat_id, messages_for_handler, request_id=request_id, emotion_callback=_on_text_emotion)
+                            response = await handle_message(user_message, user_id, chat_id, messages_for_handler, request_id=request_id, language=message_language, emotion_callback=_on_text_emotion)
                             logger.info(f"📥 handle_message 返回: type={type(response)}, response={response}")
 
                             # 【優化】處理空回應：轉換為帶情緒的 dict 格式
@@ -673,8 +769,7 @@ async def websocket_endpoint_with_jwt(
                         except Exception as e:
                             logger.exception(f"❌ _do_process_and_send 發生異常: {e}")
 
-                    import asyncio as _asyncio
-                    _asyncio.create_task(_do_process_and_send())
+                    asyncio.create_task(_do_process_and_send())
 
                 elif message_type == "env_snapshot":
                     try:
@@ -752,7 +847,16 @@ async def websocket_endpoint_with_jwt(
                         sr = 16000
 
                     if mode == "realtime_chat":
-                        # === 即時轉錄模式（使用 OpenAI Realtime API）===
+                        # 🎯 中斷 Barge-in：如果正在處理上一個回覆，立即取消
+                        await manager.cancel_user_tasks(user_id)
+                        
+                        # 🎯 2026 穩定性優化：每次開始對話時清除上一次的音頻緩衝與轉錄，防止「語音殘留」污染下一次識別
+                        client_info = manager.get_client_info(user_id) or {}
+                        client_info["audio_buffer"] = b""
+                        client_info["realtime_transcript"] = ""
+                        manager.set_client_info(user_id, client_info)
+                        
+                        # === 即時轉錄模式（使用 Google Speech-to-Text）===
                         try:
                             from services.realtime_stt_service import RealtimeSTTService
 
@@ -785,21 +889,32 @@ async def websocket_endpoint_with_jwt(
                                 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}")
+                            async def on_vad_committed(status: str):
+                                """VAD 偵測到語音狀態變化"""
+                                if status == "error":
+                                    await websocket.send_json({
+                                        "type": "error",
+                                        "message": "語音識別服務異常 (Stream Timeout)，正在自動重置環境..."
+                                    })
+                                else:
+                                    await websocket.send_json({
+                                        "type": "stt_status",
+                                        "status": status,
+                                        "timestamp": time.time()
+                                    })
+                                logger.debug(f"🎤 VAD Status: {status}")
 
                             # 從前端獲取語言設定（支援：zh, en, id, ja, vi，或 auto 自動檢測）
                             language = message_data.get("language", "auto")
                             logger.info(f"🌐 語言設定: {language}")
 
-                            # 連線到 OpenAI Realtime API
+                            # 連線到 Google Speech-to-Text 服務
                             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=language
+                                language=language,
+                                sample_rate=sr
                             )
 
                             if success:
@@ -812,11 +927,12 @@ async def websocket_endpoint_with_jwt(
                                 await websocket.send_json({
                                     "type": "realtime_stt_status",
                                     "status": "connected",
-                                    "message": "即時轉錄已啟動"
+                                    "message": "即時轉錄已啟動",
+                                    "language": language,
                                 })
                                 logger.info(f"✅ 用戶 {user_id} 即時轉錄已啟動")
                             else:
-                                raise Exception("無法連接到 OpenAI Realtime API")
+                                raise Exception("無法連接到 Google Speech-to-Text")
 
                         except Exception as e:
                             logger.error(f"❌ 啟動即時轉錄失敗: {e}")
@@ -845,16 +961,22 @@ async def websocket_endpoint_with_jwt(
                         realtime_stt = client_info.get("realtime_stt")
 
                         if realtime_stt and b64:
-                            # === 即時轉錄模式：轉發到 OpenAI Realtime API ===
+                        # === 即時轉錄模式：轉發到 Google Speech-to-Text 緩衝 ===
                             try:
                                 import base64
                                 audio_bytes = base64.b64decode(b64)
                                 await realtime_stt.send_audio_chunk(audio_bytes)
-                                logger.debug(f"🎤 轉發音頻到 OpenAI: {len(audio_bytes)} bytes")
+                                logger.debug(f"🎤 轉發音頻到 Google STT: {len(audio_bytes)} bytes")
                                 
                                 # 同時儲存到本地緩衝（用於音頻情緒辨識）
+                                # 🎯 效能與記憶體優化：實施滑動窗口（Sliding Window），僅保留最近 15 秒音頻
+                                # 16000Hz * 2bytes/sample * 15s = 480,000 bytes
+                                MAX_BUFFER_SIZE = 480000 
                                 audio_buffer = client_info.get("audio_buffer", b"")
                                 audio_buffer += audio_bytes
+                                if len(audio_buffer) > MAX_BUFFER_SIZE:
+                                    audio_buffer = audio_buffer[-MAX_BUFFER_SIZE:]
+                                    
                                 client_info["audio_buffer"] = audio_buffer
                                 manager.set_client_info(user_id, client_info)
                                 
@@ -1000,7 +1122,10 @@ async def websocket_endpoint_with_jwt(
                                     td = app.state.feature_router.get_current_time_data()
                                     name = user.get("name") or "用戶"
                                     emo = result.get("emotion") or {}
-                                    emo_label = str(emo.get("label") or "")
+                                    emo_label = str(emo.get("label") or "neutral")
+                                    # 🎯 使用原始標籤（包含中文）來生成歡迎詞，確保「心情低落」等詞彙能正確匹配
+                                    raw_emo_label = str(emo.get("raw_label") or emo_label)
+                                    
                                     tz_hint = None
                                     try:
                                         env_res = await get_user_env_current(user_id)
@@ -1011,7 +1136,7 @@ async def websocket_endpoint_with_jwt(
                                     welcome = compose_welcome(
                                         user_name=name,
                                         time_data=td,
-                                        emotion_label=emo_label,
+                                        emotion_label=raw_emo_label,
                                         timezone=tz_hint,
                                     )
                                 except Exception:
@@ -1030,6 +1155,13 @@ async def websocket_endpoint_with_jwt(
                                     logger.error(f"生成 JWT token 失敗: {e}")
                                     access_token = None
 
+                                await websocket.send_json({
+                                    "type": "emotion_detected",
+                                    "emotion": emo_label,
+                                    "care_mode": False,
+                                    "source": "voice_login"
+                                })
+
                                 await websocket.send_json({
                                     "type": "voice_login_result",
                                     "success": True,
@@ -1067,7 +1199,7 @@ async def websocket_endpoint_with_jwt(
                             })
 
                     elif mode == "realtime_chat":
-                        # === 即時轉���模式：關閉 OpenAI Realtime 連線並處理轉錄結果 ===
+                        # === 即時轉錄模式：提交 Google STT 並處理轉錄結果 ===
                         try:
                             client_info = manager.get_client_info(user_id) or {}
                             realtime_stt = client_info.get("realtime_stt")
@@ -1075,6 +1207,24 @@ async def websocket_endpoint_with_jwt(
                             audio_buffer = client_info.get("audio_buffer", b"")
 
                             if realtime_stt:
+                                await websocket.send_json({
+                                    "type": "stt_status",
+                                    "status": "transcribing",
+                                    "timestamp": time.time()
+                                })
+                                logger.info(f"📝 等待即時轉錄 final，用戶 {user_id}")
+                                final_transcript = await realtime_stt.wait_for_final_transcript(timeout=3.5)
+                                if final_transcript and final_transcript != client_info.get("realtime_transcript"):
+                                    transcription = final_transcript
+                                    client_info["realtime_transcript"] = final_transcript
+                                    await websocket.send_json({
+                                        "type": "stt_final",
+                                        "text": final_transcript,
+                                        "timestamp": time.time()
+                                    })
+                                elif final_transcript:
+                                    transcription = final_transcript
+
                                 logger.info(f"🔌 關閉即時轉錄連線，用戶 {user_id}")
                                 await realtime_stt.disconnect()
 
@@ -1099,150 +1249,128 @@ async def websocket_endpoint_with_jwt(
                                 # 立即通知前端開始思考，提升即時響應感
                                 await websocket.send_json({"type": "typing", "message": "thinking"})
 
-                                # === 方案 B：語音情緒辨識（情緒分佈驗證 + 智能回退）===
-                                audio_emotion = None
-                                if audio_buffer and len(audio_buffer) >= 16000 * 2:  # 至少 1 秒
-                                    try:
-                                        logger.info(f"🎭 開始語音情緒辨識，音訊長度: {len(audio_buffer)} bytes")
-                                        emotion_result = await predict_emotion_from_audio(audio_buffer, sample_rate=16000)
-                                        
-                                        if emotion_result.get("success"):
-                                            emotion_label = emotion_result.get("emotion", "neutral")
-                                            confidence = emotion_result.get("confidence", 0.0)
-                                            all_emotions = emotion_result.get("all_emotions", {})
-                                            
-                                            # 計算 top-1 與 top-2 的 margin
-                                            sorted_emotions = sorted(all_emotions.items(), key=lambda x: x[1], reverse=True)
-                                            margin = sorted_emotions[0][1] - sorted_emotions[1][1] if len(sorted_emotions) >= 2 else confidence
-                                            
-                                            # 方案 B 判斷邏輯
-                                            use_audio_emotion = False
-                                            reason = ""
-                                            
-                                            if emotion_label == "neutral":
-                                                # neutral 需要更高置信度，但 margin 可較寬鬆
-                                                if confidence >= 0.55 and margin >= 0.12:
-                                                    use_audio_emotion = True
-                                                    reason = f"neutral 高信心 (conf={confidence:.3f}, margin={margin:.3f})"
-                                                else:
-                                                    reason = f"neutral 信心不足 (conf={confidence:.3f}, margin={margin:.3f}) → 回退文字"
-                                            else:
-                                                # 非 neutral 需要足夠 confidence 與 margin
-                                                if confidence >= 0.48 and margin >= 0.18:
-                                                    use_audio_emotion = True
-                                                    reason = f"{emotion_label} 高信心 (conf={confidence:.3f}, margin={margin:.3f})"
-                                                else:
-                                                    reason = f"{emotion_label} 信心不足 (conf={confidence:.3f}, margin={margin:.3f}) → 回退文字"
-                                            
-                                            if use_audio_emotion:
-                                                audio_emotion = emotion_result
-                                                logger.info(f"✅ 使用語音情緒: {emotion_label}, {reason}")
-                                            else:
-                                                audio_emotion = None
-                                                logger.info(f"📝 {reason}")
-                                        else:
-                                            logger.warning(f"⚠️ 語音情緒辨識失敗: {emotion_result.get('error')}")
-                                    except Exception as e:
-                                        logger.error(f"❌ 語音情緒辨識異常: {e}")
-                                        audio_emotion = None
-                                
-                                # 清理音頻緩衝
-                                if audio_buffer:
-                                    client_info.pop("audio_buffer", None)
-                                    manager.set_client_info(user_id, client_info)
-
-                                # 異步處理對話邏輯
-                                async def _process_realtime_chat():
+                                # === 優化：並行處理語音情緒辨識與 Agent 邏輯 ===
+                                async def _get_audio_emotion():
+                                    if audio_buffer and len(audio_buffer) >= 16000 * 1.5:  # 至少 1.5 秒
+                                        try:
+                                            logger.info(f"🎭 [Parallel] 開始語音情緒辨識，長度: {len(audio_buffer)} bytes")
+                                            res = await predict_emotion_from_audio(audio_buffer, sample_rate=16000)
+                                            if res.get("success"):
+                                                # 簡單過濾低信心度
+                                                if res.get("confidence", 0) > 0.4:
+                                                    res["source"] = "realtime_voice"
+                                                    return res
+                                        except Exception as e:
+                                            logger.error(f"❌ 語音情緒辨識異常: {e}")
+                                    return {"success": False, "source": "realtime_voice"}
+
+                                # 定義一個內部函數來處理整個流程，稍後將其作為 Task 執行
+                                async def _process_full_request():
+                                    # 啟動並行任務
+                                    emotion_task = asyncio.create_task(_get_audio_emotion())
+                                    
+                                    # 同步準備對話 ID 等基礎工作 (這些很快，不需額外 Task)
                                     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"]
+                                                chat_id = user_chats_result["chats"][0]["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"]
+                                                chat_title = f"語音對話 {datetime.now().strftime('%Y-%m-%d %H:%M')}"
+                                                chat_res = await create_chat(user_id, chat_title)
+                                                if chat_res["success"]:
+                                                    chat_id = chat_res["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)
-
-                                    # 取得語言設定
+                                            logger.error(f"準備對話時出錯: {e}")
+                                    
+                                    # 保存用戶訊息（異步）
+                                    if chat_id:
+                                        asyncio.create_task(save_message_to_db(user_id, chat_id, "user", transcription))
+
+                                    # 等待情緒分析結果（如果還沒出的話，這邊會稍微等一下，但通常會與 GPT 意圖偵測並行）
+                                    # 為了讓意圖偵測儘早開始，我們甚至可以在 handle_message 內部去 await emotion_task
+                                    # 但這裡我們採取簡單策略：先啟動 handle_message，並傳入 task 或稍後合併
+                                    
+                                    # 實際上，handle_message 內部會做 GPT 意圖偵測，這耗時最久。
+                                    # 我們讓 handle_message 帶入 emotion_task
+                                    
                                     language = client_info.get("language", "auto")
+                                    
+                                    async def _on_emotion_detected(em: str, cm: bool, payload: Optional[Dict[str, Any]] = None):
+                                        # ... (原有回調邏輯)
+                                        if em.startswith("__bot_"): # 狀態回調
+                                            await websocket.send_json({"type": em.replace("__", ""), **(payload or {})})
+                                            return
+                                        await websocket.send_json({"type": "emotion_detected", "emotion": em, "care_mode": cm})
 
-                                    # 發送即時情緒的回調函數
-                                    async def _on_emotion_detected(em: str, cm: bool):
-                                        logger.info(f"📤 [即時回調] 發送 emotion_detected: {em}, care_mode={cm}")
-                                        await websocket.send_json({
-                                            "type": "emotion_detected",
-                                            "emotion": em,
-                                            "care_mode": cm
-                                        })
+                                    # 等待情緒完成，或者設定超時
+                                    try:
+                                        audio_emotion_res = await asyncio.wait_for(emotion_task, timeout=2.0)
+                                    except asyncio.TimeoutError:
+                                        logger.warning("⚠️ 語音情緒辨識超時，回退至文字分析")
+                                        audio_emotion_res = {"success": False}
 
-                                    # 處理對話（透過 handle_message，自動處理 pipeline）
+                                    # 執行 Agent 邏輯
                                     response = await handle_message(
                                         transcription,
                                         user_id,
                                         chat_id,
-                                        [],  # messages 參數（會自動從數據庫載入）
-                                        audio_emotion=audio_emotion,  # 傳遞音頻情緒
-                                        language=language,  # 傳遞語言設定（新增）
+                                        [],
+                                        audio_emotion=audio_emotion_res,
+                                        language=language,
                                         emotion_callback=_on_emotion_detected
                                     )
 
-                                    # 發送回應
-                                    # 從 PipelineResult 提取情緒
-                                    emotion = None
-                                    care_mode = False
+                                    # 發送結果
                                     if isinstance(response, PipelineResult):
-                                        message_text = response.text
-                                        if response.meta:
-                                            emotion = response.meta.get('emotion')
-                                            care_mode = response.meta.get('care_mode', False)
-
                                         await websocket.send_json({
                                             "type": "bot_message",
-                                            "message": message_text,
+                                            "message": response.text,
                                             "timestamp": time.time(),
-                                            "tool_name": None,
-                                            "tool_data": None,
-                                            "emotion": emotion,
-                                            "care_mode": care_mode
+                                            "emotion": response.meta.get("emotion") if response.meta else "neutral",
+                                            "care_mode": response.meta.get("care_mode", False) if response.meta else False,
+                                            "language": language,
                                         })
+                                        # 保存 AI 訊息
+                                        if chat_id:
+                                            asyncio.create_task(save_message_to_db(user_id, chat_id, "assistant", response.text))
                                     elif isinstance(response, dict):
-                                        tool_name = response.get('tool_name')
-                                        tool_data = response.get('tool_data')
-                                        emotion = response.get('emotion')
-                                        message_text = response.get('message', response.get('content', ''))
-
                                         await websocket.send_json({
                                             "type": "bot_message",
-                                            "message": message_text,
+                                            "message": response.get("message", response.get("content", "")),
                                             "timestamp": time.time(),
-                                            "tool_name": tool_name,
-                                            "tool_data": tool_data,
-                                            "emotion": emotion
+                                            "tool_name": response.get("tool_name"),
+                                            "tool_data": response.get("tool_data"),
+                                            "emotion": response.get("emotion", "neutral"),
+                                            "care_mode": response.get("care_mode", False),
+                                            "language": response.get("language", language),
                                         })
+                                        if chat_id:
+                                            asyncio.create_task(save_message_to_db(user_id, chat_id, "assistant", str(response.get("message", ""))))
                                     else:
                                         # 字串回應
                                         await websocket.send_json({
                                             "type": "bot_message",
                                             "message": str(response),
-                                            "timestamp": time.time(),
-                                            "emotion": None
+                                            "timestamp": time.time()
                                         })
+                                        if chat_id:
+                                            asyncio.create_task(save_message_to_db(user_id, chat_id, "assistant", str(response)))
+
+                                # 啟動整體處理任務
+                                # 🎯 註冊任務，以便支援 Barge-in 中斷
+                                task = asyncio.create_task(_process_full_request())
+                                manager.register_task(user_id, task)
+
+                                # 清理緩衝區並直接返回循環，讓連線保持暢通
+                                if audio_buffer:
+                                    client_info.pop("audio_buffer", None)
+                                    manager.set_client_info(user_id, client_info)
 
-                                await _process_realtime_chat()
                             else:
                                 logger.debug(f"沒有轉錄文字，返回待機狀態")
+                                await websocket.send_json({"type": "stt_status", "status": "idle"})
 
                         except Exception as e:
                             logger.error(f"❌ 關閉即時轉錄失敗: {e}")
@@ -1270,20 +1398,26 @@ async def websocket_endpoint_with_jwt(
 # 消息處理與AI
 # -----------------------------
 async def handle_message(user_message, user_id, chat_id, messages, request_id: str = None, audio_emotion: dict = None, language: str = None, emotion_callback=None):
+    user_message = (user_message or "").strip()
     logger.info(f"📥 handle_message: 收到訊息='{user_message}', user_id={user_id}, audio_emotion={audio_emotion}, language={language}")
+    resolved_language = _resolve_conversation_language(user_message, language)
     
+    if not user_message:
+        logger.info(f"🚫 攔截到空請求，中斷交由 Agent 處理。")
+        return "不好意思，我剛剛沒有聽清楚或是沒收到內容，可以請您再說一次嗎？"
+
     # 指令優先，避免進入管線造成不必要延遲
-    if user_message and user_message.startswith("/"):
+    if user_message.startswith("/"):
         cmd = await handle_command(user_message, user_id)
         if cmd:
             return cmd
 
     feature_router:MCPAgentBridge  = app.state.feature_router
 
-    async def _detect(msg: str):
+    async def _detect(msg: str, tool_context: str = "", language: str = None, **kwargs):
         logger.info(f"🎯 Pipeline: 開始意圖偵測，訊息='{msg}'")
         try:
-            result = await feature_router.detect_intent(msg)
+            result = await feature_router.detect_intent(msg, tool_context=tool_context, language=language or resolved_language)
             logger.info(f"🎯 Pipeline: 意圖偵測結果={result}")
             return result
         except Exception as e:
@@ -1301,7 +1435,59 @@ async def handle_message(user_message, user_id, chat_id, messages, request_id: s
         logger.info(f"🔧 Pipeline: 功能處理結果='{result}'")
         return result
 
-    async def _ai(messages_in, cid, model, rid, chat_id, use_care_mode=False, care_emotion=None, emotion_label=None, language=None):
+    stream_message_id = request_id or f"stream_{int(time.time() * 1000)}"
+    stream_accumulator = {"text": ""}
+
+    async def _emit_bot_status(status: str, message: str, phase: Optional[str] = None):
+        if emotion_callback is None:
+            return
+        try:
+            await emotion_callback(
+                "__bot_status__",
+                False,
+                {
+                    "status": status,
+                    "message": message,
+                    "phase": phase or status,
+                    "temporary": True,
+                },
+            )
+        except TypeError:
+            return
+
+    async def _on_ai_chunk(delta: Any):
+        if not delta or emotion_callback is None:
+            return
+        if isinstance(delta, dict):
+            delta.setdefault("temporary", True)
+            delta.setdefault("phase", delta.get("status", "processing"))
+            try:
+                await emotion_callback("__bot_status__", False, delta)
+            except TypeError:
+                return
+            return
+
+        stream_accumulator["text"] += str(delta)
+        try:
+            await emotion_callback(
+                "__bot_delta__",
+                False,
+                {
+                    "message_id": stream_message_id,
+                    "delta": str(delta),
+                    "text": stream_accumulator["text"],
+                    "language": _preferred_language_from_text(stream_accumulator["text"]) or resolved_language,
+                    "phase": "answering",
+                    "temporary": True,
+                },
+            )
+        except TypeError:
+            return
+
+    async def _ai(messages_in, cid, model, rid, chat_id, use_care_mode=False, care_emotion=None, emotion_label=None, language=None, tool_context: str = "", is_first_care: bool = False):
+        # 【效能優化】立即通知前端進入 AI 生成階段，這會刷新思考超時
+        await _emit_bot_status("generating", "正在組織語言回答您...", "thinking")
+        
         env_context = {}
         env_service = getattr(app.state, 'env_service', None)
         if env_service:
@@ -1320,37 +1506,49 @@ async def handle_message(user_message, user_id, chat_id, messages, request_id: s
             logger.debug(f"無法取得用戶名稱，使用預設值: {e}")
 
         # 使用傳入的 language 參數（優先）或閉包捕獲的外部變數
-        lang = language if language is not None else globals().get('language', 'zh')
+        lang = language if language is not None else resolved_language
 
         # 兼容：如果傳入字串，視為 user_message；如果傳入 list，視為 messages
-        if isinstance(messages_in, str):
-            return await ai_service.generate_response_for_user(
-                user_message=messages_in,
-                user_id=cid,
-                model=model,
-                request_id=rid,
-                chat_id=chat_id,
-                use_care_mode=use_care_mode,
-                care_emotion=care_emotion,
-                user_name=user_name,
-                emotion_label=emotion_label,
-                env_context=env_context,
-                language=lang,
-            )
-        else:
-            return await ai_service.generate_response_for_user(
-                messages=messages_in,
-                user_id=cid,
-                model=model,
-                request_id=rid,
-                chat_id=chat_id,
-                use_care_mode=use_care_mode,
-                care_emotion=care_emotion,
-                user_name=user_name,
-                emotion_label=emotion_label,
-                env_context=env_context,
-                language=lang,
-            )
+        try:
+            if isinstance(messages_in, str):
+                return await ai_service.generate_response_for_user(
+                    user_message=messages_in,
+                    user_id=cid,
+                    model=model,
+                    request_id=rid,
+                    chat_id=chat_id,
+                    use_care_mode=use_care_mode,
+                    care_emotion=care_emotion,
+                    user_name=user_name,
+                    emotion_label=emotion_label,
+                    env_context=env_context,
+                    language=lang,
+                    stream=bool(emotion_callback),
+                    on_chunk=_on_ai_chunk if emotion_callback else None,
+                    tool_context=tool_context,
+                    is_first_care=is_first_care,
+                )
+            else:
+                return await ai_service.generate_response_for_user(
+                    messages=messages_in,
+                    user_id=cid,
+                    model=model,
+                    request_id=rid,
+                    chat_id=chat_id,
+                    use_care_mode=use_care_mode,
+                    care_emotion=care_emotion,
+                    user_name=user_name,
+                    emotion_label=emotion_label,
+                    env_context=env_context,
+                    language=lang,
+                    stream=bool(emotion_callback),
+                    on_chunk=_on_ai_chunk if emotion_callback else None,
+                    tool_context=tool_context,
+                    is_first_care=is_first_care,
+                )
+        except Exception as e:
+            logger.error(f"AI 生成過程出錯: {e}")
+            raise
 
     model = settings.OPENAI_MODEL
     # 簡化 Pipeline：移除未使用的記憶管理和摘要決策
@@ -1360,12 +1558,13 @@ async def handle_message(user_message, user_id, chat_id, messages, request_id: s
         _process_feature,
         _ai,
         model=model,
-        detect_timeout=10.0,  # 意圖檢測超時 (15 → 10)
+        detect_timeout=25.0,  # 意圖檢測超時：保留 Agent 自主工具判斷空間
         feature_timeout=30.0,  # 功能處理超時 (15 → 30，新聞摘要生成需要更長時間)
-        ai_timeout=20.0,  # AI回應超時 (30 → 20)
+        ai_timeout=60.0,  # AI回應超時：hosted WebSearch/工具階段可能先無文字 delta
     )
-    logger.info(f"⚙️ 準備調用 ChatPipeline.process，user_message='{user_message}', audio_emotion={audio_emotion}, language={language}")
-    res: PipelineResult = await pipeline.process(user_message, user_id=user_id, chat_id=chat_id, request_id=request_id, audio_emotion=audio_emotion, language=language, emotion_callback=emotion_callback)
+    logger.info(f"⚙️ 準備調用 ChatPipeline.process，user_message='{user_message}', audio_emotion={audio_emotion}, language={resolved_language}")
+    await _emit_bot_status("planning", "已收到，正在規劃處理方式...", "planning")
+    res: PipelineResult = await pipeline.process(user_message, user_id=user_id, chat_id=chat_id, request_id=request_id, audio_emotion=audio_emotion, language=resolved_language, emotion_callback=emotion_callback)
     logger.info(f"⚙️ ChatPipeline.process 完成，結果='{res.text}', is_fallback={res.is_fallback}, reason={res.reason}")
     
     # 檢查是否有工具元數據
@@ -1408,6 +1607,7 @@ async def handle_message(user_message, user_id, chat_id, messages, request_id: s
     # 提取情緒與關懷模式資訊（新增）
     emotion = res.meta.get('emotion') if res.meta else None
     care_mode = res.meta.get('care_mode', False) if res.meta else False
+    final_language = _preferred_language_from_text(res.text) or _normalize_bcp47_language_tag(language) or "zh-TW"
     
     logger.info(f"🎭 handle_message 情緒: emotion={emotion}, care_mode={care_mode}, meta={res.meta}")
 
@@ -1420,7 +1620,8 @@ async def handle_message(user_message, user_id, chat_id, messages, request_id: s
         'tool_name': tool_name,
         'tool_data': tool_data,
         'emotion': final_emotion,
-        'care_mode': care_mode
+        'care_mode': care_mode,
+        'language': final_language,
     }
 
 
@@ -1800,6 +2001,7 @@ async def voice_login(request: VoiceLoginRequest):
         
         if not result.get("success"):
             error_code = result.get("error", "UNKNOWN_ERROR")
+            quality_warnings = result.get("quality_warnings") or []
             error_messages = {
                 "NO_AUDIO": "沒有收到音訊資料",
                 "AUDIO_TOO_SHORT": "音訊太短，請錄製至少 3 秒",
@@ -1808,11 +2010,15 @@ async def voice_login(request: VoiceLoginRequest):
                 "THRESHOLD_NOT_MET": "無法確認身份，請重試",
                 "MODEL_ERROR": "辨識系統錯誤，請稍後重試",
             }
-            logger.warning(f"🎙️ 語音辨識失敗: {error_code}")
+            logger.warning(f"🎙️ 語音辨識失敗: {error_code} quality_warnings={quality_warnings}")
             return JSONResponse(content={
                 "success": False,
                 "error": error_messages.get(error_code, f"辨識失敗：{error_code}")
             })
+
+        quality_warnings = result.get("quality_warnings") or []
+        if quality_warnings:
+            logger.warning(f"🎙️ 語音登入品質警告（未阻擋）: {quality_warnings}")
         
         # 取得辨識結果
         speaker_label = result.get("label")
@@ -2146,13 +2352,13 @@ async def analyze_image_with_gpt_vision(filename: str, image_base64: str, mime_t
             }
         ]
         try:
-            response = ai_service.client.chat.completions.create(
-                model="gpt-5-nano",
+            analysis = await ai_service.generate_response_for_user(
                 messages=messages,
-                max_completion_tokens=1500,
-                reasoning_effort="medium"  # 圖片分析需要較深入理解，使用 medium
+                user_id="image_analysis",
+                chat_id=None,
+                max_tokens=1500,
+                reasoning_effort="medium",
             )
-            analysis = response.choices[0].message.content
             return analysis
         except Exception as e:
             logger.error(f"GPT Vision分析錯誤: {str(e)}")
@@ -2401,6 +2607,12 @@ class TTSRequest(BaseModel):
     text: str
     voice: Optional[str] = "nova"
     speed: Optional[float] = 1.0
+    language: Optional[str] = None
+    persona: Optional[str] = "xiaohua"
+    mode: Optional[str] = "standard"
+    speaking_rate: Optional[float] = None
+    markup: Optional[str] = None
+    custom_pronunciations: Optional[list[dict]] = None
 
 
 @app.post("/api/tts")
@@ -2430,7 +2642,10 @@ async def synthesize_speech(
                 content={"success": False, "error": "文字長度必須在 1-4096 字元之間"}
             )
 
-        valid_voices = ["alloy", "echo", "fable", "onyx", "nova", "shimmer"]
+        valid_voices = [
+            "alloy", "echo", "fable", "onyx", "nova", "shimmer", "coral",
+            "zh-tw", "zh-cn", "en-us", "ja-jp", "ko-kr", "id-id", "vi-vn"
+        ]
         if request.voice not in valid_voices:
             return JSONResponse(
                 status_code=400,
@@ -2443,10 +2658,21 @@ async def synthesize_speech(
                 content={"success": False, "error": "語速必須在 0.25 到 4.0 之間"}
             )
 
-        logger.info(f"🔊 TTS 請求: text={request.text[:50]}..., voice={request.voice}, speed={request.speed}")
+        logger.info(
+            f"🔊 TTS 請求: text={request.text[:50]}..., voice={request.voice}, speed={request.speed}, "
+            f"language={request.language}, persona={request.persona}, speaking_rate={request.speaking_rate}, "
+            f"has_markup={bool(request.markup)}, custom_pronunciations={len(request.custom_pronunciations or [])}"
+        )
 
         # 調用 TTS 服務獲取完整音頻
-        result = await text_to_speech(request.text, request.voice, request.speed)
+        result = await text_to_speech(
+            request.text,
+            request.voice,
+            request.speed,
+            language=request.language,
+            persona=request.persona,
+            speaking_rate=request.speaking_rate,
+        )
 
         if not result.get("success"):
             return JSONResponse(
@@ -2474,6 +2700,93 @@ async def synthesize_speech(
         )
 
 
+@app.websocket("/ws/tts")
+async def tts_stream_websocket(websocket: WebSocket):
+    await websocket.accept()
+    stream_started_at = time.perf_counter()
+    total_chunks = 0
+    total_bytes = 0
+    first_chunk_at = None
+    try:
+        payload = await websocket.receive_json()
+        text = str(payload.get("text") or "").strip()
+        voice = str(payload.get("voice") or "nova")
+        speed = float(payload.get("speed") or 1.0)
+        language = payload.get("language")
+        persona = payload.get("persona") or "xiaohua"
+        speaking_rate = payload.get("speaking_rate")
+        markup = payload.get("markup")
+        custom_pronunciations = payload.get("custom_pronunciations")
+        emotion = payload.get("emotion")
+        care_mode = bool(payload.get("care_mode", False))
+
+        if not text and not markup:
+            await websocket.send_json({"type": "tts_error", "error": "文字不可為空"})
+            await websocket.close()
+            return
+
+        from services.tts_service import tts_service
+
+        await websocket.send_json({
+            "type": "tts_stream_start",
+            "sample_rate": 24000,
+            "encoding": "LINEAR16",
+            "persona": persona,
+            "language": language,
+        })
+
+        async for chunk in tts_service.streaming_synthesize(
+            text=text,
+            voice=voice,
+            speed=speed,
+            language=language,
+            persona=persona,
+            speaking_rate=speaking_rate,
+            markup=markup,
+            custom_pronunciations=custom_pronunciations,
+            emotion=emotion,
+            care_mode=care_mode,
+        ):
+            total_chunks += 1
+            total_bytes += len(chunk)
+            if first_chunk_at is None:
+                first_chunk_at = time.perf_counter()
+            await websocket.send_json({
+                "type": "tts_audio_chunk",
+                "audio_base64": base64.b64encode(chunk).decode("ascii"),
+            })
+
+        logger.debug(
+            "📡 TTS 串流傳送完成: chunks=%d bytes=%d first_chunk_delay=%s total_elapsed=%.2fs",
+            total_chunks,
+            total_bytes,
+            f"{(first_chunk_at - stream_started_at):.2f}s" if first_chunk_at is not None else "none",
+            time.perf_counter() - stream_started_at,
+        )
+        await websocket.send_json({"type": "tts_stream_end"})
+    except WebSocketDisconnect:
+        logger.debug(
+            "🔌 TTS 串流連線已由客戶端關閉: chunks=%d bytes=%d first_chunk_delay=%s total_elapsed=%.2fs",
+            total_chunks,
+            total_bytes,
+            f"{(first_chunk_at - stream_started_at):.2f}s" if first_chunk_at is not None else "none",
+            time.perf_counter() - stream_started_at,
+        )
+    except Exception as e:
+        error_detail = f"{type(e).__name__}: {str(e) or repr(e)}"
+        logger.error(f"❌ TTS 串流失敗: {error_detail}")
+        logger.exception("TTS 串流詳細錯誤堆疊:")
+        try:
+            await websocket.send_json({"type": "tts_error", "error": str(e)})
+        except Exception:
+            pass
+    finally:
+        try:
+            await websocket.close()
+        except Exception:
+            pass
+
+
 
 # -----------------------------
 # MCP Tools API

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

@@ -238,26 +238,66 @@ export function LoginForm() {
     setVoiceStatus('請求麥克風權限...');
     console.log('🎤 開始語音登入...');
 
+    let stream: MediaStream | null = null;
+    let audioContext: AudioContext | null = null;
+    let source: MediaStreamAudioSourceNode | null = null;
+    let processor: AudioWorkletNode | null = null;
+
+    const cleanupAudio = async () => {
+      if (processor) {
+        processor.port.onmessage = null;
+        processor.disconnect();
+        processor = null;
+      }
+
+      if (source) {
+        source.disconnect();
+        source = null;
+      }
+
+      if (stream) {
+        stream.getTracks().forEach(track => track.stop());
+        stream = null;
+      }
+
+      if (audioContext) {
+        await audioContext.close().catch(() => undefined);
+        audioContext = null;
+      }
+    };
+
     try {
       // 請求麥克風權限
-      const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      stream = await navigator.mediaDevices.getUserMedia({
+        audio: {
+          channelCount: 1,
+          sampleRate: 16000,
+          echoCancellation: false,
+          noiseSuppression: false,
+          autoGainControl: false,
+        },
+      });
       console.log('✅ 麥克風權限已獲取');
 
       // 設定錄音參數
-      const audioContext = new AudioContext({ sampleRate: 16000 });
-      const source = audioContext.createMediaStreamSource(stream);
-      const processor = audioContext.createScriptProcessor(4096, 1, 1);
+      audioContext = new AudioContext({ sampleRate: 16000 });
+      await audioContext.audioWorklet.addModule('/audio/pcm-recorder-worklet.js');
+      await audioContext.resume();
+      source = audioContext.createMediaStreamSource(stream);
+      processor = new AudioWorkletNode(audioContext, 'pcm-recorder-processor', {
+        numberOfInputs: 1,
+        numberOfOutputs: 0,
+        channelCount: 1,
+      });
       
-      const audioChunks: Float32Array[] = [];
+      const audioChunks: Int16Array[] = [];
       const recordDuration = 4000; // 4 秒（確保足夠長度）
       
-      processor.onaudioprocess = (e) => {
-        const inputData = e.inputBuffer.getChannelData(0);
-        audioChunks.push(new Float32Array(inputData));
+      processor.port.onmessage = (event) => {
+        audioChunks.push(new Int16Array(event.data));
       };
       
       source.connect(processor);
-      processor.connect(audioContext.destination);
       
       setVoiceStatus('🎙️ 錄音中... 請說話 (4秒)');
       console.log('🎙️ 開始錄音 4 秒...');
@@ -266,30 +306,20 @@ export function LoginForm() {
       await new Promise(resolve => setTimeout(resolve, recordDuration));
       
       // 停止錄音
-      processor.disconnect();
-      source.disconnect();
-      stream.getTracks().forEach(track => track.stop());
-      await audioContext.close();
+      await cleanupAudio();
       
       setVoiceStatus('辨識中...');
       console.log('✅ 錄音完成，處理音訊...');
       
       // 合併音訊資料
       const totalLength = audioChunks.reduce((acc, chunk) => acc + chunk.length, 0);
-      const audioData = new Float32Array(totalLength);
+      const pcm16 = new Int16Array(totalLength);
       let offset = 0;
       for (const chunk of audioChunks) {
-        audioData.set(chunk, offset);
+        pcm16.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 = '';
@@ -335,6 +365,7 @@ export function LoginForm() {
       }
       setIsLoading(false);
       setLoadingType(null);
+      await cleanupAudio();
     }
   }
 

bloom-ware-login/public/audio/pcm-recorder-worklet.js

@@ -0,0 +1,17 @@
+class PCMRecorderProcessor extends AudioWorkletProcessor {
+  process(inputs) {
+    const channelData = inputs[0]?.[0];
+    if (channelData && channelData.length) {
+      const pcm16 = new Int16Array(channelData.length);
+      for (let i = 0; i < channelData.length; i++) {
+        const sample = Math.max(-1, Math.min(1, channelData[i]));
+        pcm16[i] = sample < 0 ? sample * 0x8000 : sample * 0x7fff;
+      }
+      this.port.postMessage(pcm16.buffer, [pcm16.buffer]);
+    }
+
+    return true;
+  }
+}
+
+registerProcessor('pcm-recorder-processor', PCMRecorderProcessor);

core/ai_client.py

@@ -16,6 +16,17 @@ _openai_client = None
 _initialized = False
 
 
+def _normalize_openai_base_url(base_url: Optional[str]) -> Optional[str]:
+    """Normalize custom OpenAI-compatible base URLs for the Python SDK."""
+    if not base_url:
+        return None
+
+    normalized = base_url.rstrip("/")
+    if normalized.endswith("/v1"):
+        return normalized
+    return f"{normalized}/v1"
+
+
 def get_openai_client():
     """
     取得 OpenAI 客戶端（單例模式）
@@ -37,11 +48,16 @@ def get_openai_client():
             _initialized = True
             return None
 
-        _openai_client = OpenAI(
-            api_key=api_key,
-            timeout=float(settings.OPENAI_TIMEOUT),
-            max_retries=3,
-        )
+        client_kwargs = {
+            "api_key": api_key,
+            "timeout": float(settings.OPENAI_TIMEOUT),
+            "max_retries": 3,
+        }
+        normalized_base_url = _normalize_openai_base_url(settings.OPENAI_BASE_URL)
+        if normalized_base_url:
+            client_kwargs["base_url"] = normalized_base_url
+
+        _openai_client = OpenAI(**client_kwargs)
 
         _initialized = True
         logger.info("✅ OpenAI 客戶端初始化成功")

core/config.py

@@ -28,6 +28,11 @@ class Settings:
     _firebase_creds_base64: Optional[str] = os.getenv("FIREBASE_SERVICE_ACCOUNT_JSON_BASE64")
     _firebase_service_account_path: Optional[str] = os.getenv("FIREBASE_SERVICE_ACCOUNT_PATH")
 
+    # Google Cloud Speech / TTS 專用服務帳戶（可與 Firebase 不同 GCP 專案）
+    _google_speech_creds_json: Optional[str] = os.getenv("GOOGLE_SPEECH_CREDENTIALS_JSON")
+    _google_speech_creds_base64: Optional[str] = os.getenv("GOOGLE_SPEECH_SERVICE_ACCOUNT_JSON_BASE64")
+    _google_speech_sa_path: Optional[str] = os.getenv("GOOGLE_SPEECH_SERVICE_ACCOUNT_PATH")
+
     @classmethod
     def get_firebase_credentials(cls) -> Dict[str, Any]:
         """
@@ -80,22 +85,111 @@ class Settings:
                 "3. FIREBASE_SERVICE_ACCOUNT_PATH（檔案路徑）"
             )
 
+    @classmethod
+    def try_get_google_speech_credentials(cls) -> Optional[Dict[str, Any]]:
+        """
+        載入 STT/TTS 專用 Google 服務帳戶 JSON（與 Firebase 分離）。
+
+        若三種來源皆未設定，回傳 None；若已設定但格式錯誤則拋出 ValueError。
+        """
+        if cls._google_speech_creds_json:
+            try:
+                return json.loads(cls._google_speech_creds_json)
+            except json.JSONDecodeError as e:
+                raise ValueError(f"GOOGLE_SPEECH_CREDENTIALS_JSON 格式錯誤: {e}") from e
+        if cls._google_speech_creds_base64:
+            try:
+                decoded_bytes = base64.b64decode(cls._google_speech_creds_base64)
+                return json.loads(decoded_bytes.decode("utf-8"))
+            except Exception as e:
+                raise ValueError(f"GOOGLE_SPEECH_SERVICE_ACCOUNT_JSON_BASE64 解碼失敗: {e}") from e
+        if cls._google_speech_sa_path:
+            try:
+                with open(cls._google_speech_sa_path, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except FileNotFoundError:
+                raise ValueError(f"GOOGLE_SPEECH_SERVICE_ACCOUNT_PATH 檔案不存在: {cls._google_speech_sa_path}") from None
+            except json.JSONDecodeError as e:
+                raise ValueError(f"GOOGLE_SPEECH_SERVICE_ACCOUNT_PATH JSON 格式錯誤: {e}") from e
+        return None
+
+    @classmethod
+    def resolve_speech_service_account_info(cls) -> tuple[Optional[Dict[str, Any]], str]:
+        """
+        解析語音 API 使用的服務帳戶：優先 GOOGLE_SPEECH_*，否則退回 Firebase 憑證（相容舊部署）。
+
+        Returns:
+            (credentials_dict | None, "speech" | "firebase" | "none")
+        """
+        speech = cls.try_get_google_speech_credentials()
+        if speech is not None:
+            return speech, "speech"
+        try:
+            return cls.get_firebase_credentials(), "firebase"
+        except ValueError:
+            return None, "none"
+
+    @classmethod
+    def get_google_speech_project_id(cls, credential_project_id: Optional[str] = None) -> str:
+        """
+        Speech-to-Text recognizer 所屬 GCP 專案 ID。
+
+        優先順序：GOOGLE_SPEECH_PROJECT_ID → GOOGLE_CLOUD_PROJECT_ID（若為純數字「專案編號」
+        且憑證 JSON 內有字串型 project_id，則改用憑證內 ID，避免誤用編號）→
+        憑證 JSON 內 project_id → FIREBASE_PROJECT_ID
+        """
+        if cls.GOOGLE_SPEECH_PROJECT_ID.strip():
+            return cls.GOOGLE_SPEECH_PROJECT_ID.strip()
+        cloud = cls.GOOGLE_CLOUD_PROJECT_ID.strip()
+        cred = (credential_project_id or "").strip()
+        if cloud.isdigit() and cred and not cred.isdigit():
+            return cred
+        if cloud:
+            return cloud
+        if cred:
+            return cred
+        return cls.FIREBASE_PROJECT_ID.strip()
+
     # ===== OpenAI 配置 =====
     OPENAI_API_KEY: str = os.getenv("OPENAI_API_KEY", "")
-    OPENAI_MODEL: str = os.getenv("OPENAI_MODEL", "gpt-5-nano")
+    OPENAI_BASE_URL: str = os.getenv("OPENAI_BASE_URL", "")
+    OPENAI_MODEL: str = os.getenv("OPENAI_MODEL", "gpt-5.4")
     OPENAI_TIMEOUT: int = int(os.getenv("OPENAI_TIMEOUT", "30"))
-
-    # ===== Google OAuth 配置 =====
+    OPENAI_RESPONSES_TIMEOUT: int = int(os.getenv("OPENAI_RESPONSES_TIMEOUT", "90"))
+    OPENAI_USE_RESPONSES: bool = os.getenv("OPENAI_USE_RESPONSES", "true").lower() == "true"
+    OPENAI_MODEL_CONTEXT_WINDOW: int = int(os.getenv("OPENAI_MODEL_CONTEXT_WINDOW", "1000000"))
+    OPENAI_MODEL_AUTO_COMPACT_TOKEN_LIMIT: int = int(os.getenv("OPENAI_MODEL_AUTO_COMPACT_TOKEN_LIMIT", "900000"))
+    OPENAI_ENABLE_WEB_SEARCH: bool = os.getenv("OPENAI_ENABLE_WEB_SEARCH", "true").lower() == "true"
+    OPENAI_ENABLE_REMOTE_MCP: bool = os.getenv("OPENAI_ENABLE_REMOTE_MCP", "false").lower() == "true"
+    OPENAI_REMOTE_MCP_SERVERS_JSON: str = os.getenv("OPENAI_REMOTE_MCP_SERVERS_JSON", "[]")
+    OPENAI_ENABLE_SKILLS: bool = os.getenv("OPENAI_ENABLE_SKILLS", "false").lower() == "true"
+
+    # ===== Google OAuth（使用者「登入 Bloom Ware」用，非語音 API）=====
     GOOGLE_CLIENT_ID: str = os.getenv("GOOGLE_CLIENT_ID", "")
     GOOGLE_CLIENT_SECRET: str = os.getenv("GOOGLE_CLIENT_SECRET", "")
     GOOGLE_REDIRECT_URI: str = os.getenv(
         "GOOGLE_REDIRECT_URI",
         "http://localhost:8080/auth/google/callback"  # 開發環境預設值
     )
+    # ----- Google Cloud「語音」專案（STT/TTS，例：supervisor-project；常與 Firebase 不同）-----
+    # GOOGLE_CLOUD_PROJECT_ID：語音相關 REST/專案語境之預設專案 ID（請填「專案 ID」字串，勿只填控制台「專案編號」）
+    GOOGLE_CLOUD_PROJECT_ID: str = os.getenv("GOOGLE_CLOUD_PROJECT_ID", os.getenv("FIREBASE_PROJECT_ID", ""))
+    # GOOGLE_SPEECH_PROJECT_ID：明確指定 STT recognizer 所屬專案；與 Firebase 分離時必須搭配 GOOGLE_SPEECH_* 服務帳戶
+    GOOGLE_SPEECH_PROJECT_ID: str = os.getenv("GOOGLE_SPEECH_PROJECT_ID", "")
+    # STT gRPC 臨時除錯用；正式環境請用服務帳戶
+    GOOGLE_STT_ACCESS_TOKEN: str = os.getenv("GOOGLE_STT_ACCESS_TOKEN", "")
+    # TTS 與部分 REST 用 API Key（屬於語音 GCP；與 STT 串流 gRPC OAuth 分開）
+    GOOGLE_SPEECH_API_KEY: str = os.getenv("GOOGLE_SPEECH_API_KEY", os.getenv("GOOGLE_API_KEY", ""))
+    GOOGLE_TTS_API_KEY: str = os.getenv("GOOGLE_TTS_API_KEY", os.getenv("GOOGLE_API_KEY", ""))
+    GOOGLE_STT_LOCATION: str = os.getenv("GOOGLE_STT_LOCATION", "global")
+    GOOGLE_STT_RECOGNIZER_ID: str = os.getenv("GOOGLE_STT_RECOGNIZER_ID", "_")
+    GOOGLE_STT_AUTO_LANGUAGE_CODES: str = os.getenv("GOOGLE_STT_AUTO_LANGUAGE_CODES", "cmn-Hant-TW,en-US,ja-JP")
+    GOOGLE_TTS_LANGUAGE_CODE: str = os.getenv("GOOGLE_TTS_LANGUAGE_CODE", "cmn-TW")
+    GOOGLE_TTS_DEFAULT_VOICE: str = os.getenv("GOOGLE_TTS_DEFAULT_VOICE", "cmn-TW-Wavenet-A")
 
     # ===== 第三方 API Keys =====
     WEATHER_API_KEY: str = os.getenv("WEATHER_API_KEY", "")
-    NEWSDATA_API_KEY: str = os.getenv("NEWSDATA_API_KEY", "")
+    TAVILY_API_KEY: str = os.getenv("TAVILY_API_KEY", "")
     EXCHANGE_API_KEY: str = os.getenv("EXCHANGE_API_KEY", "")
 
     # ===== JWT 認證配置 =====
@@ -108,7 +202,7 @@ class Settings:
 
     # ===== GPT 意圖檢測配置 =====
     USE_GPT_INTENT: bool = os.getenv("USE_GPT_INTENT", "true").lower() == "true"
-    GPT_INTENT_MODEL: str = os.getenv("GPT_INTENT_MODEL", "gpt-5-nano")
+    GPT_INTENT_MODEL: str = os.getenv("GPT_INTENT_MODEL", "gpt-5.4")
 
     # ===== 背景任務開關 =====
     ENABLE_BACKGROUND_JOBS: bool = os.getenv("ENABLE_BACKGROUND_JOBS", "true").lower() == "true"
@@ -190,8 +284,8 @@ class Settings:
             logger.error("請檢查 FIREBASE_CREDENTIALS_JSON 或 FIREBASE_SERVICE_ACCOUNT_PATH")
             return False
 
-        # 驗證 OpenAI API Key 格式（基本檢查）
-        if not cls.OPENAI_API_KEY.startswith("sk-"):
+        # 驗證 OpenAI API Key 格式（OpenAI-compatible relay keys may not use sk-*）
+        if not cls.OPENAI_BASE_URL and not cls.OPENAI_API_KEY.startswith("sk-"):
             import logging
             logger = logging.getLogger("core.config")
             logger.warning("⚠️ OpenAI API Key 格式可能不正確（應以 'sk-' 開頭）")
@@ -236,7 +330,10 @@ class Settings:
             firebase_source = "未設定 ❌"
         logger.info(f"Firebase 憑證來源: {firebase_source}")
         logger.info(f"OpenAI 模型: {cls.OPENAI_MODEL}")
+        logger.info(f"OpenAI Base URL: {cls.OPENAI_BASE_URL or 'default'}")
+        logger.info(f"OpenAI Responses API: {'enabled' if cls.OPENAI_USE_RESPONSES else 'disabled'}")
         logger.info(f"OpenAI Timeout: {cls.OPENAI_TIMEOUT}s")
+        logger.info(f"OpenAI Responses Timeout: {cls.OPENAI_RESPONSES_TIMEOUT}s")
         logger.info(f"Google OAuth 回調 URI: {cls.GOOGLE_REDIRECT_URI}")
         logger.info(f"JWT Token 有效期: {cls.ACCESS_TOKEN_EXPIRE_MINUTES} 分鐘")
         logger.info(f"伺服器監聽: {cls.HOST}:{cls.PORT}")

core/environment/__init__.py

@@ -1,3 +1,9 @@
+from .context_builder import EnvironmentContextBuilder, EnvironmentInjection
 from .context_service import EnvironmentContextService, EnvironmentSnapshot
 
-__all__ = ["EnvironmentContextService", "EnvironmentSnapshot"]
+__all__ = [
+    "EnvironmentContextBuilder",
+    "EnvironmentContextService",
+    "EnvironmentInjection",
+    "EnvironmentSnapshot",
+]

core/environment/context_builder.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+
+@dataclass(frozen=True)
+class EnvironmentInjection:
+    summary_text: str
+    raw_context: Dict[str, Any]
+    metadata: Dict[str, Any]
+
+
+class EnvironmentContextBuilder:
+    """
+    將最新環境快照轉成固定可注入格式。
+
+    設計目標：
+    1. 每回合固定注入，但內容結構固定，避免 prompt 漂移
+    2. 同時保留 raw context，供工具與 runtime 做更細緻決策
+    3. 缺資料時明確標記 freshness / completeness，而不是靜默忽略
+    """
+
+    def build(
+        self,
+        env_context: Optional[Dict[str, Any]],
+        *,
+        now: Optional[datetime] = None,
+    ) -> EnvironmentInjection:
+        ctx = dict(env_context or {})
+        current_time = now or datetime.now(timezone.utc)
+
+        lines = [
+            f"snapshot_time_utc: {current_time.isoformat()}",
+            f"has_location: {self._has_location(ctx)}",
+            f"has_address: {bool(ctx.get('detailed_address') or ctx.get('address_display') or ctx.get('label'))}",
+            f"has_timezone: {bool(ctx.get('tz'))}",
+            f"has_locale: {bool(ctx.get('locale'))}",
+        ]
+
+        if ctx.get("detailed_address"):
+            lines.append(f"detailed_address: {ctx['detailed_address']}")
+        elif ctx.get("address_display"):
+            lines.append(f"address_display: {ctx['address_display']}")
+        elif ctx.get("label"):
+            lines.append(f"label: {ctx['label']}")
+
+        if ctx.get("city"):
+            lines.append(f"city: {ctx['city']}")
+        if ctx.get("admin"):
+            lines.append(f"admin: {ctx['admin']}")
+        if ctx.get("country_code"):
+            lines.append(f"country_code: {ctx['country_code']}")
+        if ctx.get("precision"):
+            lines.append(f"precision: {ctx['precision']}")
+        if ctx.get("poi_label"):
+            lines.append(f"poi_label: {ctx['poi_label']}")
+        if ctx.get("road"):
+            lines.append(f"road: {ctx['road']}")
+        if ctx.get("house_number"):
+            lines.append(f"house_number: {ctx['house_number']}")
+        if ctx.get("tz"):
+            lines.append(f"timezone: {ctx['tz']}")
+        if ctx.get("locale"):
+            lines.append(f"locale: {ctx['locale']}")
+        if ctx.get("heading_cardinal"):
+            lines.append(f"heading: {ctx['heading_cardinal']}")
+        elif ctx.get("heading_deg") is not None:
+            lines.append(f"heading_deg: {ctx['heading_deg']}")
+        if ctx.get("accuracy_m") is not None:
+            lines.append(f"accuracy_m: {ctx['accuracy_m']}")
+        if ctx.get("lat") is not None and ctx.get("lon") is not None:
+            lines.append(f"coordinates: {ctx['lat']},{ctx['lon']}")
+
+        metadata = {
+            "source": "environment_context_service",
+            "freshness": "latest_available" if ctx else "missing",
+            "has_location": self._has_location(ctx),
+            "has_timezone": bool(ctx.get("tz")),
+            "has_locale": bool(ctx.get("locale")),
+        }
+
+        return EnvironmentInjection(
+            summary_text="\n".join(lines),
+            raw_context=ctx,
+            metadata=metadata,
+        )
+
+    @staticmethod
+    def _has_location(ctx: Dict[str, Any]) -> bool:
+        return ctx.get("lat") is not None and ctx.get("lon") is not None

core/intent_detector.py

@@ -17,9 +17,13 @@ from typing import Dict, Any, Optional, Tuple, List
 
 from core.tool_registry import tool_registry
 from core.logging import get_logger
+from core.config import settings
+from core.prompts.tool_calling_policy import get_tool_calling_policy
 
 logger = get_logger("core.intent_detector")
 
+MIN_TOOL_CONFIDENCE = 0.90
+
 
 class IntentDetector:
     """
@@ -37,6 +41,14 @@ class IntentDetector:
     
     def __init__(self):
         self._cache: Dict[str, Tuple[bool, Optional[Dict[str, Any]], float]] = {}
+
+    @staticmethod
+    def _estimate_tool_confidence(tool_name: str, arguments: Dict[str, Any]) -> float:
+        if not tool_name:
+            return 0.0
+        if not isinstance(arguments, dict):
+            return 0.0
+        return 0.95 if arguments else 0.92
     
     async def detect(
         self,
@@ -143,7 +155,7 @@ class IntentDetector:
                 messages=messages,
                 tools=tools,
                 user_id="intent_detection",
-                model="gpt-5-nano",
+                model=settings.GPT_INTENT_MODEL,
                 reasoning_effort=optimal_effort,
             )
             
@@ -159,12 +171,14 @@ class IntentDetector:
         
         注意：不再描述每個工具，工具定義由 tools 參數傳遞
         """
-        return """你是一個多語言智能助手，根據用戶需求選擇合適的工具。支援中文、英文、日文、印尼文、越南文。
+        return f"""你是一個多語言智能助手，根據用戶需求選擇合適的工具。支援中文、英文、日文、印尼文、越南文。
+
+{get_tool_calling_policy()}
 
 【核心規則】
 1. 用戶詢問任何可用工具能解決的需求時，必須選擇對應工具
 2. 只有純粹的閒聊、問候、情感表達才不選擇工具
-3. 工具參數盡量從用戶消息中提取，無法確定的使用合理預設值
+3. 工具參數從用戶消息中提取；無法確定的可選參數留空，不自行編造預設值
 
 【多語言意圖識別】
 無論用戶使用什麼語言，都要識別以下意圖並選擇對應工具：
@@ -251,6 +265,7 @@ class IntentDetector:
                 "tool_name": tool_name,
                 "arguments": arguments,
                 "emotion": emotion,
+                "confidence": self._estimate_tool_confidence(tool_name, arguments),
             }
         
         # 沒有工具調用，視為一般聊天

core/logging.py

@@ -1,105 +1,121 @@
-"""
-統一日誌配置
-集中管理所有模組的日誌設定
-
-使用方式：
-    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"
-
+# ANSI 轉義序列
+class LogColor:
+    DEBUG = "\x1b[38;20m"    # 灰色
+    INFO = "\x1b[32;20m"     # 綠色
+    WARNING = "\x1b[33;20m"  # 黃色
+    ERROR = "\x1b[31;20m"    # 紅色
+    CRITICAL = "\x1b[31;1m"   # 粗體紅
+    RESET = "\x1b[0m"
+    GRAY = "\x1b[90m"        # 淺灰色
+    CYAN = "\x1b[36;20m"     # 青色
+    BLUE = "\x1b[34;20m"     # 藍色
+    MAGENTA = "\x1b[35;20m"  # 品紅
+
+class ColoredFormatter(logging.Formatter):
+    """自定義彩色日誌格式化器"""
+    
+    LEVEL_COLORS = {
+        logging.DEBUG: LogColor.GRAY,
+        logging.INFO: LogColor.INFO,
+        logging.WARNING: LogColor.WARNING,
+        logging.ERROR: LogColor.ERROR,
+        logging.CRITICAL: LogColor.CRITICAL
+    }
+
+    def format(self, record):
+        level_color = self.LEVEL_COLORS.get(record.levelno, LogColor.RESET)
+        
+        # 格式化時間（淡灰色）
+        asctime = self.formatTime(record, self.datefmt)
+        asctime_colored = f"{LogColor.GRAY}{asctime}{LogColor.RESET}"
+        
+        # 格式化名稱（青色）
+        name_colored = f"{LogColor.CYAN}{record.name}{LogColor.RESET}"
+        
+        # 格式化等級（根據等級變色）
+        levelname_colored = f"{level_color}{record.levelname:8}{LogColor.RESET}"
+        
+        # 格式化訊息
+        message = record.getMessage()
+        
+        # 自動截斷過長的訊息（如工具調用的完整原始數據）
+        if len(message) > 500:
+            message = message[:500] + f"{LogColor.GRAY}... [已截斷，共 {len(message)} 字元]{LogColor.RESET}"
+
+        if "✅" in message:
+            message = f"{LogColor.INFO}{message}{LogColor.RESET}"
+        elif "❌" in message or "⚠️" in message:
+            message = f"{LogColor.ERROR}{message}{LogColor.RESET}"
+        elif "🎙️" in message or "🔊" in message:
+            message = f"{LogColor.BLUE}{message}{LogColor.RESET}"
+        elif "🌐" in message or "MCP" in message:
+            message = f"{LogColor.MAGENTA}{message}{LogColor.RESET}"
+        else:
+            message = f"{level_color}{message}{LogColor.RESET}"
+            
+        return f"{asctime_colored} | {name_colored} | {levelname_colored} | {message}"
+
+# 全域日誌等級
+_LOG_LEVEL_NAME = os.getenv("BLOOMWARE_LOG_LEVEL", "INFO").upper()
+_LOG_LEVEL = getattr(logging, _LOG_LEVEL_NAME, logging.INFO)
 
 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)
+        console_handler.setFormatter(ColoredFormatter())
         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 = logging.getLogger()
+        root.setLevel(get_log_level())
+        
+        # 清除現有的 handlers
+        for handler in root.handlers[:]:
+            root.removeHandler(handler)
+            
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(ColoredFormatter())
+        root.addHandler(console_handler)
+        
         _root_configured = True
 
-
 # 自動配置
 configure_root_logger()
+
+# 關閉 Speechbrain 等吵雜的日誌
+logging.getLogger("speechbrain").setLevel(logging.WARNING)
+logging.getLogger("werkzeug").setLevel(logging.WARNING)
+logging.getLogger("urllib3").setLevel(logging.WARNING)
+logging.getLogger("httpcore").setLevel(logging.WARNING)
+logging.getLogger("httpx").setLevel(logging.WARNING)

core/memory_system.py

@@ -1,6 +1,8 @@
 import json
 from typing import List, Dict, Any, Optional, Tuple
 from datetime import datetime
+import asyncio
+import random
 
 # 統一日誌配置
 from core.logging import get_logger
@@ -8,12 +10,122 @@ logger = get_logger("MemorySystem")
 
 # 統一 OpenAI 客戶端
 from core.ai_client import get_openai_client
+from core.config import settings
+from core.responses_runtime import ResponsesAgentRuntime
 
 def _get_memory_client():
     """取得記憶系統用的 OpenAI 客戶端"""
     return get_openai_client()
 
 
+TRANSIENT_MEMORY_ERROR_MARKERS = (
+    "502",
+    "503",
+    "504",
+    "bad gateway",
+    "upstream",
+    "timeout",
+    "timed out",
+    "connection",
+)
+
+TRANSIENT_QUERY_MARKERS = (
+    "今天",
+    "現在",
+    "目前",
+    "最新",
+    "即時",
+    "收盤",
+    "開盤",
+    "股價",
+    "股票",
+    "匯率",
+    "天氣",
+    "新聞",
+    "多少",
+    "查詢",
+    "search",
+    "latest",
+    "today",
+    "now",
+    "price",
+    "stock",
+    "weather",
+    "news",
+)
+
+MEMORY_ANALYSIS_SCHEMA = {
+    "type": "object",
+    "properties": {
+        "memories": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "type": {
+                        "type": "string",
+                        "enum": ["personal_info", "preferences", "goals"],
+                    },
+                    "content": {"type": "string"},
+                    "importance": {
+                        "type": "number",
+                        "minimum": 0,
+                        "maximum": 1,
+                    },
+                },
+                "required": ["type", "content", "importance"],
+                "additionalProperties": False,
+            },
+        }
+    },
+    "required": ["memories"],
+    "additionalProperties": False,
+}
+
+
+def _is_transient_memory_error(exc: Exception) -> bool:
+    if isinstance(exc, TimeoutError) or isinstance(exc, asyncio.TimeoutError):
+        return True
+    error_text = str(exc).lower()
+    return any(marker in error_text for marker in TRANSIENT_MEMORY_ERROR_MARKERS)
+
+
+def _should_run_ai_memory_analysis(user_message: str, assistant_response: str = "") -> bool:
+    text = f"{user_message}\n{assistant_response}".strip().lower()
+    if not text:
+        return False
+
+    durable_markers = (
+        "我叫",
+        "我的名字",
+        "我喜歡",
+        "我不喜歡",
+        "我討厭",
+        "我的偏好",
+        "我住在",
+        "我的工作",
+        "我的目標",
+        "我想達成",
+        "我希望",
+        "請記得",
+        "記住",
+        "下次",
+        "my name",
+        "i like",
+        "i dislike",
+        "remember",
+        "my goal",
+    )
+    if any(marker in text for marker in durable_markers):
+        return True
+
+    user_text = (user_message or "").lower()
+    if any(marker in user_text for marker in TRANSIENT_QUERY_MARKERS):
+        return False
+
+    return len(user_message.strip()) >= 80
+
+
 
 # 導入數據庫函數
 try:
@@ -122,7 +234,44 @@ class MemoryAnalyzer:
     """記憶分析器：使用AI分析對話內容"""
 
     def __init__(self):
-        pass
+        self.responses_runtime = ResponsesAgentRuntime()
+
+    @staticmethod
+    def _memory_model() -> str:
+        return settings.OPENAI_MODEL or settings.GPT_INTENT_MODEL
+
+    @staticmethod
+    def _memory_timeout() -> float:
+        return min(float(getattr(settings, "OPENAI_TIMEOUT", 30)), 20.0)
+
+    @staticmethod
+    async def _transient_backoff(attempt: int) -> None:
+        delay = min(0.5 * (2 ** attempt), 3.0) + random.uniform(0, 0.2)
+        await asyncio.sleep(delay)
+
+    def _create_analysis_response(self, client: Any, messages: List[Dict[str, str]], max_tokens_value: int) -> Any:
+        model = self._memory_model()
+        if settings.OPENAI_USE_RESPONSES and model.startswith("gpt-5"):
+            payload = self.responses_runtime.build_payload_from_messages(
+                messages=messages,
+                model=model,
+                max_output_tokens=max_tokens_value,
+                text_format={
+                    "type": "json_schema",
+                    "name": "memory_analysis",
+                    "strict": True,
+                    "schema": MEMORY_ANALYSIS_SCHEMA,
+                },
+            )
+            payload["store"] = False
+            return client.responses.create(**payload)
+
+        return client.chat.completions.create(
+            model=model,
+            messages=messages,
+            max_completion_tokens=max_tokens_value,
+            response_format={"type": "json_object"},
+        )
 
     async def analyze_conversation(self, user_message: str, assistant_response: str = "",
                                   conversation_history: List[Dict] = None) -> List[Dict[str, Any]]:
@@ -174,39 +323,42 @@ class MemoryAnalyzer:
                 {"role": "user", "content": user_prompt}
             ]
 
-            # 嘗試調用OpenAI API，最多重試2次
-            max_retries = 2
-            for attempt in range(max_retries + 1):
+            max_attempts = 3
+            for attempt in range(max_attempts):
                 try:
-                    if attempt > 0:
-                        # 如果是重試，增加token限制
-                        max_tokens_value = 2000 + (attempt * 1000)
-                        logger.info(f"重試AI分析 (嘗試 {attempt + 1}/{max_retries + 1})，增加token限制到 {max_tokens_value}")
-                    else:
-                        max_tokens_value = 2000
+                    max_tokens_value = 500
 
-                    response = client.chat.completions.create(
-                        model="gpt-5-nano",
-                        messages=messages,
-                        max_completion_tokens=max_tokens_value,
-                        reasoning_effort="low"
+                    response = await asyncio.wait_for(
+                        asyncio.to_thread(self._create_analysis_response, client, messages, max_tokens_value),
+                        timeout=self._memory_timeout(),
                     )
                     break  # 成功後跳出重試循環
 
                 except Exception as api_error:
                     error_str = str(api_error).lower()
-                    if "max_tokens" in error_str or "token limit" in error_str:
-                        if attempt < max_retries:
-                            logger.warning(f"AI分析遇到token限制錯誤，正在重試 ({attempt + 1}/{max_retries + 1}): {api_error}")
+                    if _is_transient_memory_error(api_error):
+                        if attempt < max_attempts - 1:
+                            logger.warning(
+                                "AI記憶分析遇到暫時性上游錯誤，準備重試 (%s/%s): %s",
+                                attempt + 1,
+                                max_attempts,
+                                api_error,
+                            )
+                            await self._transient_backoff(attempt)
                             continue
-                        else:
-                            logger.error(f"AI分析在 {max_retries + 1} 次嘗試後仍然遇到token限制錯誤: {api_error}")
-                            return []  # 返回空列表，回退到關鍵字提取
+                        logger.error("AI記憶分析連續暫時性上游錯誤，已放棄本輪背景分析: %s", api_error)
+                        return []
+                    if "max_tokens" in error_str or "token limit" in error_str:
+                        logger.error(f"AI分析遇到token限制錯誤: {api_error}")
+                        return []  # 返回空列表，回退到關鍵字提取
                     else:
                         # 其他類型的錯誤，直接拋出
                         raise api_error
 
-            result_text = response.choices[0].message.content.strip()
+            if hasattr(response, "choices"):
+                result_text = response.choices[0].message.content.strip()
+            else:
+                result_text = self.responses_runtime.extract_output_text(response)
 
             # 解析JSON結果 - 嘗試多種解析方式
             try:
@@ -241,6 +393,9 @@ class MemoryAnalyzer:
             return memories
 
         except Exception as e:
+            if _is_transient_memory_error(e):
+                logger.info("AI記憶分析遇到暫時性上游錯誤，跳過本輪背景分析: %s", e)
+                return []
             logger.error(f"AI記憶分析時發生錯誤: {e}")
             return []
 
@@ -268,10 +423,12 @@ class MemoryManager:
 
             # 2. 使用AI分析提取記憶（如果可用）
             ai_memories = []
-            if _get_memory_client():
+            if _get_memory_client() and _should_run_ai_memory_analysis(user_message, assistant_response):
                 ai_memories = await self.analyzer.analyze_conversation(
                     user_message, assistant_response, conversation_history
                 )
+            else:
+                logger.debug("跳過AI記憶分析：本輪內容不具備長期記憶價值或客戶端不可用")
 
             # 3. 合併記憶（去重）
             all_memories = self._merge_memories(keyword_memories, ai_memories)

core/pipeline.py

@@ -4,9 +4,13 @@ from dataclasses import dataclass
 from typing import Any, Awaitable, Callable, Optional, Dict, Tuple, List
 
 from core.emotion_care_manager import EmotionCareManager
+from core.config import settings
+from core.voice_care_gate import decide_voice_care, is_voice_context
 
 logger = logging.getLogger(__name__)
 
+MIN_TOOL_CONFIDENCE = 0.90
+
 
 @dataclass
 class PipelineResult:
@@ -35,10 +39,10 @@ class ChatPipeline:
         intent_detector: Callable[[str], Awaitable[Tuple[bool, dict]]],
         feature_processor: Callable[[dict, str, str, Optional[str]], Awaitable[Any]],
         ai_generator: Callable[..., Awaitable[str]],
-        model: str = "gpt-5-nano",
-        detect_timeout: float = 5.0,    # 2025 最佳實踐：Structured Outputs 通常 2-3秒
-        feature_timeout: float = 10.0,  # MCP 工具已有內部超時（30秒）
-        ai_timeout: float = 12.0,       # 配合 Streaming（首次回應 0.5-1秒）
+        model: Optional[str] = None,
+        detect_timeout: float = 20.0,   # 考量到 Function Calling 可能較慢
+        feature_timeout: float = 30.0,  # MCP 工具內部超時
+        ai_timeout: float = 25.0,       # 配合 Streaming
     ) -> None:
         self._intent_detector = intent_detector
         self._feature_processor = feature_processor
@@ -46,7 +50,7 @@ class ChatPipeline:
         self._detect_timeout = detect_timeout
         self._feature_timeout = feature_timeout
         self._ai_timeout = ai_timeout
-        self._model = model
+        self._model = model or settings.OPENAI_MODEL
 
     def _is_chinese_message(self, text: str) -> bool:
         """
@@ -142,11 +146,15 @@ class ChatPipeline:
                 {"role": "user", "content": combined_text}
             ]
 
-            logger.info(f"🌐 呼叫 GPT 翻譯，模型: gpt-4o-mini")
+            logger.info(f"🌐 呼叫 GPT 翻譯")
+            # 格式化回應使用環境變數設定的模型
+            model = settings.GPT_INTENT_MODEL or settings.OPENAI_MODEL
+            logger.info(f"🎨 使用配置模型進行格式化: {model}")
+            
             translated = await ai_service.generate_response_async(
                 messages=messages,
-                model="gpt-4o-mini",  # 升級到 gpt-4o-mini 以提升翻譯品質
-                reasoning_effort=None,  # gpt-4o-mini 不支援此參數
+                model=model,
+                reasoning_effort=None,
                 max_tokens=800,
             )
             logger.info(f"🌐 GPT 翻譯完成，結果長度: {len(translated) if translated else 0}")
@@ -221,207 +229,182 @@ class ChatPipeline:
 
         # language 參數保留以向後兼容，但不使用（GPT 自動判斷語言）
 
-        # 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
-
-        # 【情緒融合】雙軌制：音頻情緒優先，文字情緒輔助
-        text_emotion = intent_data.get("emotion", "neutral") if intent_data else "neutral"
-        logger.info(f"🎭 [情緒流向-1] 文字情緒: {text_emotion}")
-
-        # 檢查音頻情緒
-        if audio_emotion:
-            logger.info(f"🎭 [情緒流向-2] 音頻情緒資料: success={audio_emotion.get('success')}, emotion={audio_emotion.get('emotion')}, confidence={audio_emotion.get('confidence')}")
-
-        # 情緒融合邏輯
-        emotion_confidence = 0.5  # 預設置信度
-        if audio_emotion and audio_emotion.get("success"):
-            audio_emotion_label = audio_emotion.get("emotion", "neutral")
-            audio_confidence = audio_emotion.get("confidence", 0.0)
-
-            # 【優化】提高門檻到 0.7，避免誤判（太敏感會導致錯誤情緒）
-            if audio_confidence >= 0.7:
-                emotion_value = audio_emotion_label
-                emotion_confidence = audio_confidence
-                logger.info(f"🎭 [情緒流向-3] ✅ 採用音頻情緒: {emotion_value} (置信度: {audio_confidence:.4f})")
-            else:
-                emotion_value = text_emotion
-                emotion_confidence = 0.5  # 文字情緒預設置信度
-                logger.info(f"🎭 [情緒流向-3] ⬇️ 音頻置信度過低 ({audio_confidence:.4f})，改用文字情緒: {emotion_value}")
-        else:
-            emotion_value = text_emotion
-            emotion_confidence = 0.5  # 文字情緒預設置信度
-            logger.info(f"🎭 [情緒流向-3] 📝 無音頻情緒，使用文字情緒: {emotion_value}")
-
-        # 【關鍵】記錄最終情緒
-        logger.info(f"🎭 [情緒流向-最終] emotion={emotion_value}, confidence={emotion_confidence:.2f}")
-
-        # 1) 檢查是否在關懷模式
-        if user_id and EmotionCareManager.is_in_care_mode(user_id, chat_id):
-            # 檢查是否解��關懷模式（傳入情緒資訊）
-            if EmotionCareManager.check_release(user_id, user_message, chat_id, emotion=emotion_value):
-                logger.info(f"✅ 用戶 {user_id} 情緒恢復，解除關懷模式，繼續正常流程")
-                # 解除後繼續正常流程
-            else:
-                logger.info(f"💙 用戶 {user_id} 在關懷模式中，跳過工具調用，使用關懷 AI")
-                # 直接用關懷模式 AI 回應（不檢測意圖，不調用工具）
-                care_emotion = EmotionCareManager.get_care_emotion(user_id, chat_id)
-                final_emotion = care_emotion or emotion_value
+        has_feature = False
+        intent_data = None
+        tool_context = ""
+        tool_results_list = []
+        emotion_value = "neutral"
+        care_emotion = None
+        use_care_mode = False
+        max_loops = 3
+        current_loop = 0
+        ai_res_text = ""
+
+        while current_loop < max_loops:
+            # 0) 先進行意圖偵測與可回答性評估 (Confidence-driven check)
+            detect_res = await self._with_timeout(
+                self._intent_detector(user_message, tool_context, language=language), self._detect_timeout, reason="detect"
+            )
+            if isinstance(detect_res, PipelineResult):
+                return detect_res
+            has_feature, intent_data = detect_res
+            
+            if current_loop == 0:
+                # 只在第一輪提取情緒與進行關懷模式判斷
+                if intent_data and "emotion" in intent_data:
+                    emotion_value = intent_data["emotion"]
+                else:
+                    emotion_value = "neutral"
+
+                voice_context = is_voice_context(audio_emotion)
+                voice_care_decision = None
+                if voice_context:
+                    try:
+                        voice_care_decision = decide_voice_care(text_emotion=emotion_value, audio_emotion=audio_emotion)
+                        if voice_care_decision.emotion:
+                            emotion_value = voice_care_decision.emotion
+                    except Exception as e:
+                        logger.warning(f"Voice care decision failed: {e}")
+
+                emotion_confidence = float(audio_emotion.get("confidence", 0.0)) if isinstance(audio_emotion, dict) else 0.0
+
+                if EmotionCareManager.is_in_care_mode(user_id):
+                    exit_match = False
+                    if "沒事了" in user_message or "謝謝" in user_message or "好多了" in user_message:
+                        if emotion_value not in ["sad", "angry", "fear"]:
+                            exit_match = True
+                        if voice_context and voice_care_decision and not voice_care_decision.allow:
+                            exit_match = True
+
+                    if exit_match:
+                        logger.info(f"💙 使用者情緒平穩 [{emotion_value}]，退出關懷模式")
+                        EmotionCareManager.exit_care_mode(user_id)
+                        use_care_mode = False
+                        if emotion_callback:
+                            try:
+                                await emotion_callback(emotion_value, False)
+                            except Exception as e:
+                                logger.warning(f"emotion_callback 錯誤: {e}")
+                    else:
+                        logger.info(f"💙 維持關懷模式，情緒=[{emotion_value}]")
+                        use_care_mode = True
+                        care_emotion = EmotionCareManager._active_care_users.get(user_id, {}).get("emotion") or emotion_value
+                        if emotion_callback:
+                            try:
+                                await emotion_callback(emotion_value, True)
+                            except Exception as e:
+                                logger.warning(f"emotion_callback 錯誤: {e}")
+
+                        ai_res = await self._with_timeout(
+                            self._ai_generator(
+                                user_message,
+                                user_id,
+                                self._model,
+                                request_id,
+                                chat_id,
+                                use_care_mode=use_care_mode,
+                                care_emotion=care_emotion,
+                                emotion_label=emotion_value,
+                                is_first_care=False,
+                            ),
+                            self._ai_timeout,
+                            reason="ai-care",
+                        )
+                        if isinstance(ai_res, PipelineResult):
+                            return ai_res
+                        text = str(ai_res or "").strip()
+                        if not text:
+                            text = "我在這裡陪你，隨時可以聊聊。"
+                        return PipelineResult(text=text, is_fallback=False, meta={"care_mode": True, "emotion": care_emotion})
+
+                # 檢查是否需要進入關懷模式
+                can_enter_care = True
+                if voice_context and voice_care_decision is not None:
+                    can_enter_care = voice_care_decision.allow
+
+                if can_enter_care and user_id and EmotionCareManager.check_and_enter_care_mode(
+                    user_id, emotion_value, chat_id, confidence=emotion_confidence
+                ):
+                    logger.warning(f"⚠️ 偵測到極端情緒 [{emotion_value}]（置信度: {emotion_confidence:.2f}），進入關懷模式")
+                    
+                    if emotion_callback:
+                        try:
+                            await emotion_callback(emotion_value, True)
+                        except Exception as e:
+                            logger.warning(f"emotion_callback 錯誤: {e}")
+
+                    ai_res = await self._with_timeout(
+                        self._ai_generator(
+                            user_message,
+                            user_id,
+                            self._model,
+                            request_id,
+                            chat_id,
+                            use_care_mode=True,
+                            care_emotion=emotion_value,
+                            emotion_label=emotion_value,
+                            is_first_care=True,  # 告知 Agent 這是第一次進入，需引導退出
+                        ),
+                        self._ai_timeout,
+                        reason="ai-care",
+                    )
+                    if isinstance(ai_res, PipelineResult):
+                        return ai_res
+                    text = str(ai_res or "").strip()
+                    if not text:
+                        text = "我聽到了，我在這裡陪你。"
+
+                    return PipelineResult(text=text, is_fallback=False, meta={"care_mode": True, "emotion": emotion_value})
+
                 if emotion_callback:
                     try:
-                        await emotion_callback(final_emotion, True)
+                        await emotion_callback(emotion_value, False)
                     except Exception as e:
                         logger.warning(f"emotion_callback 錯誤: {e}")
 
-                ai_res = await self._with_timeout(
-                    self._ai_generator(
-                        user_message,
-                        user_id,
-                        self._model,
-                        request_id,
-                        chat_id,
-                        use_care_mode=True,
-                        care_emotion=care_emotion,
-                        emotion_label=care_emotion,
-                    ),
-                    self._ai_timeout,
-                    reason="ai-care",
-                )
-                if isinstance(ai_res, PipelineResult):
-                    return ai_res
-                text = str(ai_res or "").strip()
-                if not text:
+            if has_feature and intent_data and intent_data.get("type") == "mcp_tool":
+                confidence = float(intent_data.get("confidence", 0.0) or 0.0)
+                if confidence < MIN_TOOL_CONFIDENCE:
+                    logger.info("🔒 工具信心度不足 %.2f，禁止調用工具", confidence)
                     return PipelineResult(
-                        text="我在這裡陪你，隨時可以聊聊。",
+                        text=self._build_low_confidence_tool_message(user_message, confidence),
                         is_fallback=True,
-                        reason="ai-care-empty",
-                        meta={"care_mode": True, "emotion": care_emotion or "sad"}
+                        reason="low_confidence",
+                        meta={"confidence": confidence}
                     )
-                return PipelineResult(text=text, is_fallback=False, meta={"care_mode": True, "emotion": care_emotion})
-
-        # 2) 檢查是否需要進入關懷模式（傳遞置信度，用於連續性判斷）
-        if user_id and EmotionCareManager.check_and_enter_care_mode(
-            user_id, emotion_value, chat_id, confidence=emotion_confidence
-        ):
-            logger.warning(f"⚠️ 偵測到極端情緒 [{emotion_value}]（置信度: {emotion_confidence:.2f}），進入關懷模式")
-            # 立即使用關懷模式 AI 回應
-            
-            if emotion_callback:
-                try:
-                    await emotion_callback(emotion_value, True)
-                except Exception as e:
-                    logger.warning(f"emotion_callback 錯誤: {e}")
-
-            ai_res = await self._with_timeout(
-                self._ai_generator(
-                    user_message,
-                    user_id,
-                    self._model,
-                    request_id,
-                    chat_id,
-                    use_care_mode=True,
-                    care_emotion=emotion_value,
-                    emotion_label=emotion_value,
-                ),
-                self._ai_timeout,
-                reason="ai-care",
-            )
-            if isinstance(ai_res, PipelineResult):
-                return ai_res
-            text = str(ai_res or "").strip()
-            if not text:
-                text = "我聽到了，我在這裡陪你。"
-
-            # 第一次進入關懷模式時，附加退出提示（新增）
-            exit_hint = "\n\n💙 關懷模式已啟動。說「我沒事了」可以退出。"
-            return PipelineResult(text=text + exit_hint, is_fallback=False, meta={"care_mode": True, "emotion": emotion_value})
-
-        if emotion_callback:
-            try:
-                await emotion_callback(emotion_value, False)
-            except Exception as e:
-                logger.warning(f"emotion_callback 錯誤: {e}")
-
-        # 3) 有功能 → 功能處理(限時)
-        if has_feature and intent_data:
-            feat_res = await self._with_timeout(
-                self._feature_processor(intent_data, user_id, user_message, chat_id),
-                self._feature_timeout,
-                reason="feature",
-            )
-            if isinstance(feat_res, PipelineResult):
-                return feat_res
-            # 如果返回 None，表示這是聊天，不應該被當作功能處理
-            if feat_res is None:
-                has_feature = False
-                intent_data = None
-            else:
-                # 檢查是否為字典（包含工具信息）
-                if isinstance(feat_res, dict):
-                    text = feat_res.get('message', feat_res.get('content', '')).strip()
-                    tool_name = feat_res.get('tool_name')
-                    tool_data = feat_res.get('tool_data')
-                    if not text:
-                        return PipelineResult(
-                            text="抱歉，功能處理沒有產出結果。",
-                            is_fallback=True,
-                            reason="feature-empty",
-                            meta={"emotion": emotion_value, "care_mode": False}
-                        )
 
-                    # 簡化翻譯：非中文用戶 → 翻譯工具卡片
-                    is_chinese = self._is_chinese_message(user_message)
-                    logger.info(f"🌐 語言檢測: user_message='{user_message}', is_chinese={is_chinese}")
-                    if not is_chinese and tool_data:
-                        logger.info(f"🌐 開始翻譯工具卡片: {len(str(tool_data))} chars")
-                        tool_data = await self._translate_tool_data(tool_data, user_message)
-                        logger.info(f"🌐 翻譯完成: {len(str(tool_data))} chars")
-                    elif is_chinese:
-                        logger.info(f"🌐 用戶使用中文，不翻譯工具卡片")
-                    elif not tool_data:
-                        logger.info(f"🌐 無工具資料，跳過翻譯")
-
-                    # 返回帶有工具元數據的結果（包含情緒）
-                    meta_dict = {
-                        'emotion': emotion_value,
-                        'care_mode': False  # 工具調用不是關懷模式
-                    }
-                    if tool_name:
-                        meta_dict['tool_name'] = tool_name
-                    if tool_data:
-                        meta_dict['tool_data'] = tool_data
-
-                    return PipelineResult(
-                        text=text,
-                        is_fallback=False,
-                        meta=meta_dict
-                    )
+            if has_feature and intent_data:
+                feat_res = await self._with_timeout(
+                    self._feature_processor(intent_data, user_id, user_message, chat_id),
+                    self._feature_timeout,
+                    reason="feature",
+                )
+                if isinstance(feat_res, PipelineResult):
+                    tool_context += f"\n[工具執行結果]:\n{feat_res.text}\n"
+                    tool_results_list.append({"text": feat_res.text, "meta": feat_res.meta})
+                elif isinstance(feat_res, dict):
+                    t_name = feat_res.get('tool_name', 'unknown')
+                    t_msg = feat_res.get('message', '')
+                    t_data = feat_res.get('tool_data', {})
+                    tool_context += f"\n[工具 {t_name} 執行結果]:\n{t_msg}\n(Data: {str(t_data)[:2000]})\n"
+                    tool_results_list.append(feat_res)
                 else:
-                    # 正常字串
                     text = str(feat_res or "").strip()
-                    if not text:
-                        return PipelineResult(
-                            text="抱歉，功能處理沒有產出結果。",
-                            is_fallback=True,
-                            reason="feature-empty",
-                            meta={"emotion": emotion_value, "care_mode": False}
-                        )
-
-                    # 不再翻譯工具回應，讓 GPT 自己處理並用���應語言描述
-
-                    return PipelineResult(
-                        text=text,
-                        is_fallback=False,
-                        meta={"emotion": emotion_value, "care_mode": False},
-                    )
+                    tool_context += f"\n[工具執行結果]:\n{text}\n"
+                    tool_results_list.append({"text": text})
+                # 【效能優化】短路機制：如果工具調用信心度為 100%，且是簡單工具，則不進入下一輪驗證
+                if confidence >= 1.0:
+                    logger.info("⚡ 工具執行信心度高且結果明確，跳過冗餘驗證")
+                    break
+
+                current_loop += 1
+                continue
+            else:
+                # 如果沒有調用工具，表示 Agent 對目前答案已有 100% 信心，退出循環
+                break
 
-        # 4) 無功能 → 一般聊天（限時）
-        # 注意：不傳 messages，改傳 user_message，讓 ai_generator 自動載入歷史對話和記憶
-        ai_res = await self._with_timeout(
+        # 4) 最後 AI 生成回應（結合了所有 tool_context）
+        ai_res_text = await self._with_timeout(
             self._ai_generator(
                 user_message,
                 user_id or "default",
@@ -430,25 +413,48 @@ class ChatPipeline:
                 chat_id,
                 emotion_label=emotion_value,
                 language=language,
+                tool_context=tool_context,
             ),
             self._ai_timeout,
-            reason="ai",
+            reason="ai_gen",
+        )
+        if isinstance(ai_res_text, PipelineResult):
+            return ai_res_text
+
+        meta = {"emotion": emotion_value, "care_mode": use_care_mode}
+        if tool_results_list:
+            executed_tools = []
+            for t in tool_results_list:
+                if isinstance(t, dict) and t.get("tool_name"):
+                    executed_tools.append({
+                        "tool_name": t.get("tool_name"),
+                        "tool_data": t.get("tool_data")
+                    })
+                elif hasattr(t, 'meta') and t.meta and t.meta.get("tool_name"):
+                    executed_tools.append({
+                        "tool_name": t.meta.get("tool_name"),
+                        "tool_data": t.meta.get("tool_data")
+                    })
+            if executed_tools:
+                meta["executed_tools"] = executed_tools
+                # 兼容原有邏輯，將最後一個工具設為主卡片
+                last_tool = executed_tools[-1]
+                meta["tool_name"] = last_tool["tool_name"]
+                meta["tool_data"] = last_tool["tool_data"]
+            else:
+                last_tool = tool_results_list[-1]
+                if isinstance(last_tool, dict):
+                    meta["tool_name"] = last_tool.get("tool_name")
+                    meta["tool_data"] = last_tool.get("tool_data")
+                elif hasattr(last_tool, 'meta') and last_tool.meta:
+                    meta.update(last_tool.meta)
+
+        return PipelineResult(
+            text=str(ai_res_text or "").strip(),
+            is_fallback=False,
+            meta=meta
         )
-        if isinstance(ai_res, PipelineResult):
-            return ai_res
-        text = str(ai_res or "").strip()
-        if not text:
-            return PipelineResult(
-                text="抱歉，我暫時沒有合適的回應。可以換個說法再試試嗎？",
-                is_fallback=True,
-                reason="ai-empty",
-                meta={"emotion": emotion_value, "care_mode": False}
-            )
-
-        # 一般聊天也包含情緒資訊
-        meta_dict = {
-            'emotion': emotion_value,
-            'care_mode': False  # 一般聊天不是關懷模式
-        }
 
-        return PipelineResult(text=text, is_fallback=False, meta=meta_dict)
+    def _build_low_confidence_tool_message(self, user_message: str, confidence: float) -> str:
+        """建立低信心度工具調用的提示訊息"""
+        return "抱歉，我不太確定您的意思。您能說得更具體一點嗎？"

core/prompts/care_mode.py

@@ -1,8 +1,16 @@
 """
 情緒關懷模式 Prompt
-精簡化設計，保持關懷品質
+⚠️ DEPRECATED: 此模組的內容已遷移至 services/ai_service.py 中的
+CARE_MODE_BASE_PROMPT / EMOTION_SPECIFIC_PROMPTS / get_care_mode_prompt()。
+本模組僅保留向後兼容的 re-export，供既有測試使用。
 """
 
+import warnings as _warnings
+
+# ── 向後兼容 re-export ──────────────────────────────────────────
+# 生產環境使用 services.ai_service 中的活躍版本。
+# 此處提供簡化版僅為保持 test_prompts.py 不斷鏈。
+
 CARE_MODE_PROMPT = """你是 BloomWare 的情緒關懷助手「小花」。你的任務是傾聽、陪伴。
 
 【回應原則】
@@ -25,7 +33,9 @@ CARE_MODE_PROMPT = """你是 BloomWare 的情緒關懷助手「小花」。你
 
 def get_care_prompt(emotion: str = None, user_name: str = None) -> str:
     """
-    生成關懷模式 Prompt
+    生成關懷模式 Prompt（向後兼容）
+
+    ⚠️ DEPRECATED: 生產環境請使用 services.ai_service.get_care_mode_prompt()
 
     Args:
         emotion: 用戶情緒標籤
@@ -34,6 +44,12 @@ def get_care_prompt(emotion: str = None, user_name: str = None) -> str:
     Returns:
         關懷模式 System Prompt
     """
+    _warnings.warn(
+        "core.prompts.care_mode.get_care_prompt() is deprecated. "
+        "Use services.ai_service.get_care_mode_prompt() instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
     prompt = CARE_MODE_PROMPT
 
     if emotion:

core/prompts/care_mode_skills.py

@@ -0,0 +1,41 @@
+import os
+from pathlib import Path
+from typing import List
+
+CARE_SKILLS_ROOT = Path(__file__).resolve().parents[2] / "features" / "care_mode" / "skills"
+
+def load_care_mode_skills() -> str:
+    """
+    載入並格式化情緒關懷模式的對話技巧 (Skills)
+    """
+    if not CARE_SKILLS_ROOT.exists():
+        return ""
+    
+    skills_content = []
+    skills_content.append("\n【情緒關懷對話技巧 (Care Mode Skills)】")
+    skills_content.append("在關懷模式下，請靈活運用以下專業對話技巧來提升共鳴感：")
+    
+    try:
+        # 獲取所有 .md 檔案
+        skill_files = list(CARE_SKILLS_ROOT.glob("*.md"))
+        
+        for file_path in skill_files:
+            content = file_path.read_text(encoding="utf-8")
+            # 移除 Frontmatter (--- ... ---)
+            if content.startswith("---"):
+                parts = content.split("---", 2)
+                if len(parts) >= 3:
+                    content = parts[2].strip()
+            
+            skills_content.append(f"\n--- {file_path.stem} ---\n{content}")
+            
+        return "\n".join(skills_content)
+    except Exception as e:
+        print(f"載入關懷模式技巧失敗: {e}")
+        return ""
+
+def get_care_mode_skills_block() -> str:
+    """
+    獲取用於 System Prompt 的技巧區塊
+    """
+    return load_care_mode_skills()

core/prompts/intent_detection.py

@@ -1,9 +1,15 @@
 """
 意圖檢測 Prompt 模板
-精簡化設計，減少 token 消耗約 40%
+⚠️ DEPRECATED: 此模組的 TOOL_RULES 和 get_intent_prompt() 在生產環境中未被使用。
+生產意圖偵測由 features/mcp/agent_bridge.py 的 _build_function_calling_prompt() 處理。
+本模組僅保留向後兼容的定義，供既有測試使用。
 """
 
-# 工具特定規則（按需載入）
+import warnings as _warnings
+
+from core.prompts.tool_calling_policy import get_tool_calling_policy
+
+# ── 工具特定規則（DEPRECATED — 生產中由 agent_bridge 硬編碼處理） ──
 TOOL_RULES = {
     "weather": """天氣查詢：城市必須用英文（台北→Taipei, 高雄→Kaohsiung），預設 Taipei""",
 
@@ -32,7 +38,7 @@ TOOL_RULES = {
 「怎麼去 X」→ forward_geocode:query=X""",
 }
 
-# 情緒標籤說明
+# ── 情緒標籤說明 ──
 EMOTION_RULES = """情緒判斷：neutral/happy/sad/angry/fear/surprise
 - happy: 開心、興奮（「好開心！」「太棒了」）
 - sad: 難過、沮喪（「好難過」「心情不好」）
@@ -44,7 +50,10 @@ EMOTION_RULES = """情緒判斷：neutral/happy/sad/angry/fear/surprise
 
 def get_intent_prompt(tools_description: str, include_rules: list = None) -> str:
     """
-    生成意圖檢測 Prompt
+    生成意圖檢測 Prompt（向後兼容）
+
+    ⚠️ DEPRECATED: 生產環境使用 features/mcp/agent_bridge.py 的
+    _build_function_calling_prompt() + OpenAI Function Calling。
 
     Args:
         tools_description: 可用工具描述
@@ -53,9 +62,17 @@ def get_intent_prompt(tools_description: str, include_rules: list = None) -> str
     Returns:
         精簡化的 System Prompt
     """
+    _warnings.warn(
+        "core.prompts.intent_detection.get_intent_prompt() is deprecated. "
+        "Production intent detection uses MCPAgentBridge._build_function_calling_prompt().",
+        DeprecationWarning,
+        stacklevel=2,
+    )
     # 基礎 Prompt
     base = f"""你是意圖解析助手。分析用戶消息，決定是否調用工具。
 
+{get_tool_calling_policy()}
+
 可用工具：
 {tools_description}
 

core/prompts/tool_calling_policy.py

@@ -0,0 +1,18 @@
+"""Shared policy text for tool-calling agents."""
+
+
+TOOL_CALLING_POLICY = """【鐵血工具調用政策】
+1. 反幻覺：只要問題需要最新、精確、外部、檔案、位置、時間、健康、交通、天氣、新聞、匯率或其他工具可驗證資訊，必須優先調用工具；不得憑印象補答案。
+2. 環境優先：選工具前先把系統注入的時間、位置、使用者設定、狀態視為第一決策依據；若使用者說「附近」「這裡」「我這邊」「現在」，不要編造 city/lat/lon，留空交給系統環境注入。
+3. 參數紀律：只填使用者明確提供或可無歧義轉換的參數；可選參數不確定時留空，讓工具 schema default 或環境注入處理。
+4. 工具失敗：不得假裝成功；若工具回錯、缺資料或參數不足，只能修正參數重試、改用可用降級資訊，或明確說明不足。
+5. 證據約束：工具結果回來後，回答只能依據工具結果、已驗證上下文與系統環境；禁止新增未查證事實。
+6. 純聊天例外：只有問候、純情緒陪伴、閒聊、或詢問能力說明可以不調工具。
+7. 信心閘門：只有當工具選擇信心度至少 90% 時才允許工具調用；低於 90% 必須視為沒有可用工具，並請使用者補充地點、時間、路線、幣別、檔名或關鍵字。
+8. 語言一致：使用者用什麼語言互動，就必須用同一種語言回覆；工具卡片與錯誤說明也應跟隨使用者語言。
+"""
+
+
+def get_tool_calling_policy() -> str:
+    """Return the shared non-negotiable tool-calling policy."""
+    return TOOL_CALLING_POLICY

core/reasoning_strategy.py

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

core/responses_runtime.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+from core.environment.context_builder import EnvironmentInjection
+
+
+@dataclass
+class ResponsesRuntimeRequest:
+    user_input: str
+    model: str
+    instructions: Optional[str] = None
+    environment: Optional[EnvironmentInjection] = None
+    tools: List[Dict[str, Any]] = field(default_factory=list)
+    input_items: Optional[List[Dict[str, Any]]] = None
+    previous_response_id: Optional[str] = None
+    reasoning_effort: Optional[str] = None
+    max_output_tokens: Optional[int] = None
+    text_format: Optional[Dict[str, Any]] = None
+    tool_choice: Any = "auto"
+
+
+class ResponsesAgentRuntime:
+    """
+    新版主 Agent runtime 骨架。
+
+    目前先負責：
+    1. 統一組裝 Responses API payload
+    2. 固定附帶 environment injection
+    3. 為 hosted tools / bridge tools 預留同一個組裝入口
+    """
+
+    def build_request_payload(self, request: ResponsesRuntimeRequest) -> Dict[str, Any]:
+        input_parts: List[Dict[str, Any]] = list(request.input_items or [])
+
+        if request.environment:
+            input_parts.insert(
+                0,
+                {
+                    "role": "system",
+                    "content": [
+                        {
+                            "type": "input_text",
+                            "text": "Latest environment context:\n" + request.environment.summary_text,
+                        }
+                    ],
+                }
+            )
+
+        input_parts.append(
+            self.message_to_input_item({"role": "user", "content": request.user_input})
+        )
+
+        payload: Dict[str, Any] = {
+            "model": request.model,
+            "input": input_parts,
+            "tools": self.normalize_tools_for_responses(request.tools),
+        }
+
+        if request.instructions:
+            payload["instructions"] = request.instructions
+        if request.previous_response_id:
+            payload["previous_response_id"] = request.previous_response_id
+        if request.reasoning_effort:
+            payload["reasoning"] = {"effort": request.reasoning_effort}
+        if request.max_output_tokens:
+            payload["max_output_tokens"] = request.max_output_tokens
+        if request.text_format:
+            payload["text"] = {"format": request.text_format}
+        if request.tools:
+            payload["tool_choice"] = request.tool_choice
+
+        return payload
+
+    def build_payload_from_messages(
+        self,
+        *,
+        messages: List[Dict[str, Any]],
+        model: str,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        reasoning_effort: Optional[str] = None,
+        max_output_tokens: Optional[int] = None,
+        tool_choice: Any = "auto",
+        text_format: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        input_items: List[Dict[str, Any]] = []
+        instructions: Optional[str] = None
+
+        for message in messages:
+            if message.get("role") == "system":
+                content = message.get("content") or ""
+                instructions = f"{instructions}\n\n{content}" if instructions else str(content)
+                continue
+            input_items.append(self.message_to_input_item(message))
+
+        payload: Dict[str, Any] = {
+            "model": model,
+            "input": input_items,
+            "tools": self.normalize_tools_for_responses(tools or []),
+        }
+        if instructions:
+            payload["instructions"] = instructions
+        if reasoning_effort:
+            payload["reasoning"] = {"effort": reasoning_effort}
+        if max_output_tokens:
+            payload["max_output_tokens"] = max_output_tokens
+        if text_format:
+            payload["text"] = {"format": text_format}
+        if tools:
+            payload["tool_choice"] = tool_choice
+        return payload
+
+    @staticmethod
+    def without_hosted_tools(payload: Dict[str, Any]) -> Dict[str, Any]:
+        stripped = dict(payload)
+        tools = [
+            tool for tool in stripped.get("tools", [])
+            if tool.get("type") == "function"
+        ]
+        stripped["tools"] = tools
+        if not tools:
+            stripped.pop("tool_choice", None)
+        return stripped
+
+    @staticmethod
+    def message_to_input_item(message: Dict[str, Any]) -> Dict[str, Any]:
+        role = message.get("role") or "user"
+        content = message.get("content") or ""
+        if isinstance(content, list):
+            return {"role": role, "content": [ResponsesAgentRuntime.normalize_content_part(part, role) for part in content]}
+        content_type = "output_text" if role == "assistant" else "input_text"
+        return {"role": role, "content": [{"type": content_type, "text": str(content)}]}
+
+    @staticmethod
+    def normalize_content_part(part: Dict[str, Any], role: str) -> Dict[str, Any]:
+        part_type = part.get("type")
+        if part_type == "text":
+            return {
+                "type": "output_text" if role == "assistant" else "input_text",
+                "text": str(part.get("text", "")),
+            }
+        if part_type == "image_url":
+            image_url = part.get("image_url") or {}
+            return {
+                "type": "input_image",
+                "image_url": image_url.get("url", image_url if isinstance(image_url, str) else ""),
+            }
+        return dict(part)
+
+    @staticmethod
+    def normalize_tools_for_responses(tools: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        normalized: List[Dict[str, Any]] = []
+        for tool in tools:
+            if tool.get("type") != "function" or "function" not in tool:
+                normalized.append(dict(tool))
+                continue
+
+            fn = tool.get("function") or {}
+            converted = {
+                "type": "function",
+                "name": fn.get("name"),
+                "description": fn.get("description", ""),
+                "parameters": fn.get("parameters", {"type": "object", "properties": {}}),
+            }
+            if "strict" in fn:
+                converted["strict"] = fn["strict"]
+            normalized.append(converted)
+        return normalized
+
+    @staticmethod
+    def extract_output_text(response: Any) -> str:
+        text = getattr(response, "output_text", None)
+        if isinstance(text, str) and text.strip():
+            return text.strip()
+
+        parts: List[str] = []
+        for item in getattr(response, "output", []) or []:
+            item_type = getattr(item, "type", None)
+            if item_type != "message":
+                continue
+            for content in getattr(item, "content", []) or []:
+                content_text = getattr(content, "text", None)
+                if content_text:
+                    parts.append(str(content_text))
+        return "\n".join(parts).strip()
+
+    @staticmethod
+    def extract_function_calls(response: Any) -> List[Dict[str, Any]]:
+        calls: List[Dict[str, Any]] = []
+        for item in getattr(response, "output", []) or []:
+            if getattr(item, "type", None) != "function_call":
+                continue
+            calls.append(
+                {
+                    "id": getattr(item, "call_id", None) or getattr(item, "id", None),
+                    "type": "function",
+                    "function": {
+                        "name": getattr(item, "name", ""),
+                        "arguments": getattr(item, "arguments", "{}") or "{}",
+                    },
+                }
+            )
+        return calls
+
+    @staticmethod
+    def decode_arguments(arguments: str) -> Dict[str, Any]:
+        try:
+            return json.loads(arguments or "{}")
+        except json.JSONDecodeError:
+            return {}

core/tool_registry.py

@@ -6,6 +6,7 @@
 重構版本：整合 Pydantic Schema 自動生成
 """
 
+import inspect
 from typing import Dict, List, Any, Optional, Callable, Type
 from dataclasses import dataclass, field
 
@@ -18,6 +19,7 @@ from core.tool_schema import (
     extract_schema_from_mcp_tool,
 )
 
+from features.mcp.tools.base_tool import MCPTool
 logger = get_logger("core.tool_registry")
 
 
@@ -246,35 +248,45 @@ def register_mcp_tools_to_registry(mcp_server) -> int:
     count = 0
 
     for tool_name, tool in mcp_server.tools.items():
-        # 優先嘗試從 MCPTool 類別提取完整 Schema
+        # 1. 嘗試獲取工具類別
+        tool_class = None
         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
+            tool_class = type(tool.handler.__self__)
+        elif hasattr(tool, 'handler') and hasattr(tool.handler, '__closure__') and tool.handler.__closure__:
+            # 嘗試從閉包中找 (例如 classmethod_wrapper or instance_wrapper)
+            for cell in tool.handler.__closure__:
+                try:
+                    contents = cell.cell_contents
+                    # 檢查是否為 MCPTool 類別或實例 (使用鴨子類型，避免模組導入路徑不一致問題)
+                    if inspect.isclass(contents) and hasattr(contents, 'get_input_schema') and hasattr(contents, 'NAME'):
+                        tool_class = contents
+                        break
+                    elif not inspect.isclass(contents) and hasattr(contents, 'get_input_schema') and hasattr(contents, 'NAME'):
+                        tool_class = type(contents)
+                        break
+                except:
+                    continue
+        
+        # 2. 如果能找到類別，使用 register_mcp_tool (這會處理 rich description)
+        if tool_class and tool_registry.register_mcp_tool(tool_class):
+            count += 1
+            continue
         
-        # 降級：使用舊方法註冊
+        # 3. 降級：手動提取並註冊
         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}")
-
-        # 提取關鍵字和範例
+        parameters = getattr(tool, 'inputSchema', {"type": "object", "properties": {}, "required": []})
+        output_schema = getattr(tool, 'outputSchema', None)
+        
+        # 嘗試從 handler 閉包中找 tool_class (如果有的話)
+        # 或者從 tool.metadata 找
         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)
+        if hasattr(tool, 'metadata') and tool.metadata:
+            keywords = tool.metadata.get('keywords', [])
+            examples = tool.metadata.get('usage_tips', []) or tool.metadata.get('examples', [])
+            category = tool.metadata.get('category', 'general')
+        else:
+            category = _infer_category(tool_name)
 
         # 判斷是否需要位置
         requires_location = _requires_location(tool_name, parameters)

core/tool_router.py

@@ -28,15 +28,16 @@ class ToolRouter:
     
     # 分類關鍵字映射
     CATEGORY_KEYWORDS = {
-        "weather": ["天氣", "氣溫", "下雨", "晴天", "陰天", "weather", "溫度", "濕度"],
+        "weather": ["天氣", "氣溫", "下雨", "晴天", "陰天", "weather", "溫度", "濕度", "天気", "雨", "気温"],
         "transportation": [
             "公車", "巴士", "bus", "火車", "台鐵", "高鐵", "捷運", "metro",
-            "youbike", "ubike", "微笑單車", "共享單車", "停車場", "停車位"
+            "youbike", "ubike", "微笑單車", "共享單車", "停車場", "停車位",
+            "バス", "電車", "地下鉄", "新幹線", "駐輪場", "駐車場"
         ],
-        "location": ["我在哪", "這是哪", "位置", "地址", "怎麼去", "導航", "路線"],
-        "information": ["新聞", "消息", "報導", "news"],
-        "finance": ["匯率", "換算", "美元", "日圓", "歐元", "currency", "exchange"],
-        "health": ["心率", "步數", "血氧", "睡眠", "健康", "運動"],
+        "location": ["我在哪", "這是哪", "位置", "地址", "怎麼去", "導航", "路線", "どこ", "現在地", "住所", "ナビ"],
+        "information": ["新聞", "消息", "報導", "news", "ニュース", "報道"],
+        "finance": ["匯率", "換算", "美元", "日圓", "歐元", "currency", "exchange", "為替", "レート", "円", "ドル"],
+        "health": ["心率", "步數", "血氧", "睡眠", "健康", "運動", "健康", "歩数", "心拍", "運動"],
     }
     
     # 時間敏感工具（深夜可能不適用）
@@ -89,6 +90,7 @@ class ToolRouter:
         logger.debug(f"🎯 檢測到的分類: {detected_categories}")
         
         # 2. 過濾工具
+        language = context.get("language")
         filtered_tools = []
         for tool in tools:
             tool_name = tool.get("function", {}).get("name", "")
@@ -106,6 +108,12 @@ class ToolRouter:
             filtered_tools.append(tool)
         
         # 3. 排序工具（相關分類優先）
+        # 如果是日語，特別提升新聞與天氣的優先級（補償關鍵字可能不全的情況）
+        if language == 'ja':
+            detected_categories.add("weather")
+            detected_categories.add("finance")
+            detected_categories.add("information")
+
         sorted_tools = self._sort_tools(filtered_tools, detected_categories, context)
         
         # 4. 限制工具數量（減少 token 消耗）
@@ -114,7 +122,7 @@ class ToolRouter:
             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]}")
+        logger.info(f"🔧 過濾後工具: {[t['function']['name'] for t in sorted_tools]} (用戶語系: {language})")
         return sorted_tools
     
     def _detect_categories(self, message: str) -> Set[str]:
@@ -234,11 +242,11 @@ class ToolRouter:
             return 20
         
         if len(detected_categories) == 1:
-            # 單一分類，但仍需要保留足夠工具（如 directions）
-            return 12
+            # 單一分類，只需保留核心工具，顯著減少 LLM 負擔
+            return 6
         
-        # 多個分類
-        return 15
+        # 多個分類，保持在較小範圍
+        return 10
     
     def record_tool_usage(self, user_id: str, tool_name: str) -> None:
         """記錄工具使用（用於優先級調整）"""

core/tool_schema.py

@@ -5,10 +5,11 @@ Pydantic 工具 Schema 定義
 功能：
 1. 工具輸入/輸出的 Pydantic 基礎類別
 2. 自動生成 OpenAI tools 格式的 JSON Schema
-3. 支援 strict mode 確保 100% 有效輸出
+3. 支援 provider strict mode 確保工具參數結構穩定
 4. 裝飾器模式自動註冊工具
 """
 
+from copy import deepcopy
 from typing import Dict, Any, Optional, List, Callable, Type, TypeVar, get_type_hints
 from dataclasses import dataclass, field
 from functools import wraps
@@ -54,7 +55,7 @@ class ToolSchema:
         轉換為 OpenAI Function Calling 格式
         
         Args:
-            strict: 是否啟用 strict mode（確保輸出符合 schema）
+        strict: 是否啟用 provider strict mode（約束工具參數 schema）
         
         Returns:
             OpenAI tools 格式的字典
@@ -110,32 +111,74 @@ class ToolSchema:
         
         strict mode 要求：
         1. additionalProperties: false
-        2. 所有屬性都在 required 中（或有 default）
-        3. 不支援 oneOf/anyOf/allOf
+        2. 保留 JSON Schema required 語意
+        3. 可選欄位必須透過 default 或 nullable 型別明確表達
         """
-        result = dict(schema)
+        result = deepcopy(schema)
         
         # 確保是 object 類型
         if result.get("type") != "object":
             result = {"type": "object", "properties": result}
         
-        # 添加 additionalProperties: false
-        result["additionalProperties"] = False
-        
-        # 確保所有屬性都在 required 中
+        # Provider strict mode 要求所有 properties 都列入 required；
+        # 有 default 的欄位先保留 default，執行端仍會套用工具 schema 預設值。
+        self._apply_provider_strict_object_rules(result)
         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
+        result["required"] = list(properties.keys())
         
         return result
 
+    def _apply_provider_strict_object_rules(self, schema: Dict[str, Any]) -> None:
+        """遞迴套用 provider strict object schema 規則。"""
+        if schema.get("type") == "object":
+            schema["additionalProperties"] = False
+            properties = schema.get("properties", {})
+            if isinstance(properties, dict):
+                schema["required"] = list(properties.keys())
+                for prop_schema in properties.values():
+                    if isinstance(prop_schema, dict):
+                        self._apply_provider_strict_object_rules(prop_schema)
+
+        for key in ("items",):
+            nested = schema.get(key)
+            if isinstance(nested, dict):
+                self._apply_provider_strict_object_rules(nested)
+
+    def validate_schema_contract(self) -> List[str]:
+        """檢查 input/output schema 是否有會破壞工具調用的契約問題。"""
+        issues: List[str] = []
+        if not self.metadata.name:
+            issues.append("tool name is required")
+        if self.input_schema.get("type") != "object":
+            issues.append(f"{self.metadata.name}: input_schema.type must be object")
+
+        properties = self.input_schema.get("properties", {})
+        if not isinstance(properties, dict):
+            issues.append(f"{self.metadata.name}: input_schema.properties must be object")
+
+        required = self.input_schema.get("required", [])
+        if required and not isinstance(required, list):
+            issues.append(f"{self.metadata.name}: input_schema.required must be list")
+        for field in required:
+            if field not in properties:
+                issues.append(f"{self.metadata.name}: required field '{field}' missing from properties")
+
+        if self.output_schema is not None:
+            if self.output_schema.get("type") != "object":
+                issues.append(f"{self.metadata.name}: output_schema.type must be object")
+            output_props = self.output_schema.get("properties", {})
+            if not isinstance(output_props, dict):
+                issues.append(f"{self.metadata.name}: output_schema.properties must be object")
+
+        return issues
+
+    def contract_warnings(self) -> List[str]:
+        """回報不阻擋執行、但會降低模型選工具品質的問題。"""
+        warnings: List[str] = []
+        if not self.metadata.description:
+            warnings.append(f"{self.metadata.name}: description is empty")
+        return warnings
+
     def get_summary(self) -> Dict[str, Any]:
         """獲取工具摘要（用於快速意圖匹配）"""
         return {
@@ -185,7 +228,6 @@ def extract_schema_from_mcp_tool(tool_class: Type) -> Optional[ToolSchema]:
         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（可選）
@@ -253,6 +295,11 @@ class ToolSchemaRegistry:
     
     def register(self, schema: ToolSchema) -> None:
         """註冊工具 Schema"""
+        issues = schema.validate_schema_contract()
+        if issues:
+            raise ValueError("; ".join(issues))
+        for warning in schema.contract_warnings():
+            logger.warning(warning)
         self._schemas[schema.metadata.name] = schema
         logger.debug(f"註冊工具 Schema: {schema.metadata.name}")
     

core/voice_care_gate.py

@@ -0,0 +1,82 @@
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+
+EXTREME_EMOTIONS = {"sad", "angry", "fear"}
+VOICE_EMOTION_CONFIDENCE_THRESHOLD = 0.70
+VOICE_SPEECH_CONFIDENCE_THRESHOLD = 0.70
+
+
+@dataclass(frozen=True)
+class VoiceCareDecision:
+    allow: bool
+    emotion: str
+    confidence: float
+    reason: str
+    evidence: Dict[str, Any]
+
+
+def _to_float(value: Any, default: float = 0.0) -> float:
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def _normalize_emotion(value: Any) -> str:
+    text = str(value or "neutral").strip().lower()
+    return text if text else "neutral"
+
+
+def is_voice_context(audio_emotion: Optional[Dict[str, Any]]) -> bool:
+    if not audio_emotion:
+        return False
+    source = str(audio_emotion.get("source") or "").strip().lower()
+    return source in {"realtime_voice", "voice", "speech", "audio"}
+
+
+def decide_voice_care(
+    *,
+    text_emotion: str,
+    audio_emotion: Optional[Dict[str, Any]],
+) -> VoiceCareDecision:
+    """
+    Gate for voice-triggered care mode.
+
+    Voice emotion is allowed to trigger care mode only when the transcript-side
+    emotion agrees that the user is in the same extreme-emotion family.
+    """
+    text_value = _normalize_emotion(text_emotion)
+    audio_value = _normalize_emotion((audio_emotion or {}).get("emotion"))
+    audio_confidence = _to_float((audio_emotion or {}).get("confidence"))
+    speech_confidence_raw = (audio_emotion or {}).get("speech_confidence")
+    speech_confidence = (
+        _to_float(speech_confidence_raw)
+        if speech_confidence_raw is not None
+        else None
+    )
+    evidence = {
+        "text_emotion": text_value,
+        "audio_emotion": audio_value,
+        "audio_emotion_confidence": audio_confidence,
+        "speech_confidence": speech_confidence,
+    }
+
+    if not audio_emotion or not audio_emotion.get("success"):
+        return VoiceCareDecision(False, text_value, 0.5, "voice-audio-missing", evidence)
+
+    if speech_confidence is not None and speech_confidence < VOICE_SPEECH_CONFIDENCE_THRESHOLD:
+        return VoiceCareDecision(False, text_value, 0.5, "voice-speech-low-confidence", evidence)
+
+    if audio_confidence < VOICE_EMOTION_CONFIDENCE_THRESHOLD:
+        if text_value in EXTREME_EMOTIONS:
+            return VoiceCareDecision(True, text_value, 0.5, "voice-text-extreme-audio-low-confidence", evidence)
+        return VoiceCareDecision(False, text_value, 0.5, "voice-audio-low-confidence", evidence)
+
+    if audio_value not in EXTREME_EMOTIONS:
+        return VoiceCareDecision(False, text_value, audio_confidence, "voice-audio-not-extreme", evidence)
+
+    if text_value not in EXTREME_EMOTIONS:
+        return VoiceCareDecision(False, text_value, 0.5, "voice-text-not-extreme", evidence)
+
+    return VoiceCareDecision(True, text_value, audio_confidence, "voice-extreme-family-match", evidence)

features/care_mode/skills/ACTIVE_LISTENING.md

@@ -0,0 +1,24 @@
+---
+name: active-listening
+description: "主動傾聽技巧：透過反映與複述，讓用戶感受到被聽見與理解。"
+usage_policy:
+  mirror_feelings: true
+  reflect_content: true
+  avoid_judgement: true
+---
+
+# 主動傾聽 (Active Listening)
+
+當用戶表達情緒或分享經歷時，使用此技能來強化理解感。
+
+### 執行要點：
+1. **反映感受**：辨識並說出用戶文字背後的情緒。
+   - *例子*：「聽起來這件事讓你感到很挫折。」
+2. **複述核心**：用你自己的話簡單重述用戶提到的關鍵點，確認你的理解。
+   - *例子*：「你提到雖然努力了很久，但結果不如預期，這讓你感到很不甘心。」
+3. **鼓勵續說**：使用簡短的鼓勵詞，邀請用戶進一步宣洩。
+   - *例子*：「我在聽，你想多聊聊這部分嗎？」
+
+### 禁忌：
+- 在用戶說完前就給予建議。
+- 使用「我知道你的感受」這種空洞的話（除非你能具體說出是什麼感受）。

features/care_mode/skills/ANGER_HANDLING.md

@@ -0,0 +1,15 @@
+---
+name: anger-handling
+description: "憤怒情緒處理技巧：認可憤怒的合理性，不給予壓力。"
+usage_policy:
+  calm_empathy: true
+  validate_anger: true
+  avoid_suppression: true
+---
+
+# 憤怒情緒處理 (Anger Handling)
+
+### 執行要點：
+- **語氣**：冷靜但帶有同理、不卑不亢。
+- **重點**：認可對方的憤怒是有原因的，幫助對方感覺被理解。
+- **避免**：說「冷靜一下」、「別生氣」這類否定情緒的話。

features/care_mode/skills/CARE_CORE_STRATEGY.md

@@ -0,0 +1,26 @@
+---
+name: care-core-strategy
+description: "關懷模式核心策略：定義回應的結構與核心原則。"
+usage_policy:
+  empathy_first: true
+  companionship: true
+  open_encouragement: true
+---
+
+# 關懷模式核心策略 (Core Care Strategy)
+
+這是進行情緒關懷對話的基礎框架，必須嚴格遵守。
+
+### 核心職責：
+1. **深度同理 (Deep Empathy)**：第一句話必須精準反映用戶目前的感受或處境。
+   - *例子*：「考零分真的會很難過，這種失落我懂。」
+2. **溫柔陪伴 (Gentle Companionship)**：表達你在這裡，願意傾聽。
+   - *例子*：「我在這裡陪你。」
+3. **開放式鼓勵 (Open Encouragement)**：適度詢問細節，鼓勵用戶宣洩情緒。
+   - *例子*：「想說說發生了什麼嗎？」
+
+### 回應原則：
+- **語氣**：輕柔、自然、像好朋友。
+- **格式**：保持簡潔（約 2-3 句話），確保每句話都有溫度。
+- **禁止**：機械化回答、過度正向的毒雞湯、心理醫生式的說教。
+- **禁止**：重複使用罐頭話術。

features/care_mode/skills/EMOTIONAL_VALIDATION.md

@@ -0,0 +1,24 @@
+---
+name: emotional-validation
+description: "情感驗證技巧：認可用戶情緒的合理性，減輕其自我懷疑或羞恥感。"
+usage_policy:
+  normalize_emotions: true
+  validate_logic: true
+  show_empathy: true
+---
+
+# 情感驗證 (Emotional Validation)
+
+當用戶對自己的情緒感到懷疑、羞恥或困惑時，使用此技能。
+
+### 執行要點：
+1. **正常化情緒**：讓用戶知道在這種情況下有這種感覺是很正常的。
+   - *例子*：「換作是我，遇到這種情況也會感到生氣的。」
+2. **認可合理性**：根據對話背景，解釋為什麼用戶的情緒是合理的。
+   - *例子*：「付出了那麼多努力卻沒有回報，難過是很自然的事。」
+3. **消除孤獨感**：表達這種情緒是普遍的人類經驗。
+   - *例子*：「很多人在面對這種轉變時都會感到焦慮，你並不孤單。」
+
+### 禁忌：
+- 質疑用戶情緒的真實性。
+- 說「這沒什麼大不了的」或「別想太多」。

features/care_mode/skills/FEAR_HANDLING.md

@@ -0,0 +1,15 @@
+---
+name: fear-handling
+description: "恐懼/焦慮情緒處理技巧：提供穩定感與安全感。"
+usage_policy:
+  stable_presence: true
+  accept_fear: true
+  provide_security: true
+---
+
+# 恐懼/焦慮處理 (Fear & Anxiety Handling)
+
+### 執行要點：
+- **語氣**：穩定、溫暖、帶有安全感。
+- **重點**：讓對方感覺不孤單，恐懼是可以被接納的。
+- **避免**：說「沒什麼好怕的」、「想太多了」這類否定情緒的話。

features/care_mode/skills/FIRST_CONTACT_CARE.md

@@ -0,0 +1,21 @@
+---
+name: first-contact-care
+description: "初次關懷引導：在進入關懷模式的首個回覆中，引導用戶如何操作。"
+usage_policy:
+  conditional_execution: true
+  provide_exit_hint: true
+---
+
+# 初次關懷引導 (First Contact Care)
+
+當系統偵測到這是進入「關懷模式」的第一個回覆時（`is_first_care=True`），請執行此引導。
+
+### 執行要點：
+1. **完成溫暖回應**：首先根據用戶情緒提供深度同理與陪伴的回應。
+2. **附上退出提示**：在回覆的結尾，換行兩次後，附上以下藍色字體的提示：
+   - `💙 關懷模式已啟動。說「我沒事了」可以退出。`
+
+### 範例：
+「考零分真的會很難過，這種失落我懂。我在這裡陪你，想說說發生什麼嗎？
+
+💙 關懷模式已啟動。說「我沒事了」可以退出。」

features/care_mode/skills/SADNESS_HANDLING.md

@@ -0,0 +1,15 @@
+---
+name: sadness-handling
+description: "悲傷情緒處理技巧：提供溫柔理解，避免過度積極。"
+usage_policy:
+  gentle_tone: true
+  normalize_sadness: true
+  avoid_toxic_positivity: true
+---
+
+# 悲傷情緒處理 (Sadness Handling)
+
+### 執行要點：
+- **語氣**：溫柔、輕聲、帶有理解。
+- **重點**：陪伴而非解決問題，讓對方知道悲傷是正常的。
+- **避免**：說「不要難過」、「振作點」這類否定情緒的話。

features/care_mode/skills/SUPPORTIVE_PRESENCE.md

@@ -0,0 +1,24 @@
+---
+name: supportive-presence
+description: "支持性陪伴技巧：提供純粹的陪伴感，不急於解決問題，建立安全感。"
+usage_policy:
+  be_present: true
+  slow_down: true
+  offer_space: true
+---
+
+# 支持性陪伴 (Supportive Presence)
+
+當用戶處於情緒低谷，且尚未準備好採取行動或深入探討時，使用此技能。
+
+### 執行要點：
+1. **傳達在場**：明確表達你現在就在這裡，不會離開。
+   - *例子*：「我就在這裡陪你，不需要急著說什麼。」
+2. **減緩節奏**：給予用戶空間，不要連續追問。
+   - *例子*：「如果你累了想靜一下也可以，我會一直都在。」
+3. **無條件接納**：表達無論用戶現在狀態如何，你都能接受。
+   - *例子*：「現在不想說話也沒關係，我可以就這樣靜靜陪著你。」
+
+### 禁忌：
+- 急著提供「解決方案」或「待辦清單」。
+- 表現得像是在趕時間或想要結束對話。

features/mcp/agent_bridge.py

@@ -6,11 +6,13 @@ MCP + Agent 橋接層
 import json
 import logging
 import asyncio
+import time
 from typing import Dict, Any, Optional, List, Tuple, Callable, Awaitable
 from datetime import datetime
 from .server import FeaturesMCPServer
 import services.ai_service as ai_service
 from services.ai_service import StrictResponseError
+from core.prompts.tool_calling_policy import get_tool_calling_policy
 from core.reasoning_strategy import get_optimal_reasoning_effort
 from core.database import get_user_env_current
 from .coordinator import ToolCoordinator
@@ -105,38 +107,38 @@ class MCPAgentBridge:
                 name="weather_query",
                 requires_env={"lat", "lon", "city"},
                 env_fallbacks={"city": ["detailed_address", "label"]},
-                enable_reformat=True,
+                enable_reformat=False,
             )
         )
         register(
             ToolMetadata(
                 name="reverse_geocode",
                 requires_env={"lat", "lon"},
-                enable_reformat=True,
+                enable_reformat=False,
             )
         )
         register(
             ToolMetadata(
                 name="exchange_query",
-                enable_reformat=True,
+                enable_reformat=False,
             )
         )
         register(
             ToolMetadata(
                 name="news_query",
-                enable_reformat=True,
+                enable_reformat=False,
             )
         )
         register(
             ToolMetadata(
                 name="healthkit_query",
-                enable_reformat=True,
+                enable_reformat=False,
             )
         )
         register(
             ToolMetadata(
                 name="directions",
-                enable_reformat=True,
+                enable_reformat=False,
             )
         )
         register(
@@ -223,68 +225,12 @@ class MCPAgentBridge:
             logger.info(f"異步初始化完成，完整可用 MCP 工具數量: {len(self.mcp_server.tools)}")
 
         # 將 MCP Server 的工具註冊到 tool_registry
-        self._sync_tools_to_registry()
+        from core.tool_registry import register_mcp_tools_to_registry
+        register_mcp_tools_to_registry(self.mcp_server)
 
         # 快取預熱已移除：啟動時連續調用 7 次 GPT API 增加延遲和成本
         # 實際使用中快取會自然累積，無需預熱
 
-    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]:
         """
@@ -444,92 +390,28 @@ class MCPAgentBridge:
             "tool_data": fallback_payload,
         }
 
-    def get_current_time_data(self) -> Dict[str, Any]:
+    async def detect_intent(self, message: str, tool_context: str = "", language: Optional[str] = None) -> Tuple[bool, Optional[Dict[str, Any]]]:
         """
-        獲取當前時間數據，用於生成個性化歡迎詞
-        返回格式與舊 time_service 兼容
-        """
-        now = datetime.now()
-
-        # 獲取時間段
-        hour = now.hour
-        if 5 <= hour < 12:
-            day_period = "上午"
-        elif 12 <= hour < 18:
-            day_period = "下午"
-        elif 18 <= hour < 22:
-            day_period = "晚上"
-        else:
-            day_period = "深夜" if hour >= 22 else "凌晨"
-
-        # 星期幾中文名稱
-        weekdays = ["星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"]
-        weekday_full_chinese = weekdays[now.weekday()]
-
-        return {
-            "year": now.year,
-            "month": now.month,
-            "day": now.day,
-            "hour": hour,
-            "minute": now.minute,
-            "second": now.second,
-            "weekday": now.weekday(),  # 0-6, 星期一到星期日
-            "weekday_full_chinese": weekday_full_chinese,
-            "day_period": day_period,
-            "timestamp": now.timestamp(),
-            "iso_format": now.isoformat()
-        }
-
-    async def detect_intent(self, message: str) -> Tuple[bool, Optional[Dict[str, Any]]]:
-        """
-        檢測用戶消息中的意圖 (保持與舊 FeatureRouter 相同介面)
-        
-        2025 重構版：使用 OpenAI 原生 Function Calling
-        - 不再使用巨大的 system_prompt 描述每個工具
-        - 工具定義由 tools 參數傳遞，GPT 原生選擇
-        - 新增工具只需註冊到 Registry，不需更新任何 prompt
-
-        參數:
-        message (str): 用戶消息
-
-        返回:
-        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 描述每個工具
+        意圖偵測（符合 2025 年最佳實踐：語言感知與快取優化）
         """
         import hashlib
-        import time as time_module
-        
-        # 生成快取鍵
-        cache_key = hashlib.md5(message.encode()).hexdigest()
+        # 將 message, tool_context 與 language 組合後計算 md5
+        cache_raw = f"{message}||{tool_context or ''}||{language or ''}"
+        cache_key = hashlib.md5(cache_raw.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:
+            if time.time() - cached_time < self._intent_cache_ttl:
                 logger.debug(f"💾 意圖快取命中: {message[:50]}...")
-
-                # 【關鍵修復】快取命中時，仍需重新偵測情緒（情緒是即時的）
-                # 因為同一句話在不同時間說可能帶有不同的情緒強度
                 try:
                     fresh_emotion = await self._analyze_emotion_from_message(message)
                     if fresh_emotion and intent_data:
-                        intent_data = dict(intent_data)  # 複製避免修改原快取
+                        intent_data = dict(intent_data)
                         intent_data['emotion'] = fresh_emotion
                         logger.info(f"🎭 快取命中但重新偵測情緒: {fresh_emotion}")
                 except Exception as e:
                     logger.warning(f"快取命中時情緒分析失敗: {e}")
-
                 return has_feature, intent_data
             else:
                 del self._intent_cache[cache_key]
@@ -543,7 +425,6 @@ class MCPAgentBridge:
                 return True, {"type": "special_command", "command": "feature_list"}
 
         try:
-            # 從 tool_registry 取得 OpenAI tools 格式
             from core.tool_registry import tool_registry
             from core.tool_router import tool_router
             
@@ -553,39 +434,51 @@ class MCPAgentBridge:
                 logger.warning("⚠️ 沒有可用的工具，降級為聊天")
                 return False, {"emotion": "neutral"}
             
-            # 使用 ToolRouter 動態過濾和排序工具
-            context = {"hour": datetime.now().hour}
-            tools = tool_router.filter_tools(all_tools, message, context)
+            router_context = {
+                "hour": datetime.now().hour,
+                "language": language
+            }
+            tools = tool_router.filter_tools(all_tools, message, router_context)
+            
+            logger.info(f"🔧 載入 {len(all_tools)} 個工具，過濾後 {len(tools)} 個 (語言: {language})")
             
-            logger.info(f"🔧 載入 {len(all_tools)} 個工具，過濾後 {len(tools)} 個")
+            system_prompt = self._build_function_calling_prompt(language)
             
-            # 建構精簡的 system prompt（只處理特殊規則）
-            system_prompt = self._build_function_calling_prompt()
+            if tool_context:
+                system_prompt += f"\n\n【已執行的工具結果與上下文】\n請根據以下資訊判斷是否足夠回答用戶，若不足則繼續調用工具：\n{tool_context}"
             
             messages = [
                 {"role": "system", "content": system_prompt},
                 {"role": "user", "content": message}
             ]
             
-            # 使用 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}")
             
+            emotion_task = asyncio.create_task(self._analyze_emotion_from_message(message))
+
             response = await ai_service.generate_response_with_tools(
                 messages=messages,
                 tools=tools,
                 user_id="intent_detection",
-                model="gpt-4o-mini",  # 使用更強的模型以提升參數提取準確度
-                reasoning_effort=None,  # gpt-4o-mini 不支援 reasoning_effort
+                model=None,
+                reasoning_effort=optimal_effort,
                 tool_choice="auto",
             )
             
-            # 解析回應
+            try:
+                parallel_emotion = await emotion_task
+            except Exception as e:
+                logger.warning(f"並行情緒分析失敗: {e}")
+                parallel_emotion = "neutral"
+            finally:
+                if not emotion_task.done():
+                    emotion_task.cancel()
+            
             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", "")
@@ -596,7 +489,6 @@ class MCPAgentBridge:
                 except json.JSONDecodeError:
                     arguments = {}
                 
-                # 正規化工具名稱
                 normalized_name = self._normalize_tool_name(tool_name)
                 if not normalized_name:
                     logger.warning(f"⚠️ 工具 {tool_name} 無法對應到註冊名稱，降級為聊天")
@@ -605,38 +497,36 @@ class MCPAgentBridge:
                 logger.info(f"✅ GPT 選擇工具: {normalized_name}")
                 logger.debug(f"工具參數: {_safe_json(arguments)}")
 
-                # 提取情緒（從 content 或直接從用戶訊息分析）
                 content = response.get("content", "")
                 if content:
                     emotion = self._extract_emotion_from_content(content)
                 else:
-                    # 當 GPT 只回傳 tool_calls 時，直接從用戶訊息分析情緒
-                    logger.debug(f"🔍 GPT content 為空，從用戶訊息分析情緒")
-                    emotion = await self._analyze_emotion_from_message(message)
+                    logger.debug(f"🔍 使用並行情緒分析結果: {parallel_emotion}")
+                    emotion = parallel_emotion
+
+                confidence = self._calculate_tool_confidence(normalized_name, arguments)
 
                 intent_result = (True, {
                     "type": "mcp_tool",
                     "tool_name": normalized_name,
                     "arguments": arguments,
                     "emotion": emotion,
+                    "confidence": confidence,
                 })
                 
-                # 寫入快取
-                self._intent_cache[cache_key] = (*intent_result, time_module.time())
+                self._intent_cache[cache_key] = (*intent_result, time.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())
+                self._intent_cache[cache_key] = (*intent_result, time.time())
                 return intent_result
                 
         except Exception as e:
             logger.error(f"❌ Function Calling 意圖檢測失敗: {e}")
-            # 降級：使用關鍵詞匹配
             logger.info("🔄 嘗試使用關鍵詞匹配作為降級方案")
             try:
                 fallback_result = self._keyword_intent_detection(message)
@@ -646,20 +536,60 @@ class MCPAgentBridge:
             except Exception as fallback_error:
                 logger.error(f"❌ 關鍵詞匹配也失敗: {fallback_error}")
         
-        # 最終降級：視為一般聊天
         logger.info("💬 降級為一般聊天")
         return False, {"emotion": "neutral"}
 
-    def _build_function_calling_prompt(self) -> str:
+    def get_current_time_data(self) -> Dict[str, Any]:
         """
-        建構精簡的 Function Calling system prompt
-        
-        注意：不再描述每個工具，工具定義由 tools 參數傳遞
-        只處理特殊規則和情緒判斷
+        獲取當前時間數據，用於生成個性化歡迎詞
+        返回格式與舊 time_service 兼容
         """
-        return """You are an intelligent assistant that selects appropriate tools based on user needs.
+        now = datetime.now()
+
+        # 獲取時間段
+        hour = now.hour
+        if 5 <= hour < 12:
+            day_period = "上午"
+        elif 12 <= hour < 18:
+            day_period = "下午"
+        elif 18 <= hour < 22:
+            day_period = "晚上"
+        else:
+            day_period = "深夜" if hour >= 22 else "凌晨"
+
+        # 星期幾中文名稱
+        weekdays = ["星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"]
+        weekday_full_chinese = weekdays[now.weekday()]
+
+        return {
+            "year": now.year,
+            "month": now.month,
+            "day": now.day,
+            "hour": hour,
+            "minute": now.minute,
+            "second": now.second,
+            "weekday": now.weekday(),  # 0-6, 星期一到星期日
+            "weekday_full_chinese": weekday_full_chinese,
+            "day_period": day_period,
+            "timestamp": now.timestamp(),
+            "iso_format": now.isoformat()
+        }
 
-Rules:
+    def _build_function_calling_prompt(self, language: Optional[str] = None) -> str:
+        """
+        建構精簡的 Function Calling system prompt
+        """
+        from core.prompts.tool_calling_policy import get_tool_calling_policy
+        policy = get_tool_calling_policy()
+        
+        # 根據語系決定基礎提示詞語言
+        lang_context = f"目前的用戶語言是：{language or 'zh (繁體中文)'}"
+        
+        return (
+            f"You are an intelligent assistant. {lang_context}\n\n"
+            + policy
+            + "\n\n"
+            + """Rules:
 1. If the user's request can be solved with a tool, select the most appropriate tool
 2. Only skip tool selection for pure greetings (hi, hello) or meta questions (what can you do)
 3. Extract tool parameters from user message
@@ -676,116 +606,18 @@ Rules:
 
 【重要】語言使用規範：
 - 調用工具時：所有參數必須使用英文（城市名、國家名、貨幣代碼等）
-- 範例：用戶說「台北天氣」或 "Taipei weather" → 參數 {"city": "Taipei"}
+- 範例：用戶說「台北天氣」或 "Taipei weather" 或 "東京の天気" → 參數 {"city": "Taipei"} 或 {"city": "Tokyo"}
 
 參數語言轉換規則：
-- 城市名稱：台北→Taipei, 新北→NewTaipei, 桃園→Taoyuan, 台中→Taichung, 台南→Tainan, 高雄→Kaohsiung, 新竹→Hsinchu
+- 城市名稱：台北→Taipei, 新北→NewTaipei, 桃園→Taoyuan, 台中→Taichung, 台南→Tainan, 高雄→Kaohsiung, 新竹→Hsinchu, 東京→Tokyo, 大阪→Osaka, 京都→Kyoto
 - 國家名稱：台灣→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 參數！站名可保持中文！
+- 貨幣代碼：美元→USD, 台幣→TWD, 日圓/円→JPY, 歐元→EUR, 英鎊→GBP
+
+【Answerability Check - Confidence-Driven Agent Loop】
+1. Evaluate provided "tool_context" (if any) against the user's request.
+2. If tool_context contains sufficient information to answer the user with ~100% confidence, do NOT call any more tools.
+3. If information is missing, inconsistent, or outdated, select the appropriate tool to gather more evidence (work_again).
+4. If the user's question is "Can you find X and then Y?", you must first find X, evaluate its result, then in the next turn find Y based on X.
 
 【情緒偵測】（重要！）：
 - 分析用戶的情緒狀態（根據用詞、語氣、標點符號、表情符號）
@@ -799,6 +631,38 @@ YouBike 查詢（重要！參數提取規則）：
   * 用戶說「哇！」→ 回應最後加上 [EMOTION:surprise]
   * 一般對話 → 回應最後加上 [EMOTION:neutral]
 """
+        )
+
+    def _calculate_tool_confidence(self, tool_name: str, arguments: Dict[str, Any]) -> float:
+        """根據工具所需參數動態計算信心度"""
+        if not tool_name:
+            return 0.0
+
+        try:
+            from core.tool_registry import tool_registry
+            tool_def = tool_registry.get_tool(tool_name)
+            
+            # 如果找不到工具定義，或者該工具沒有 parameters
+            if not tool_def or not tool_def.parameters:
+                return 0.95 if arguments else 0.92
+
+            required_params = tool_def.parameters.get("required", [])
+            
+            if not required_params:
+                return 1.0  # 不需要任何參數，直接給最高信心度
+                
+            # 檢查缺少的必填參數數量
+            missing_count = sum(1 for req in required_params if req not in arguments or arguments[req] is None or str(arguments[req]).strip() == "")
+            
+            if missing_count == 0:
+                return 1.0
+                
+            # 每缺少一個必填參數，扣除一定比例的信心度（確保其低於 MIN_TOOL_CONFIDENCE 0.90）
+            return max(0.0, 0.95 - (missing_count * 0.5))
+        except Exception as e:
+            logger.warning(f"⚠️ 計算工具信心度失敗: {e}")
+            return 0.95 if arguments else 0.92
+
 
     def _extract_emotion_from_content(self, content: str) -> str:
         """從回應內容中提取情緒標籤 [EMOTION:xxx]"""
@@ -830,9 +694,18 @@ YouBike 查詢（重要！參數提取規則）：
             import services.ai_service as ai_service
 
             system_prompt = (
-                "分析用戶訊息的情緒狀態。\n"
-                "情緒類型：neutral（平靜）、happy（開心）、sad（難過）、angry（生氣）、fear（害怕）、surprise（驚訝）\n"
-                "只回傳情緒類型的英文單字，不要有任何其他文字。"
+                "## 任務：純粹情緒分類\n"
+                "你是一個專業的情緒分析員。請分析用戶訊息的情緒狀態，並僅從以下列表中選擇一個最符合的標籤：\n"
+                "- neutral（平靜/詢問資訊）\n"
+                "- happy（開心/興奮）\n"
+                "- sad（難過/沮喪）\n"
+                "- angry（生氣/不滿）\n"
+                "- fear（害怕/焦慮）\n"
+                "- surprise（驚訝/震撼）\n\n"
+                "## 規則：\n"
+                "1. **絕對不要回答用戶的問題**（例如用戶問股價，你絕對不能回答數字）。\n"
+                "2. **只能回傳單個英文標籤**，不要有任何解釋或標點符號。\n"
+                "3. 如果訊息是中性的事實詢問，請回傳 neutral。"
             )
 
             messages = [
@@ -842,7 +715,7 @@ YouBike 查詢（重要！參數提取規則）：
 
             emotion = await ai_service.generate_response_async(
                 messages=messages,
-                model="gpt-4o-mini",
+                model=None,
                 max_tokens=10,
             )
 
@@ -991,29 +864,35 @@ YouBike 查詢（重要！參數提取規則）：
             import re
             city_match = re.search(r'([^\s，。！？]+)\s*天氣', message)
             city = city_match.group(1) if city_match else "台北"
+            args = {"city": city}
 
             return True, {
                 "type": "mcp_tool",
                 "tool_name": "weather_query",
-                "arguments": {"city": city}
+                "arguments": args,
+                "confidence": self._calculate_tool_confidence("weather_query", args)
             }
 
         # 新聞檢測
         news_keywords = ["新聞", "消息", "報導", "news"]
         if any(kw in message_lower for kw in news_keywords):
+            args = {"language": "zh-TW", "limit": 5}
             return True, {
                 "type": "mcp_tool",
                 "tool_name": "news_query",
-                "arguments": {"language": "zh-TW", "limit": 5}
+                "arguments": args,
+                "confidence": self._calculate_tool_confidence("news_query", args)
             }
 
         # 匯率檢測
         exchange_keywords = ["匯率", "美元", "台幣", "exchange", "usd", "twd"]
         if any(kw in message_lower for kw in exchange_keywords):
+            args = {"from_currency": "USD", "to_currency": "TWD"}
             return True, {
                 "type": "mcp_tool",
                 "tool_name": "exchange_query",
-                "arguments": {"from_currency": "USD", "to_currency": "TWD"}
+                "arguments": args,
+                "confidence": self._calculate_tool_confidence("exchange_query", args)
             }
 
         return False, None
@@ -1213,6 +1092,9 @@ YouBike 查詢（重要！參數提取規則）：
                 "⭐ 分析使用者的核心意圖（問溫度？天氣？時間？地點？數量？）\n"
                 "⭐ 從工具數據中只提取相關資訊，無關資訊一���省略\n"
                 "⭐ **注意：用什麼語言提問，就用什麼語言回答**（日文問→日文答，英文問→英文答）\n\n"
+                "【反幻覺與安全原則】\n"
+                "🚨 嚴禁推測：如果工具返回的資料缺漏，必須誠實告知用戶，絕對不能自己憑空捏造數字或事實\n"
+                "🚨 不得把工具錯誤包裝成成功結果：如果工具返回錯誤或查無資料，不能說「我查到了」\n\n"
                 "【回應要求】\n"
                 "1. 使用口語化、親切的語氣（可以用「喔」「呢」「哦」等語氣詞）\n"
                 "2. 不要列表式的羅列數據，而是用對話方式描述\n"
@@ -1243,13 +1125,16 @@ YouBike 查詢（重要！參數提取規則）：
                 {"role": "user", "content": user_prompt}
             ]
 
-            # 格式化回應使用 gpt-4o-mini（支援多語言，不需 reasoning_effort）
-            response = await ai_service.generate_response_for_user(
+            # 格式化回應使用環境變數設定的模型
+            model = settings.GPT_INTENT_MODEL or settings.OPENAI_MODEL
+            logger.info(f"🎨 使用配置模型進行格式化: {model}")
+            
+            response = await ai_service.generate_response_with_tools(
                 messages=messages,
-                user_id="format_response",
-                model="gpt-4o-mini",  # 升級到 gpt-4o-mini 以支援多語言
-                chat_id=None,
-                reasoning_effort=None  # gpt-4o-mini 不支援此參數
+                tools=None,
+                user_id="reformatting",
+                model=model,
+                reasoning_effort=None,
             )
 
             return response

features/mcp/auto_registry.py

@@ -54,14 +54,17 @@ class MCPAutoRegistry:
 
             logger.info(f"掃描工具目錄: {tools_path}")
 
-            # 掃描所有 Python 文件（包含 *_tool.py 和 tdx_*.py）
-            tool_files = list(tools_path.glob("*_tool.py")) + list(tools_path.glob("tdx_*.py"))
-            # 去重（避免 tdx_*_tool.py 被掃描兩次）
-            tool_files = list(set(tool_files))
+            # 掃描所有 Python 文件
+            tool_files = list(tools_path.rglob("*.py"))
             
             for py_file in tool_files:
+                if py_file.name == "__init__.py" or py_file.name == "base_tool.py" or py_file.name == "tdx_base.py":
+                    continue
+                    
                 tool_name = py_file.stem
-                module_name = f"{tools_dir}.{tool_name}"
+                rel_path = py_file.relative_to(tools_path)
+                module_parts = list(rel_path.parts[:-1]) + [tool_name]
+                module_name = f"{tools_dir}.{'.'.join(module_parts)}"
 
                 try:
                     # 動態導入模組
@@ -175,7 +178,8 @@ class MCPAutoRegistry:
                 description=definition["description"],
                 inputSchema=definition["inputSchema"],
                 handler=handler,
-                metadata=definition.get("metadata", {})
+                metadata=definition.get("metadata", {}),
+                outputSchema=definition.get("outputSchema")
             )
 
             return tool
@@ -198,7 +202,8 @@ class MCPAutoRegistry:
                     description=definition["description"],
                     inputSchema=definition["inputSchema"],
                     handler=handler,
-                    metadata=definition.get("metadata", {})
+                    metadata=definition.get("metadata", {}),
+                    outputSchema=definition.get("outputSchema")
                 )
                 return tool
             else:
@@ -211,7 +216,8 @@ class MCPAutoRegistry:
                     description=definition["description"],
                     inputSchema=definition["inputSchema"],
                     handler=handler,
-                    metadata=definition.get("metadata", {})
+                    metadata=definition.get("metadata", {}),
+                    outputSchema=definition.get("outputSchema")
                 )
                 return tool
 
@@ -293,7 +299,17 @@ class MCPAutoRegistry:
                 description=description,
                 inputSchema=input_schema,
                 handler=placeholder_handler,
-                metadata=metadata
+                metadata=metadata,
+                outputSchema={
+                    "type": "object",
+                    "properties": {
+                        "success": {"type": "boolean"},
+                        "content": {"type": "string"},
+                        "error": {"type": ["string", "null"]},
+                        "error_code": {"type": ["string", "null"]},
+                    },
+                    "required": ["success"],
+                }
             )
 
             logger.info(f"創建系統工具占位符: {name}")

features/mcp/coordinator.py

@@ -1,14 +1,38 @@
 import asyncio
 import logging
+import re
 from typing import Any, Awaitable, Callable, Dict, Optional
 
 from .tool_models import ToolMetadata, ToolResult
 
+try:
+    import jsonschema
+except ImportError:
+    jsonschema = None
+
 logger = logging.getLogger(__name__)
 
+CITY_ALIASES = {
+    "台北市": "台北",
+    "臺北市": "臺北",
+    "新北市": "新北",
+    "桃園市": "桃園",
+    "台中市": "台中",
+    "臺中市": "臺中",
+    "台南市": "台南",
+    "臺南市": "臺南",
+    "高雄市": "高雄",
+    "新竹市": "新竹",
+}
+
 EnvProvider = Callable[[Optional[str]], Awaitable[Dict[str, Any]]]
 ResultFormatter = Callable[[str, str, Dict[str, Any], str], Awaitable[str]]
 ToolHandler = Callable[[Dict[str, Any]], Awaitable[Any]]
+OutputSchemaProvider = Callable[[str], Optional[Dict[str, Any]]]
+
+
+class ToolOutputValidationError(RuntimeError):
+    """Raised when a tool result violates its declared outputSchema."""
 
 
 class ToolCoordinator:
@@ -25,11 +49,13 @@ class ToolCoordinator:
         env_provider: EnvProvider,
         tool_lookup: Callable[[str], Optional[ToolHandler]],
         formatter: ResultFormatter,
+        output_schema_provider: Optional[OutputSchemaProvider] = None,
         failure_handlers: Optional[Dict[str, Callable[[Dict[str, Any], Exception], ToolResult]]] = None,
     ) -> None:
         self._env_provider = env_provider
         self._tool_lookup = tool_lookup
         self._formatter = formatter
+        self._output_schema_provider = output_schema_provider
         self._metadata: Dict[str, ToolMetadata] = {}
         self._failure_handlers = failure_handlers or {}
 
@@ -78,7 +104,10 @@ class ToolCoordinator:
             logger.info(f"📦 [Coordinator] 環境資訊: {env_ctx}")
             if env_ctx:
                 for field in metadata.requires_env:
-                    if merged.get(field) is not None:
+                    val = merged.get(field)
+                    # 如果參數已有值且不是預設佔位符（如 0 或空字串），則跳過注入
+                    # 這是為了解決 GPT 可能會填入 0 作為座標佔位符的問題
+                    if val is not None and val != 0 and val != "":
                         continue
                     env_value = env_ctx.get(field)
                     # 主欄位為 None 時，嘗試 fallback 欄位
@@ -90,6 +119,7 @@ class ToolCoordinator:
                                 break
                     # 只注入非 None 的值，避免覆蓋工具的預設值或觸發 schema 驗證錯誤
                     if env_value is not None:
+                        env_value = self._normalize_env_value(field, env_value)
                         merged[field] = env_value
                         logger.info(f"📦 [Coordinator] 注入環境變數: {field}={env_value}")
         elif not user_id:
@@ -98,6 +128,24 @@ class ToolCoordinator:
         logger.info(f"📦 [Coordinator] 最終參數: {merged}")
         return merged
 
+    @staticmethod
+    def _normalize_env_value(field: str, value: Any) -> Any:
+        if field != "city" or not isinstance(value, str):
+            return value
+
+        normalized = value.strip()
+        if not normalized:
+            return value
+
+        if normalized in CITY_ALIASES:
+            return CITY_ALIASES[normalized]
+
+        exact_match = re.match(r"^(台北|臺北|新北|桃園|台中|臺中|台南|臺南|高雄|新竹)(?:市|縣)?$", normalized)
+        if exact_match:
+            return exact_match.group(1)
+
+        return normalized
+
     async def _execute(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
         handler = self._tool_lookup(tool_name)
         if not handler:
@@ -109,8 +157,13 @@ class ToolCoordinator:
             try:
                 result = await asyncio.wait_for(handler(arguments), timeout=30.0)
                 if isinstance(result, dict):
+                    self._validate_output(tool_name, result)
                     return result
-                return {"success": True, "content": str(result)}
+                wrapped = {"success": True, "content": str(result)}
+                self._validate_output(tool_name, wrapped)
+                return wrapped
+            except ToolOutputValidationError:
+                raise
             except Exception as exc:  # noqa: BLE001
                 last_exc = exc
                 logger.warning("工具 %s 執行失敗 (attempt=%s): %s", tool_name, attempt, exc)
@@ -120,6 +173,21 @@ class ToolCoordinator:
             return handler(arguments, last_exc)  # type: ignore[arg-type]
         raise RuntimeError(f"工具 {tool_name} 執行失敗：{last_exc}")  # type: ignore[arg-type]
 
+    def _validate_output(self, tool_name: str, result: Dict[str, Any]) -> None:
+        if not self._output_schema_provider or jsonschema is None:
+            return
+
+        schema = self._output_schema_provider(tool_name)
+        if not schema:
+            return
+
+        try:
+            jsonschema.validate(result, schema)
+        except jsonschema.ValidationError as exc:
+            field_path = ".".join(str(part) for part in exc.absolute_path)
+            detail = f"{field_path}: {exc.message}" if field_path else exc.message
+            raise ToolOutputValidationError(f"工具 {tool_name} 輸出格式不符合契約: {detail}") from exc
+
     async def _format_result(
         self,
         tool_name: str,

features/mcp/mcp_client.py

@@ -165,6 +165,7 @@ class MCPClient:
             name = tool_data.get("name")
             description = tool_data.get("description", "")
             input_schema = tool_data.get("inputSchema", {"type": "object", "properties": {}})
+            output_schema = tool_data.get("outputSchema")
 
             # 創建代理處理器
             async def tool_handler(arguments: Dict[str, Any]) -> Dict[str, Any]:
@@ -174,7 +175,8 @@ class MCPClient:
                 name=name,
                 description=description,
                 inputSchema=input_schema,
-                handler=tool_handler
+                handler=tool_handler,
+                outputSchema=output_schema
             )
 
             return tool
@@ -192,7 +194,21 @@ class MCPClient:
             })
 
             if response and response.get("result"):
-                content = response["result"].get("content", [])
+                result = response["result"]
+                content = result.get("content", [])
+                structured = result.get("structuredContent")
+                if result.get("isError"):
+                    if structured:
+                        structured = dict(structured)
+                        structured.setdefault("success", False)
+                        structured.setdefault("error", "\n".join([item.get("text", "") for item in content if item.get("type") == "text"]))
+                        return structured
+                    return {
+                        "success": False,
+                        "error": "\n".join([item.get("text", "") for item in content if item.get("type") == "text"]) or "外部工具執行失敗"
+                    }
+                if structured:
+                    return structured
                 return {
                     "success": True,
                     "content": "\n".join([item.get("text", "") for item in content if item.get("type") == "text"])
@@ -356,4 +372,4 @@ class MCPClientManager:
 
     def is_client_connected(self, server_name: str) -> bool:
         """檢查客戶端是否連接"""
-        return server_name in self.clients and self.clients[server_name].connected
+        return server_name in self.clients and self.clients[server_name].connected

features/mcp/openai_tools.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from core.config import settings
+from core.logging import get_logger
+
+logger = get_logger("mcp.openai_tools")
+
+DEFAULT_CONFIG_PATH = Path(__file__).resolve().parents[1] / "mcp_config.json"
+
+
+def _load_mcp_config(config_path: Optional[Path] = None) -> Dict[str, Any]:
+    path = config_path or DEFAULT_CONFIG_PATH
+    try:
+        with path.open("r", encoding="utf-8") as f:
+            return json.load(f)
+    except FileNotFoundError:
+        logger.warning("MCP 配置不存在: %s", path)
+    except json.JSONDecodeError as exc:
+        logger.warning("MCP 配置 JSON 無效: %s", exc)
+    return {}
+
+
+def _configured_items(section: Dict[str, Any]) -> List[Dict[str, Any]]:
+    items: List[Dict[str, Any]] = []
+    for item in section.get("items", []):
+        if isinstance(item, dict) and item.get("enabled", True):
+            items.append({key: value for key, value in item.items() if key != "enabled"})
+    return items
+
+
+def _configured_remote_mcp_items(section: Dict[str, Any]) -> List[Dict[str, Any]]:
+    items = []
+    for item in _configured_items(section):
+        if item.get("server_url") or item.get("connector_id"):
+            items.append(item)
+        else:
+            logger.info("跳過沒有 server_url/connector_id 的 hosted MCP 設定: %s", item.get("server_label"))
+    return items
+
+
+def _env_json_list(raw: str, *, label: str) -> List[Dict[str, Any]]:
+    if not raw:
+        return []
+    try:
+        parsed = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        logger.warning("%s 不是合法 JSON，已忽略: %s", label, exc)
+        return []
+    if not isinstance(parsed, list):
+        logger.warning("%s 必須是 list，已忽略", label)
+        return []
+    return [item for item in parsed if isinstance(item, dict)]
+
+
+def build_openai_hosted_tools(config_path: Optional[Path] = None) -> List[Dict[str, Any]]:
+    config = _load_mcp_config(config_path)
+    openai_tools = config.get("openai_tools", {})
+    specs: List[Dict[str, Any]] = []
+
+    web_search = openai_tools.get("web_search", {})
+    if settings.OPENAI_ENABLE_WEB_SEARCH and web_search.get("enabled", True):
+        specs.append({"type": "web_search"})
+
+    remote_mcp = openai_tools.get("remote_mcp", {})
+    if settings.OPENAI_ENABLE_REMOTE_MCP and remote_mcp.get("enabled", False):
+        for server in _configured_remote_mcp_items(remote_mcp) + _configured_remote_mcp_items(
+            {"items": _env_json_list(
+                settings.OPENAI_REMOTE_MCP_SERVERS_JSON,
+                label="OPENAI_REMOTE_MCP_SERVERS_JSON",
+            )}
+        ):
+            spec = dict(server)
+            spec["type"] = "mcp"
+            spec.setdefault("require_approval", remote_mcp.get("approval_default", "always"))
+            specs.append(spec)
+
+    return specs

features/mcp/server.py

@@ -11,9 +11,14 @@ import time
 import os
 from typing import Dict, Any, List, Optional, Callable, Tuple
 from enum import Enum
-from .types import Tool
+from .types import Tool, ToolCallResult
 from .auto_registry import MCPAutoRegistry
 
+try:
+    import jsonschema
+except ImportError:
+    jsonschema = None
+
 LOG_LEVEL_NAME = os.getenv("BLOOMWARE_LOG_LEVEL", "WARNING").upper()
 LOG_LEVEL = getattr(logging, LOG_LEVEL_NAME, logging.WARNING)
 logging.basicConfig(
@@ -183,7 +188,17 @@ class FeaturesMCPServer:
                     name=tool_name,
                     description=description,
                     inputSchema={"type": "object", "properties": {}},
-                    handler=handler
+                    handler=handler,
+                    outputSchema={
+                        "type": "object",
+                        "properties": {
+                            "success": {"type": "boolean"},
+                            "content": {"type": "string"},
+                            "error": {"type": ["string", "null"]},
+                            "error_code": {"type": ["string", "null"]},
+                        },
+                        "required": ["success"],
+                    }
                 )
                 self.register_tool(tool)
 
@@ -215,6 +230,60 @@ class FeaturesMCPServer:
         """註冊工具"""
         self.tools[tool.name] = tool
         logger.info(f"註冊工具: {tool.name}")
+
+    def _format_tool_result(self, tool_name: str, result: Any) -> Dict[str, Any]:
+        """轉成 MCP tools/call result，保留 structuredContent。"""
+        if isinstance(result, ToolCallResult):
+            return result.to_dict()
+
+        if isinstance(result, dict):
+            is_error = result.get("success") is False
+            content = result.get("content")
+            if not content:
+                content = result.get("error") if is_error else json.dumps(result, ensure_ascii=False)
+
+            output_issue = self._validate_tool_output(tool_name, result)
+            if output_issue:
+                return ToolCallResult(
+                    content=[{"type": "text", "text": "工具輸出格式不符合契約"}],
+                    structuredContent={
+                        "success": False,
+                        "error_code": "TOOL_OUTPUT_VALIDATION",
+                        "tool_name": tool_name,
+                        "details": output_issue,
+                    },
+                    isError=True,
+                ).to_dict()
+
+            payload = ToolCallResult(
+                content=[{"type": "text", "text": str(content)}],
+                structuredContent=result,
+                isError=is_error,
+            ).to_dict()
+            if is_error and "error_code" not in payload["structuredContent"]:
+                payload["structuredContent"]["error_code"] = "TOOL_EXECUTION_ERROR"
+            return payload
+
+        return ToolCallResult(
+            content=[{"type": "text", "text": str(result)}],
+            structuredContent={"tool_name": tool_name, "value": result},
+            isError=False,
+        ).to_dict()
+
+    def _validate_tool_output(self, tool_name: str, result: Dict[str, Any]) -> Optional[str]:
+        """用工具 outputSchema 驗證 structuredContent。"""
+        tool = self.tools.get(tool_name)
+        if not tool or not tool.outputSchema or jsonschema is None:
+            return None
+
+        try:
+            jsonschema.validate(result, tool.outputSchema)
+            return None
+        except jsonschema.ValidationError as exc:
+            field_path = ".".join(str(part) for part in exc.absolute_path)
+            if field_path:
+                return f"{field_path}: {exc.message}"
+            return exc.message
     
     def get_tools_summary(self) -> List[Dict[str, Any]]:
         """
@@ -352,22 +421,29 @@ class FeaturesMCPServer:
         if tool.handler:
             try:
                 result = await tool.handler(arguments)
-
-                # 統一回應格式
-                if isinstance(result, dict) and result.get("success"):
-                    content = result.get("content", "")
-                    return {"content": [{"type": "text", "text": content}]}
-                elif isinstance(result, dict) and not result.get("success"):
-                    error_msg = result.get("error", "工具執行失敗")
-                    return {"content": [{"type": "text", "text": f"❌ {error_msg}"}], "isError": True}
-                else:
-                    return {"content": [{"type": "text", "text": str(result)}]}
+                return self._format_tool_result(tool_name, result)
 
             except Exception as e:
                 logger.error(f"工具執行錯誤 {tool_name}: {e}")
-                return {"content": [{"type": "text", "text": f"❌ 執行錯誤: {str(e)}"}], "isError": True}
-
-        return {"content": [{"type": "text", "text": "工具未實作"}]}
+                return ToolCallResult(
+                    content=[{"type": "text", "text": "工具執行失��"}],
+                    structuredContent={
+                        "success": False,
+                        "error_code": "TOOL_EXECUTION_ERROR",
+                        "tool_name": tool_name,
+                    },
+                    isError=True,
+                ).to_dict()
+
+        return ToolCallResult(
+            content=[{"type": "text", "text": "工具未實作"}],
+            structuredContent={
+                "success": False,
+                "error_code": "TOOL_NOT_IMPLEMENTED",
+                "tool_name": tool_name,
+            },
+            isError=True,
+        ).to_dict()
 
     async def cleanup(self):
         """清理資源"""

features/mcp/skills.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Iterable, List
+
+import json
+
+SKILLS_ROOT = Path(__file__).resolve().parent / "skills"
+DEFAULT_CONFIG_PATH = Path(__file__).resolve().parents[1] / "mcp_config.json"
+
+
+def _load_mcp_config(config_path: Path = DEFAULT_CONFIG_PATH) -> Dict[str, Any]:
+    try:
+        return json.loads(config_path.read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        return {}
+
+
+def _slug(name: str) -> str:
+    return "".join(ch if ch.isalnum() or ch in {"-", "_"} else "-" for ch in name).strip("-").lower()
+
+
+def _yaml_scalar(value: Any) -> str:
+    if value is None:
+        return "null"
+    text = str(value).replace('"', '\\"')
+    return f'"{text}"'
+
+
+def _yaml_list(values: Iterable[Any], indent: int = 2) -> str:
+    prefix = " " * indent
+    items = list(values)
+    if not items:
+        return f"{prefix}[]"
+    return "\n".join(f"{prefix}- {_yaml_scalar(item)}" for item in items)
+
+
+def tool_skill_path(tool_name: str) -> Path:
+    return SKILLS_ROOT / _slug(tool_name) / "SKILL.md"
+
+
+def render_tool_skill(tool_name: str, tool_info: Dict[str, Any]) -> str:
+    examples = tool_info.get("examples") or []
+    return "\n".join(
+        [
+            "---",
+            f"name: mcp-{tool_name}",
+            f"description: { _yaml_scalar('Use when the user request matches the Bloom Ware MCP tool ' + tool_name + ' usage scenario.') }",
+            "tool_contract:",
+            f"  name: {_yaml_scalar(tool_name)}",
+            f"  category: {_yaml_scalar(tool_info.get('category', 'general'))}",
+            f"  module: {_yaml_scalar(tool_info.get('module', ''))}",
+            f"  class: {_yaml_scalar(tool_info.get('class', ''))}",
+            f"  description: {_yaml_scalar(tool_info.get('description', ''))}",
+            "  examples:",
+            _yaml_list(examples, indent=4),
+            "routing:",
+            "  invocation_mode: \"local_mcp_bridge_function_calling\"",
+            "  openai_hosted_mcp: \"disabled_unless_remote_server_url_is_configured\"",
+            "  required_action: \"Select this tool only when the request maps to its category and required inputs can be extracted or safely derived from environment context.\"",
+            "safety:",
+            "  do_not_fabricate_missing_data: true",
+            "  preserve_tool_failure_semantics: true",
+            "  user_approval_required_for_high_impact_actions: true",
+            "---",
+            "",
+            "Use this skill as the authoritative routing note for this Bloom Ware MCP tool.",
+            "The actual tool call must go through the local MCP bridge/function-calling path.",
+            "",
+        ]
+    )
+
+
+def write_tool_skills(config_path: Path = DEFAULT_CONFIG_PATH) -> List[Path]:
+    config = _load_mcp_config(config_path)
+    written: List[Path] = []
+    for tool_name, tool_info in sorted((config.get("tools") or {}).items()):
+        if not (tool_info.get("module") and tool_info.get("class")):
+            continue
+        path = tool_skill_path(tool_name)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(render_tool_skill(tool_name, tool_info), encoding="utf-8")
+        written.append(path)
+    return written
+
+
+def skills_prompt_block(config_path: Path = DEFAULT_CONFIG_PATH) -> str:
+    config = _load_mcp_config(config_path)
+    lines = [
+        "Bloom Ware tool skills:",
+        "Use these routing notes when selecting local MCP bridge tools or OpenAI hosted tools. Do not call hosted MCP for local tools unless a remote server_url is configured.",
+        "- web_search: category=hosted_openai_tool; use_when=current, recent, time-sensitive, public, or externally verifiable information is needed; call_via=responses_hosted_tool_auto; read_skill=features/mcp/skills/web_search/SKILL.md; rule=use time/environment context and source timestamps to decide, without domain-specific hardcoding",
+    ]
+    for tool_name, tool_info in sorted((config.get("tools") or {}).items()):
+        if not (tool_info.get("module") and tool_info.get("class")):
+            continue
+        examples = ", ".join(tool_info.get("examples") or [])
+        lines.append(
+            f"- {tool_name}: category={tool_info.get('category', 'general')}; "
+            f"use_when={tool_info.get('description', '')}; examples={examples}; "
+            f"call_via=local_function_calling_tool_schema"
+        )
+    return "\n".join(lines)

features/mcp/skills/directions/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: mcp-directions
+description: "Use when the user request matches the Bloom Ware MCP tool directions usage scenario."
+tool_contract:
+  name: "directions"
+  category: "location"
+  module: "features.mcp.tools.location.directions_tool"
+  class: "DirectionsTool"
+  description: "規劃兩點之間的路線"
+  examples:
+    - "從這裡到台北車站怎麼走"
+    - "幫我規劃路線"
+routing:
+  invocation_mode: "local_mcp_bridge_function_calling"
+  openai_hosted_mcp: "disabled_unless_remote_server_url_is_configured"
+  required_action: "Select this tool only when the request maps to its category and required inputs can be extracted or safely derived from environment context."
+safety:
+  do_not_fabricate_missing_data: true
+  preserve_tool_failure_semantics: true
+  user_approval_required_for_high_impact_actions: true
+---
+
+Use this skill as the authoritative routing note for this Bloom Ware MCP tool.
+The actual tool call must go through the local MCP bridge/function-calling path.

features/mcp/skills/environment_context/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: mcp-environment_context
+description: "Use when the user request matches the Bloom Ware MCP tool environment_context usage scenario."
+tool_contract:
+  name: "environment_context"
+  category: "environment"
+  module: "features.mcp.tools.environment.context_tool"
+  class: "EnvironmentContextTool"
+  description: "取得使用者目前環境感知資料（位置、時區、語言、裝置、活動狀態）"
+  examples:
+    - "我現在在哪"
+    - "目前環境資訊"
+routing:
+  invocation_mode: "local_mcp_bridge_function_calling"
+  openai_hosted_mcp: "disabled_unless_remote_server_url_is_configured"
+  required_action: "Select this tool only when the request maps to its category and required inputs can be extracted or safely derived from environment context."
+safety:
+  do_not_fabricate_missing_data: true
+  preserve_tool_failure_semantics: true
+  user_approval_required_for_high_impact_actions: true
+---
+
+Use this skill as the authoritative routing note for this Bloom Ware MCP tool.
+The actual tool call must go through the local MCP bridge/function-calling path.

features/mcp/skills/exchange_query/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: mcp-exchange_query
+description: "Use when the user request matches the Bloom Ware MCP tool exchange_query usage scenario."
+tool_contract:
+  name: "exchange_query"
+  category: "utility"
+  module: "features.mcp.tools.utility.exchange_tool"
+  class: "ExchangeTool"
+  description: "查詢即時匯率並換算貨幣"
+  examples:
+    - "100 美元換台幣"
+    - "日圓匯率"
+routing:
+  invocation_mode: "local_mcp_bridge_function_calling"
+  openai_hosted_mcp: "disabled_unless_remote_server_url_is_configured"
+  required_action: "Select this tool only when the request maps to its category and required inputs can be extracted or safely derived from environment context."
+safety:
+  do_not_fabricate_missing_data: true
+  preserve_tool_failure_semantics: true
+  user_approval_required_for_high_impact_actions: true
+---
+
+Use this skill as the authoritative routing note for this Bloom Ware MCP tool.
+The actual tool call must go through the local MCP bridge/function-calling path.

features/mcp/skills/forward_geocode/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: mcp-forward_geocode
+description: "Use when the user request matches the Bloom Ware MCP tool forward_geocode usage scenario."
+tool_contract:
+  name: "forward_geocode"
+  category: "location"
+  module: "features.mcp.tools.location.geocoding_tool"
+  class: "ForwardGeocodeTool"
+  description: "將地點名稱轉換成座標"
+  examples:
+    - "銘傳大學在哪"
+    - "台北車站座標"
+routing:
+  invocation_mode: "local_mcp_bridge_function_calling"
+  openai_hosted_mcp: "disabled_unless_remote_server_url_is_configured"
+  required_action: "Select this tool only when the request maps to its category and required inputs can be extracted or safely derived from environment context."
+safety:
+  do_not_fabricate_missing_data: true
+  preserve_tool_failure_semantics: true
+  user_approval_required_for_high_impact_actions: true
+---
+
+Use this skill as the authoritative routing note for this Bloom Ware MCP tool.
+The actual tool call must go through the local MCP bridge/function-calling path.

features/mcp/skills/healthkit_query/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: mcp-healthkit_query
+description: "Use when the user request matches the Bloom Ware MCP tool healthkit_query usage scenario."
+tool_contract:
+  name: "healthkit_query"
+  category: "utility"
+  module: "features.mcp.tools.utility.healthkit_tool"
+  class: "HealthKitTool"
+  description: "查詢使用者健康資料（心率、步數、血氧、睡眠等）"
+  examples:
+    - "我今天走幾步"
+    - "最近心率如何"
+routing:
+  invocation_mode: "local_mcp_bridge_function_calling"
+  openai_hosted_mcp: "disabled_unless_remote_server_url_is_configured"
+  required_action: "Select this tool only when the request maps to its category and required inputs can be extracted or safely derived from environment context."
+safety:
+  do_not_fabricate_missing_data: true
+  preserve_tool_failure_semantics: true
+  user_approval_required_for_high_impact_actions: true
+---
+
+Use this skill as the authoritative routing note for this Bloom Ware MCP tool.
+The actual tool call must go through the local MCP bridge/function-calling path.

features/mcp/skills/news_query/SKILL.md

@@ -0,0 +1,22 @@
+# 新聞與即時資訊查詢 (Tavily AI)
+
+這個 Skill 使用 Tavily API 提供基於 AI 的新聞與即時資訊搜尋。相比傳統新聞 API，Tavily 能夠更好地過濾噪音、提供即時動態並對搜尋結果進行智慧摘要。
+
+## 功能特點
+- **極致時效性**：直接串接最新搜尋引擎索引，獲取分秒必爭的時事。
+- **AI 摘要**：自動整合多個來源，提供一句話或一段話的精華總結。
+- **深度搜尋**：支援 basic 與 advanced 兩種深度，應對簡單查詢或深入研究。
+
+## 參數說明
+- `query` (string, 必填): 搜尋關鍵詞。例如：「台積電收盤價」、「2024 奧運獎牌榜」。
+- `limit` (integer, 可選): 返回新聞數量，預設 5，上限 10。
+- `search_depth` (string, 可選): `basic` (快速) 或 `advanced` (深入)。
+
+## 使用範例
+- 「查看今天最重要的科技新聞」 -> `news_query(query="今天科技新聞", limit=5)`
+- 「搜尋關於 SpaceX 最近發射任務的詳細報導」 -> `news_query(query="SpaceX 最近發射任務", search_depth="advanced")`
+- 「台積電今天收盤多少？」 -> `news_query(query="台積電 股票 收盤價 今天")`
+
+## 注意事項
+- Tavily 會自動嘗試理解問題並給出 `answer` (AI 摘要)，這對語音助手快速回報非常有用。
+- 本工具已移除舊有的 NewsData.io 邏輯，不再支援 `country` 或 `category` 的硬性篩選，改由 AI 語義搜尋達成。

features/mcp/skills/reverse_geocode/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: mcp-reverse_geocode
+description: "Use when the user request matches the Bloom Ware MCP tool reverse_geocode usage scenario."
+tool_contract:
+  name: "reverse_geocode"
+  category: "location"
+  module: "features.mcp.tools.location.geocode_tool"
+  class: "ReverseGeocodeTool"
+  description: "將座標轉換成地址、城市與行政區"
+  examples:
+    - "我在哪裡"
+    - "這個座標是哪裡"
+routing:
+  invocation_mode: "local_mcp_bridge_function_calling"
+  openai_hosted_mcp: "disabled_unless_remote_server_url_is_configured"
+  required_action: "Select this tool only when the request maps to its category and required inputs can be extracted or safely derived from environment context."
+safety:
+  do_not_fabricate_missing_data: true
+  preserve_tool_failure_semantics: true
+  user_approval_required_for_high_impact_actions: true
+---
+
+Use this skill as the authoritative routing note for this Bloom Ware MCP tool.
+The actual tool call must go through the local MCP bridge/function-calling path.

features/mcp/skills/tdx_bus_arrival/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: mcp-tdx_bus_arrival
+description: "Use when the user request matches the Bloom Ware MCP tool tdx_bus_arrival usage scenario."
+tool_contract:
+  name: "tdx_bus_arrival"
+  category: "transportation"
+  module: "features.mcp.tools.transportation.tdx_bus_arrival"
+  class: "TDXBusArrivalTool"
+  description: "查詢公車即時到站時間（自動感知用戶位置，找最近站點）"
+  examples:
+    - "307 公車還要多久"
+    - "附近有什麼公車"
+    - "桃園火車站附近公車"
+routing:
+  invocation_mode: "local_mcp_bridge_function_calling"
+  openai_hosted_mcp: "disabled_unless_remote_server_url_is_configured"
+  required_action: "Select this tool only when the request maps to its category and required inputs can be extracted or safely derived from environment context. For precise stop areas, landmarks, roads, or intersections, fill location_query."
+safety:
+  do_not_fabricate_missing_data: true
+  preserve_tool_failure_semantics: true
+  user_approval_required_for_high_impact_actions: true
+---
+
+Use this skill as the authoritative routing note for this Bloom Ware MCP tool.
+The actual tool call must go through the local MCP bridge/function-calling path.

features/mcp/skills/tdx_metro/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: mcp-tdx_metro
+description: "Use when the user request matches the Bloom Ware MCP tool tdx_metro usage scenario."
+tool_contract:
+  name: "tdx_metro"
+  category: "transportation"
+  module: "features.mcp.tools.transportation.tdx_metro"
+  class: "TDXMetroTool"
+  description: "查詢捷運即時到站、最近車站（台北/高雄/桃園/台中捷運）"
+  examples:
+    - "最近的捷運站在哪"
+    - "台北車站捷運幾分鐘到"
+    - "桃園火車站附近捷運站"
+routing:
+  invocation_mode: "local_mcp_bridge_function_calling"
+  openai_hosted_mcp: "disabled_unless_remote_server_url_is_configured"
+  required_action: "Select this tool only when the request maps to its category and required inputs can be extracted or safely derived from environment context. For precise landmarks or addresses, fill location_query before falling back to city/operator."
+safety:
+  do_not_fabricate_missing_data: true
+  preserve_tool_failure_semantics: true
+  user_approval_required_for_high_impact_actions: true
+---
+
+Use this skill as the authoritative routing note for this Bloom Ware MCP tool.
+The actual tool call must go through the local MCP bridge/function-calling path.

features/mcp/skills/tdx_parking/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: mcp-tdx_parking
+description: "Use when the user request matches the Bloom Ware MCP tool tdx_parking usage scenario."
+tool_contract:
+  name: "tdx_parking"
+  category: "transportation"
+  module: "features.mcp.tools.transportation.tdx_parking"
+  class: "TDXParkingTool"
+  description: "查詢附近停車場資訊和即時空位"
+  examples:
+    - "附近停車場"
+    - "台北車站附近停車位"
+    - "中正路100號附近停車場"
+routing:
+  invocation_mode: "local_mcp_bridge_function_calling"
+  openai_hosted_mcp: "disabled_unless_remote_server_url_is_configured"
+  required_action: "Select this tool only when the request maps to its category and required inputs can be extracted or safely derived from environment context. For precise addresses, landmarks, or intersections, fill location_query instead of forcing city."
+safety:
+  do_not_fabricate_missing_data: true
+  preserve_tool_failure_semantics: true
+  user_approval_required_for_high_impact_actions: true
+---
+
+Use this skill as the authoritative routing note for this Bloom Ware MCP tool.
+The actual tool call must go through the local MCP bridge/function-calling path.