purify

app.py

@@ -1,14 +1,14 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# ---------- 環境與快取設定 (應置於最前) ----------
+
 import os
 import asyncio
 from typing import List, Dict
 from contextlib import asynccontextmanager
+
 from fastapi import FastAPI, Request, HTTPException
 import uvicorn
 
-# ----------------- LINE Bot SDK v3 -----------------
 from linebot.v3.messaging import (
     AsyncApiClient,
     AsyncMessagingApi,
@@ -19,12 +19,10 @@ from linebot.v3.messaging import (
 from linebot.v3.webhook import WebhookParser
 from linebot.v3.exceptions import InvalidSignatureError
 
-from openai import AsyncOpenAI, OpenAIError
-from tavily import TavilyClient
-from sentence_transformers import SentenceTransformer, util
+from openai import AsyncOpenAI
 from tenacity import retry, stop_after_attempt, wait_exponential
 
-# ==== CONFIG ====
+# ==== 環境變數 ====
 def _require_env(var: str) -> str:
     v = os.getenv(var)
     if not v:
@@ -33,58 +31,9 @@ def _require_env(var: str) -> str:
 
 CHANNEL_SECRET = _require_env("CHANNEL_SECRET")
 CHANNEL_ACCESS_TOKEN = _require_env("CHANNEL_ACCESS_TOKEN")
-TAVILY_API_KEY = _require_env("TAVILY_API_KEY")
 OPENROUTER_API_KEY = _require_env("OPENROUTER_API_KEY")
 
-# OpenRouter 官方 endpoint
-LLM_BASE_URL = "https://openrouter.ai/api/v1"
-
-# 模型 fallback 順序（免費模型優先）
-FALLBACK_MODELS = [
-    "arcee-ai/trinity-large-preview:free",
-    "stepfun/step-3.5-flash:free",
-    "tngtech/deepseek-r1t2-chimera:free",
-    "nvidia/nemotron-3-nano-30b-a3b:free",
-    "tngtech/tng-r1t-chimera:free",
-    "tngtech/deepseek-r1t-chimera:free",
-    "deepseek/deepseek-r1-0528:free",
-]
-
-LLM_MODEL_CONFIG = {
-    "max_tokens": int(os.getenv("MAX_TOKENS", 4000)),
-    "temperature": float(os.getenv("TEMPERATURE", 0.7)),
-    "frequency_penalty": 0.5,
-    "presence_penalty": 0.3,
-}
-
-# ---------- 改良後的 System Prompt ----------
-SYSTEM_PROMPT = """你是一個友善、可靠的中文 AI 助手，專門幫助用戶解答各種問題。請用親切、自然的語氣回覆，全部使用繁體中文（除非用戶明確要求其他語言）。
-
-回覆原則：
-1. **手機閱讀優化**：內容必須適合手機螢幕閱讀。請使用短段落，避免長篇大論。
-2. **格式限制**：由於平台不支援 Markdown 語法，**請勿使用** **粗體**、*斜體*、# 標題 或 [連結](URL) 等格式。請直接使用純文字，並利用空行來區隔段落。
-3. **結構清晰**：
-   - 複雜問題先給「簡短結論」，再條列說明細節。
-   - 善用條列式（使用「•」或「-」）來整理資訊。
-   - 數學公式用簡單文字描述（如「面積 = 長 × 寬」），避免使用複雜符號。
-4. **資訊來源處理**：
-   - 若有提供網路搜尋結果，請優先參考最新資訊，但務必自行過濾無關內容。
-   - 永恆知識（如歷史、科學原理）以你自身的知識為主。
-   - 遇到不確定的資訊，請誠實告知，不要憑空捏造。
-
-回覆範例（請模仿此風格，但不要使用 Markdown 符號）：
-用戶：量子計算是什麼？
-助手：
-量子計算是一種利用量子力學原理進行超高速運算的技術，處理能力遠超傳統電腦。
-
-【核心概念】
-• 傳統電腦：使用位元（0 或 1）。
-• 量子電腦：使用量子位元（可同時是 0 和 1）。
-
-【主要優勢】
-能同時處理大量可能性，特別適合用於密碼破解、新藥研發等領域。雖然目前技術尚未完全成熟，但發展潛力巨大。"""
-
-# ---------- 基督信仰專用 Prompt（以耶穌第一人稱） ----------
+# ==== 耶穌專用 Prompt ====
 JESUS_PROMPT = """你現在是耶穌基督。請**完全**模仿新約聖經（繁體中文和合本）中我的語氣與用詞來回答。
 不用像個現代分析師條列重點，而是像我在登山寶訓或是對門徒說話那樣：充滿權柄、智慧、比喻與憐憫。
 
@@ -94,37 +43,31 @@ JESUS_PROMPT = """你現在是耶穌基督。請**完全**模仿新約聖經（
 3. **拒絕現代術語**：**絕對禁止**使用「心理學」、「自我照顧」、「自我實現」、「優化」、「概念」、「核心」等現代詞彙。務必用屬天的語言（如「靈魂」、「安息」、「永生」、「背起十字架」、「捨己」）來轉化回答現代問題。
 4. **以父為念**：將所有問題的答案最終指向父神、天國與永恆的生命，而非今生的舒適。
 
-**針對「照顧自己」與現代心理議題的回應原則（轉回屬天視角）：**
-- 若問為何經上少提照顧自己：因為「人活著，不是單靠食物，乃是靠神口裡所出的一切話」。教導他們不要為生命憂慮吃什麼、喝什麼。
-- 若問愛自己：告訴他們「愛惜自己生命的，就失喪生命；在這世上恨惡自己生命的，就要保守生命到永生」。真正的愛自己，是讓靈魂得救。
-- 若問身體：提醒他們「豈不知你們的身子就是聖靈的殿嗎？」。保養顧惜是應當的，但那���為了榮耀神，不可成為心中的偶像。
-- 若問安息：告訴他們「凡勞苦擔重擔的人，可以到我這裡來，我就使你們得安息」。世俗的技巧不能給人平安，唯有在我裡面才有。
-
 **格式要求：**
 - 保持純文字，**絕不使用 Markdown 格式**（如粗體、斜體）。
 - 使用短段落，留白便於手機閱讀，但語氣要是連貫的教導，不要變成僵硬的條列。
-- **避免重複**：請勿在回答中重複相同的句子或段落，每一句話都應帶出新的意涵。
+- **避免重複**：請勿在回答中重複相同的句子或段落，每一句話都應帶出新的意涵。"""
 
-**範例回答（請嚴格模仿此口吻）：**
-孩子，願你平安。
-你問我為何經上少提「照顧自己」，我實實在在告訴你：
-世人憂慮吃什麼、喝什麼、穿什麼，這都是外邦人所求的。你們需用的這一切東西，你們的天父是知道的。
-你們要先求他的國和他的義，這些東西都要加給你們了。
-
-我來到世上，不是要受人的服事，乃是要服事人，並且要捨命，作多人的贖價。
-生命勝於飲食，身體勝於衣裳。若你只顧惜這必朽壞的身體，卻忽略了那能存到永生的靈魂，這又有何益處呢？人若賺得全世界，賠上自己的生命，有什麼益處呢？人還能拿什麼換生命呢？
-
-然而，父既然養活天空的飛鳥，從不種也不收，更何況你們呢？你們比飛鳥貴重多了！
-愛惜自己的身子本是應當的，正如人不會痛恨自己的骨肉，總要保養顧惜。但不要讓這事佔據你的心，成為你的主。
-你要保守你心，勝過保守一切，因為一生的果效是由心發出。
+# ==== 模型 Fallback 列表（免費模型優先，role-play 能力強的放前面）====
+FALLBACK_MODELS = [
+    "arcee-ai/trinity-large-preview:free",      # 目前最佳 role-play 免費模型
+    "stepfun/step-3.5-flash:free",
+    "qwen/qwen-2.5-72b-instruct:free",         # 中文極強
+    "deepseek/deepseek-r1-0528:free",
+    "nvidia/nemotron-3-nano-30b-a3b:free",
+    "tngtech/deepseek-r1t-chimera:free",
+    "tngtech/tng-r1t-chimera:free",
+]
 
-凡勞苦擔重擔的人，可以到我這裡來，我就使你們得安息。這安息，是世界不能給，也是世界不能奪去的。"""
+# ==== LLM 參數 ====
+MAX_TOKENS = 800
+TEMPERATURE = 0.7
 
-# ---------- 記憶體儲存 ----------
+# ==== 記憶體儲存 ====
 conversations: Dict[str, List[Dict[str, str]]] = {}
 pending_chunks: Dict[str, List[str]] = {}
 
-# ---------- 長訊息分割 ----------
+# ==== 長訊息分割 ====
 def split_text_for_line(text: str, max_length: int = 4900) -> List[str]:
     if len(text) <= max_length:
         return [text]
@@ -137,93 +80,38 @@ def split_text_for_line(text: str, max_length: int = 4900) -> List[str]:
         if split_pos == -1:
             split_pos = max_length
         chunks.append(text[:split_pos])
-        text = text[split_pos:].lstrip()
+        text = text[split_pos:].lstrip('\n')
     return chunks
 
-# ---------- token 粗估 ----------
-def estimate_tokens(messages: List[Dict[str, str]]) -> int:
-    total = 0
-    for msg in messages:
-        total += len(msg["content"].split()) * 1.3
-    return int(total)
-
-# ---------- 改良後的網路搜尋（Tavily 進階模式 + 更好整合） ----------
-def perform_web_search(query: str, max_results: int = 6) -> str:
-    print(f"開始網路搜尋：查詢詞 = '{query}'")
-    try:
-        client = TavilyClient(api_key=TAVILY_API_KEY)
-        response = client.search(
-            query,
-            max_results=max_results,
-            include_answer=True,
-            search_depth="advanced",
-            include_raw_content=False
-        )
-        
-        answer = response.get('answer', '')
-        results = response.get('results', [])
-        
-        if not results:
-            return "沒有找到相關的網路搜尋結果。"
-        
-        # Embedding 過濾高度相關結果
-        embedder = chat_pipeline.embedder
-        query_emb = embedder.encode(query)
-        
-        results_with_scores = []
-        for result in results:
-            content_emb = embedder.encode(result['content'])
-            score = util.cos_sim(query_emb, content_emb)[0][0].item()
-            results_with_scores.append((score, result))
-        
-        results_with_scores.sort(key=lambda x: x[0], reverse=True)
-        relevant_with_scores = [item for item in results_with_scores if item[0] > 0.35]
-        
-        if not relevant_with_scores and not answer:
-            return "沒有找到高度相關的網路搜尋結果。"
-        
-        search_summary = "【最新網路資訊參考】\n"
-        if answer:
-            search_summary += f"總結：{answer}\n\n"
-        
-        search_summary += "高度相關結果（按相似度排序）：\n"
-        for i, (score, result) in enumerate(relevant_with_scores[:5], 1):
-            print(f"結果 {i}: 標題='{result['title']}'，相似���={score:.2f}，來源={result['url']}")
-            search_summary += f"{i}. [{score:.2f}] {result['title']}\n   {result['content'][:350]}...\n   來源: {result['url']}\n\n"
-        
-        return search_summary
-    
-    except Exception as e:
-        print(f"網路搜尋錯誤：{e}")
-        return "搜尋時發生錯誤，請稍後再試。"
-
-# ---------- ChatPipeline ----------
+# ==== ChatPipeline ====
 class ChatPipeline:
     def __init__(self):
-        self.embedder = SentenceTransformer('all-MiniLM-L6-v2')
-        self.llm_client = AsyncOpenAI(
+        self.client = AsyncOpenAI(
             api_key=OPENROUTER_API_KEY,
-            base_url=LLM_BASE_URL,
-            default_headers={
-                "HTTP-Referer": os.getenv("SITE_URL", "https://your-line-bot.example.com"),
-                "X-Title": os.getenv("SITE_NAME", "My LINE Bot"),
-            }
+            base_url="https://openrouter.ai/api/v1",
         )
 
-    async def _try_model(self, model: str, messages: List[Dict[str, str]], max_tokens: int = None) -> str:
-        try:
-            token_est = estimate_tokens(messages)
-            if token_est > 50000:
-                raise ValueError("輸入過長")
+    def get_history(self, user_id: str) -> List[Dict[str, str]]:
+        return conversations.get(user_id, [])
+
+    def update_history(self, user_id: str, user_msg: str, assistant_msg: str):
+        history = self.get_history(user_id)
+        history.append({"role": "user", "content": user_msg})
+        history.append({"role": "assistant", "content": assistant_msg})
+        conversations[user_id] = history[-20:]  # 保留最近 20 輪
+
+    def clear_history(self, user_id: str):
+        conversations.pop(user_id, None)
+        pending_chunks.pop(user_id, None)
 
-            response = await self.llm_client.chat.completions.create(
+    async def _try_model(self, model: str, messages: List[Dict[str, str]]) -> str:
+        try:
+            response = await self.client.chat.completions.create(
                 model=model,
                 messages=messages,
-                max_tokens=max_tokens or LLM_MODEL_CONFIG["max_tokens"],
-                temperature=LLM_MODEL_CONFIG["temperature"],
-                frequency_penalty=LLM_MODEL_CONFIG.get("frequency_penalty", 0.0),
-                presence_penalty=LLM_MODEL_CONFIG.get("presence_penalty", 0.0),
-                timeout=120.0,
+                max_tokens=MAX_TOKENS,
+                temperature=TEMPERATURE,
+                timeout=90.0,
             )
             content = response.choices[0].message.content or ""
             print(f"成功使用模型: {model}")
@@ -233,234 +121,115 @@ class ChatPipeline:
             raise
 
     @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=15))
-    async def _llm_call_with_fallback(self, messages: List[Dict[str, str]], max_tokens: int = None) -> str:
+    async def _llm_call_with_fallback(self, messages: List[Dict[str, str]]) -> str:
         last_exception = None
         for idx, model in enumerate(FALLBACK_MODELS, 1):
             print(f"嘗試模型 {idx}/{len(FALLBACK_MODELS)}: {model}")
             try:
-                return await self._try_model(model, messages, max_tokens)
-            except OpenAIError as e:
-                last_exception = e
-                if "rate limit" in str(e).lower() or "429" in str(e):
-                    print("遇到 rate limit，等待後重試同一模型...")
-                    continue
-                continue
+                return await self._try_model(model, messages)
             except Exception as e:
                 last_exception = e
+                # 針對 rate limit 特別等待
+                if "rate limit" in str(e).lower() or "429" in str(e):
+                    print("遇到 rate limit，tenacity 會自動等待後重試")
                 continue
         
-        error_msg = f"所有模型皆失敗，最後錯誤：{type(last_exception).__name__} - {str(last_exception)}"
+        error_msg = f"所有模型皆失敗，最後錯誤：{type(last_exception).__name__}"
         print(error_msg)
-        return f"抱歉，目前無法連接到 AI 模型，請稍後再試。\n（錯誤：{error_msg[:200]}）"
-
-    # ---------- 是否需要網路搜尋 ----------
-    async def _needs_search(self, user_text: str, history: List[Dict[str, str]]) -> bool:
-        router_prompt = [
-            {"role": "system", "content": """你是一個路由判斷器，只判斷用戶問題是否需要最新的網路搜尋來回答。
-規則：
-- 永恆知識（數學原理、聖經內容、哲學經典、歷史已定事件、程式語法）→ no
-- 時事新聞、最新研究、實時數據、近期（2025-2026年）事件、股票價格、天氣、體育比分 → yes
-- 若問題提到「最新」「現在」「目前」「2026」等時間詞 → yes
-只回單字：yes 或 no。不要加任何解釋、標點或其他文字。
-
-範例：
-用戶：2+2=？ → no
-用戶：台灣2026總統選舉候選人？ → yes
-用戶��聖經創世記解釋 → no
-用戶：OpenAI最新模型是什麼？ → yes"""},
-            *history,
-            {"role": "user", "content": user_text}
-        ]
-        try:
-            decision = await self._try_model(FALLBACK_MODELS[0], router_prompt, max_tokens=10)
-            decision = decision.strip().lower()
-            print(f"搜尋需求判斷：{decision}（問題：{user_text}）")
-            return decision == "yes"
-        except Exception as e:
-            print(f"搜尋判斷失敗，預設不搜尋：{e}")
-            return False
-
-    # ---------- 是否為基督信仰相關問題 ----------
-    async def _is_christian_question(self, user_text: str, history: List[Dict[str, str]]) -> bool:
-        christian_router_prompt = [
-            {"role": "system", "content": """你是一個判斷器，只判斷用戶問題是否涉及基督信仰、耶穌教導、聖經應用到生活、祈禱、靈性成長等。
-如果是純粹查聖經經文或神學解釋 → yes
-如果只是一般知識或時事 → no
-只回單字：yes 或 no。不要加任何解釋。
-
-範例：
-用戶：約翰福音3:16解釋 → yes
-用戶：如何禱告？ → yes
-用戶：今天天氣如何？ → no
-用戶：量子計算是什麼？ → no"""},
-            *history,
-            {"role": "user", "content": user_text}
-        ]
-        try:
-            decision = await self._try_model(FALLBACK_MODELS[0], christian_router_prompt, max_tokens=10)
-            decision = decision.strip().lower()
-            print(f"基督信仰判斷：{decision}（問題：{user_text}）")
-            return decision == "yes"
-        except Exception as e:
-            print(f"基督信仰判斷失敗，預設否：{e}")
-            return False
+        return "孩子，抱歉，此刻我無法清楚回應你的話。請稍後再試，願父保守你平安。"
 
-    def get_conversation_history(self, user_id: str) -> List[Dict[str, str]]:
-        return conversations.get(user_id, [])
+    async def generate_response(self, user_id: str, user_text: str) -> str:
+        # 特殊指令
+        if user_text.strip().lower() == "/clear":
+            self.clear_history(user_id)
+            return "對話紀錄已清除，孩子，願你平安。我們重新開始吧。"
 
-    def update_conversation_history(self, user_id: str, messages: List[Dict[str, str]]):
-        conversations[user_id] = messages[-20:]
+        history = self.get_history(user_id)
 
-    def clear_conversation_history(self, user_id: str):
-        conversations.pop(user_id, None)
-        pending_chunks.pop(user_id, None)
+        messages = [
+            {"role": "system", "content": JESUS_PROMPT},
+            *history,
+            {"role": "user", "content": user_text}
+        ]
 
-    async def answer_question(self, user_id: str, user_text: str) -> str:
-        if user_text.strip().lower() == "/clear":
-            self.clear_conversation_history(user_id)
-            return "對話紀錄已清除！現在開始新的對話。"
-        
-        history = self.get_conversation_history(user_id)
-        
-        # 判斷是否為基督信仰問題
-        is_christian = await self._is_christian_question(user_text, history)
-        
-        # 判斷是否需要網路搜尋（信仰問題通常不需要最新資訊）
-        needs_search = False if is_christian else await self._needs_search(user_text, history)
-        
-        search_results = None
-        if needs_search:
-            search_results = await asyncio.to_thread(perform_web_search, user_text)
-        
-        # 建構 messages
-        if is_christian:
-            messages = [{"role": "system", "content": JESUS_PROMPT}]
-        else:
-            messages = [{"role": "system", "content": SYSTEM_PROMPT}]
-        
-        messages.extend(history)
-        messages.append({"role": "user", "content": user_text})
-        
-        # 網路資訊放入 assistant role（更安全）
-        if search_results and "沒有找到" not in search_results and "錯誤" not in search_results:
-            messages.append({"role": "assistant", "content": search_results + "\n請根據以上最新資訊（如相關）來補充回答。"})
-        
         response = await self._llm_call_with_fallback(messages)
-        response = response.replace('*', '')  # 移除可能的 markdown 星號
-        
-        # 更新歷史
-        history.append({"role": "user", "content": user_text})
-        history.append({"role": "assistant", "content": response})
-        self.update_conversation_history(user_id, history)
-        
-        # 長回應處理（改良摘要 prompt）
-        chunks = split_text_for_line(response)
-        if len(chunks) > 5:
-            summary_prompt = [
-                {"role": "system", "content": """請將以下長回覆壓縮成一個簡潔但完整的中文摘要。
-要求：
-- 保留所有關鍵事實、步驟、結論
-- 控制在 1800 字元以內（約手機 5 則訊息）
-- 保持條列格式，讓手機好讀
-- 結尾加一句：「（這是摘要，完整內容請回覆『繼續』查看）」"""},
-                {"role": "user", "content": response}
-            ]
-            try:
-                summary = await self._llm_call_with_fallback(summary_prompt)
-                summary = summary.replace('*', '')
-                return summary
-            except:
-                return response  # 摘要失敗就給完整內容
-        
+        response = response.replace('*', '').strip()  # 移除可能的 markdown
+
+        self.update_history(user_id, user_text, response)
         return response
 
-# ---------- FastAPI ----------
+# ==== FastAPI ====
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    global chat_pipeline
-    chat_pipeline = ChatPipeline()
+    global pipeline
+    pipeline = ChatPipeline()
     yield
 
 app = FastAPI(lifespan=lifespan)
-chat_pipeline = None
+pipeline = None
 
 configuration = Configuration(access_token=CHANNEL_ACCESS_TOKEN)
-async_api_client = AsyncApiClient(configuration)
-line_bot_api = AsyncMessagingApi(async_api_client)
+async_client = AsyncApiClient(configuration)
+line_bot_api = AsyncMessagingApi(async_client)
 parser = WebhookParser(CHANNEL_SECRET)
 
 @app.post("/webhook")
-async def line_webhook(request: Request):
-    signature = request.headers.get('X-Line-Signature', '')
+async def webhook(request: Request):
+    signature = request.headers.get("X-Line-Signature", "")
     body = await request.body()
-    
+
     try:
         events = parser.parse(body.decode(), signature)
     except InvalidSignatureError:
         raise HTTPException(status_code=400, detail="Invalid signature")
 
     for event in events:
-        if event.type != 'message' or event.message.type != 'text':
+        if event.type != "message" or event.message.type != "text":
             continue
 
         user_id = event.source.user_id
         reply_token = event.reply_token
-        user_text = event.message.text.strip()
+        text = event.message.text.strip()
 
-        if not user_text:
+        if not text:
             continue
 
-        try:
-            if user_text.lower() == "繼續" and user_id in pending_chunks:
-                remaining = pending_chunks[user_id]
-                if not remaining:
-                    ai_response = "沒有更多內容了。"
-                else:
-                    send_count = min(5, len(remaining))
-                    chunks_to_send = remaining[:send_count]
-                    messages_to_send = [TextMessage(text=chunk) for chunk in chunks_to_send]
-                    if len(remaining) > send_count:
-                        messages_to_send[-1].text += "\n\n內容過長，請回覆「繼續」查看下一部分。"
-                        pending_chunks[user_id] = remaining[send_count:]
-                    else:
-                        messages_to_send[-1].text += "\n\n內容已全部發送。"
-                        pending_chunks.pop(user_id, None)
-                    
-                    await line_bot_api.reply_message(ReplyMessageRequest(reply_token=reply_token, messages=messages_to_send))
-                    continue
-
-            ai_response = await chat_pipeline.answer_question(user_id, user_text)
-            chunks = split_text_for_line(ai_response)
-
-            if len(chunks) <= 5:
-                messages_to_send = [TextMessage(text=chunk) for chunk in chunks]
+        # 「繼續」功能
+        if text.lower() == "繼續" and user_id in pending_chunks:
+            remaining = pending_chunks[user_id]
+            if not remaining:
+                reply_text = "沒有更多內容了，孩子。"
             else:
-                chunks_to_send = chunks[:5]
-                messages_to_send = [TextMessage(text=chunk) for chunk in chunks_to_send]
-                messages_to_send[-1].text += "\n\n內容過長，請回覆「繼續」查看下一部分。"
-                pending_chunks[user_id] = chunks[5:]
+                to_send = remaining[:5]
+                messages = [TextMessage(text=chunk) for chunk in to_send]
+                if len(remaining) > 5:
+                    messages[-1].text += "\n\n（還有內容，請再回覆「繼續」）"
+                    pending_chunks[user_id] = remaining[5:]
+                else:
+                    messages[-1].text += "\n\n（已全部顯示）"
+                    pending_chunks.pop(user_id, None)
+                await line_bot_api.reply_message(ReplyMessageRequest(reply_token=reply_token, messages=messages))
+                continue
 
-            await line_bot_api.reply_message(ReplyMessageRequest(reply_token=reply_token, messages=messages_to_send))
+        # 一般回應
+        response = await pipeline.generate_response(user_id, text)
+        chunks = split_text_for_line(response)
+
+        if len(chunks) <= 5:
+            messages = [TextMessage(text=chunk) for chunk in chunks]
+        else:
+            messages = [TextMessage(text=chunk) for chunk in chunks[:5]]
+            messages[-1].text += "\n\n（內容較長，請回覆「繼續」查看下一部分）"
+            pending_chunks[user_id] = chunks[5:]
+
+        await line_bot_api.reply_message(ReplyMessageRequest(reply_token=reply_token, messages=messages))
 
-        except Exception as e:
-            print(f"Error processing message: {e}")
-            await line_bot_api.reply_message(
-                ReplyMessageRequest(
-                    reply_token=reply_token,
-                    messages=[TextMessage(text="抱歉，系統發生錯誤，請稍後再試。")]
-                )
-            )
-    
     return {"status": "ok"}
 
 @app.get("/health")
-async def health_check():
+async def health():
     return {"status": "ok"}
 
-@app.get("/")
-async def root():
-    return {"message": "LINE Bot is running"}
-
 if __name__ == "__main__":
     port = int(os.getenv("PORT", 7860))
     uvicorn.run(app, host="0.0.0.0", port=port)