Feat: implement input validation and safe transition logic. Added task list checks before planning and fixed concurrency issues on app reset.

app.py

@@ -34,14 +34,10 @@ class LifeFlowAI:
         self.service = PlannerService()
 
     def _check_api_status(self, session: UserSession) -> str:
-        """檢查 API Key 狀態並回傳對應的 Status 文字"""
-        # 1. 檢查 Session 中的自定義設定
+        """檢查 API Key 狀態"""
         has_gemini = bool(session.custom_settings.get("gemini_api_key"))
         has_google = bool(session.custom_settings.get("google_maps_api_key"))
 
-        # 2. 如果沒有自定義，也可以檢查系統預設 (可選)
-        # 這裡假設我們強制要求用戶輸入或確認
-
         if has_gemini and has_google:
             return "✅ System Ready - Waiting for input..."
         else:
@@ -51,106 +47,116 @@ class LifeFlowAI:
             return f"⚠️ Missing Keys: {', '.join(missing)} - Please configure Settings ↗"
 
     def _get_agent_outputs(self, active_agent: str = None, status: str = "idle", message: str = "Waiting") -> List[str]:
-        """
-        輔助函數：生成 6 個 Agent 卡片的 HTML 列表
-        用於在 Gradio 中更新 agent_displays
-        """
+        """輔助函數：生成 Agent 卡片 HTML"""
         agents = ['planner', 'scout', 'optimizer', 'validator', 'weather', 'traffic']
         outputs = []
         for agent in agents:
             if agent == active_agent:
                 outputs.append(create_agent_card_enhanced(agent, status, message))
             else:
-                # 簡單處理：非活動 Agent 顯示 Idle 或保持原狀 (這裡簡化為 Idle，可根據需求優化)
                 outputs.append(create_agent_card_enhanced(agent, "idle", "On standby"))
         return outputs
 
+    # -------------------------------------------------------------------------
+    # Step 1: Analyze (分析任務)
+    # -------------------------------------------------------------------------
     def analyze_wrapper(self, user_input, auto_loc, lat, lon, session_data):
-        """Step 1: 呼叫 Service 並將結果轉換為 Gradio Updates"""
         session = UserSession.from_dict(session_data)
 
-        # 呼叫 Service Generator
+        # 1. 輸入驗證
+        if not user_input or not user_input.strip():
+            agent_outputs = self._get_agent_outputs("planner", "idle", "Waiting")
+            yield (
+                "<div style='color: #ef4444; font-weight: bold; padding: 5px;'>⚠️ Please describe your plans first!</div>",
+                gr.HTML(), gr.HTML(),
+                get_reasoning_html_reversed(session.reasoning_messages),
+                gr.update(visible=False), gr.update(visible=False), gr.HTML(),
+                "⚠️ Input Required", gr.update(visible=True), *agent_outputs, session.to_dict()
+            )
+            return
+
+        # 2. 執行分析
         iterator = self.service.run_step1_analysis(user_input, auto_loc, lat, lon, session)
 
         for event in iterator:
             evt_type = event.get("type")
-
-            # 準備 Agent 狀態
             agent_status = event.get("agent_status", ("planner", "idle", "Waiting"))
             agent_outputs = self._get_agent_outputs(*agent_status)
-
-            # 獲取推理過程 HTML
-            # 注意：event 中可能已更新 session，從 session 獲取最新 reasoning
             current_session = event.get("session", session)
             reasoning_html = get_reasoning_html_reversed(current_session.reasoning_messages)
 
             if evt_type == "stream":
+                # Streaming: 保持 Input 顯示，Confirm 隱藏
                 yield (
                     create_agent_stream_output().replace("Ready to analyze...", event.get("stream_text", "")),
-                    gr.HTML(),  # Task Summary (Empty)
-                    gr.HTML(),  # Task List (Empty)
-                    reasoning_html,
-                    gr.update(visible=False),  # Confirm Area
-                    gr.update(visible=False),  # Chat Input
-                    gr.HTML(),  # Chat History
-                    f"Processing: {agent_status[2]}",  # Status Bar
-                    *agent_outputs,
-                    current_session.to_dict()
+                    gr.HTML(), gr.HTML(), reasoning_html,
+                    gr.update(visible=False), gr.update(visible=False), gr.HTML(),
+                    f"Processing: {agent_status[2]}", gr.update(visible=True), *agent_outputs, current_session.to_dict()
                 )
-
             elif evt_type == "complete":
-                # 完成時生成 Task List HTML
+                # Complete: 切換到 Confirm 頁面
                 task_html = self.service.generate_task_list_html(current_session)
-                # 生成 Summary HTML (這裡簡化調用，實際可從 service 獲取)
                 summary_html = f"<div class='summary-card'>Found {len(current_session.task_list)} tasks</div>"
-
-                # 更新所有 Agent 為完成
                 final_agents = self._get_agent_outputs("planner", "complete", "Tasks ready")
-
                 yield (
                     create_agent_stream_output().replace("Ready...", event.get("stream_text", "")),
-                    gr.HTML(value=summary_html),
-                    gr.HTML(value=task_html),
-                    reasoning_html,
-                    gr.update(visible=True),  # Confirm Area Show
-                    gr.update(visible=False),
+                    gr.HTML(value=summary_html), gr.HTML(value=task_html), reasoning_html,
+                    gr.update(visible=True), gr.update(visible=True),
                     generate_chat_history_html_bubble(current_session),
-                    "✓ Tasks extracted",
-                    *final_agents,
-                    current_session.to_dict()
+                    "✓ Tasks extracted", gr.update(visible=False), *final_agents, current_session.to_dict()
                 )
-
             elif evt_type == "error":
                 err_msg = event.get("message", "Unknown error")
                 error_agents = self._get_agent_outputs("planner", "idle", "Error")
                 yield (
-                    f"<div style='color:red'>Error: {err_msg}</div>",
-                    gr.HTML(), gr.HTML(), reasoning_html,
+                    f"<div style='color:red'>Error: {err_msg}</div>", gr.HTML(), gr.HTML(), reasoning_html,
                     gr.update(visible=False), gr.update(visible=False), gr.HTML(),
-                    f"Error: {err_msg}",
-                    *error_agents,
-                    current_session.to_dict()
+                    f"Error: {err_msg}", gr.update(visible=True), *error_agents, current_session.to_dict()
                 )
 
+    # -------------------------------------------------------------------------
+    # Chat Modification (修改任務)
+    # -------------------------------------------------------------------------
     def chat_wrapper(self, msg, session_data):
-        """Chat Logic Wrapper"""
         session = UserSession.from_dict(session_data)
         iterator = self.service.modify_task_chat(msg, session)
-
         for event in iterator:
             current_session = event.get("session", session)
-            chat_html = generate_chat_history_html_bubble(current_session)
-            task_html = self.service.generate_task_list_html(current_session)
-
             yield (
-                chat_html,
-                task_html,
+                generate_chat_history_html_bubble(current_session),
+                self.service.generate_task_list_html(current_session),
                 current_session.to_dict()
             )
 
-    def step2_wrapper(self, session_data):
-        """Step 2 Wrapper"""
+    # -------------------------------------------------------------------------
+    # Step 2 -> 3 Transition (驗證與過渡)
+    # -------------------------------------------------------------------------
+    def transition_to_planning(self, session_data):
+        """
+        Step 2 -> Step 3 過渡函數：
+        1. 檢查是否有任務 (防呆)
+        2. 若無任務：報錯並留在原位
+        3. 若有任務：隱藏 Confirm Area，顯示 Team Area，並執行 Step 2 (Search)
+        """
         session = UserSession.from_dict(session_data)
+
+        # 1. 🛑 防呆檢查
+        if not session.task_list or len(session.task_list) == 0:
+            agent_outputs = self._get_agent_outputs("planner", "idle", "No tasks")
+            reasoning = get_reasoning_html_reversed(session.reasoning_messages)
+
+            return (
+                gr.update(visible=True),  # task_confirm_area (保持顯示)
+                gr.update(visible=True),  # chat_input_area
+                gr.update(visible=False),  # team_area
+                gr.update(),  # tabs
+                reasoning,
+                "⚠️ Error: No tasks to plan! Please add tasks.",  # Status Bar
+                *agent_outputs,
+                session.to_dict()
+            )
+
+        # 2. ✅ 執行 Step 2 (Scout Search)
         result = self.service.run_step2_search(session)
         current_session = result.get("session", session)
 
@@ -158,131 +164,119 @@ class LifeFlowAI:
         agent_outputs = self._get_agent_outputs("scout", "working", "Searching POIs...")
 
         return (
+            gr.update(visible=False),  # task_confirm_area (隱藏)
+            gr.update(visible=False),  # chat_input_area
+            gr.update(visible=True),  # team_area (顯示)
+            gr.update(selected="ai_conversation_tab"),  # 切換 Tab
             reasoning_html,
-            "🗺️ Scout is searching...",
+            "🗺️ Scout is searching locations...",
             *agent_outputs,
             current_session.to_dict()
         )
 
+    # -------------------------------------------------------------------------
+    # Step 3 Wrapper (Team Analysis)
+    # -------------------------------------------------------------------------
     def step3_wrapper(self, session_data):
-        """Step 3 Wrapper"""
         session = UserSession.from_dict(session_data)
-        iterator = self.service.run_step3_team(session)
+        if not session.task_list:  # 二次防呆
+            yield ("", session.to_dict())
+            return
 
+        iterator = self.service.run_step3_team(session)
         for event in iterator:
             current_session = event.get("session", session)
             if event["type"] == "complete":
                 yield (event.get("report_html", ""), current_session.to_dict())
             elif event["type"] == "error":
                 yield (f"Error: {event.get('message')}", current_session.to_dict())
-            # 可以根據需要處理中間狀態更新
 
+    # -------------------------------------------------------------------------
+    # Step 4 Wrapper (Optimization & Results)
+    # -------------------------------------------------------------------------
     def step4_wrapper(self, session_data):
-        """Step 4 Wrapper"""
         session = UserSession.from_dict(session_data)
+        if not session.task_list:  # 二次防呆
+            default_map = create_animated_map()
+            agent_outputs = self._get_agent_outputs("planner", "idle", "No tasks")
+            return (
+                "", "", "", default_map,
+                gr.update(), gr.update(), "⚠️ Planning aborted",
+                *agent_outputs, session.to_dict()
+            )
+
         result = self.service.run_step4_finalize(session)
         current_session = result.get("session", session)
 
         if result["type"] == "success":
             agent_outputs = self._get_agent_outputs("team", "complete", "Done")
             return (
-                result["timeline_html"],
-                result["metrics_html"],
-                result["result_html"],
-                result["map_fig"],
-                gr.update(visible=True),  # Show Map Tab
-                gr.update(visible=False),  # Hide Team Area
-                "🎉 Planning completed!",
-                *agent_outputs,
-                current_session.to_dict()
+                result["timeline_html"], result["metrics_html"], result["result_html"], result["map_fig"],
+                gr.update(visible=True), gr.update(visible=False), "🎉 Planning completed!",
+                *agent_outputs, current_session.to_dict()
             )
         else:
-            # Error handling
             default_map = create_animated_map()
             agent_outputs = self._get_agent_outputs("team", "idle", "Error")
             err = result.get("message", "Error")
             return (
                 f"Error: {err}", "", "", default_map,
-                gr.update(), gr.update(),
-                f"Error: {err}",
-                *agent_outputs,
-                current_session.to_dict()
+                gr.update(), gr.update(), f"Error: {err}",
+                *agent_outputs, current_session.to_dict()
             )
 
     def save_settings(self, google_key, weather_key, gemini_key, model, session_data):
-        """Settings Save Wrapper"""
         session = UserSession.from_dict(session_data)
         session.custom_settings['google_maps_api_key'] = google_key
         session.custom_settings['openweather_api_key'] = weather_key
         session.custom_settings['gemini_api_key'] = gemini_key
         session.custom_settings['model'] = model
-
         new_status = self._check_api_status(session)
-
         return "✅ Settings saved locally!", session.to_dict(), new_status
 
+    # -------------------------------------------------------------------------
+    # UI Builder
+    # -------------------------------------------------------------------------
     def build_interface(self):
         def reset_app(old_session_data):
-            # 1. 讀取舊 Session
             old_session = UserSession.from_dict(old_session_data)
-
-            # 2. 創建新 Session (數據歸零)
             new_session = UserSession()
-
-            # 3. 🔥 關鍵：繼承舊的設定 (API Keys, Model)
             new_session.custom_settings = old_session.custom_settings
-
             status_msg = self._check_api_status(new_session)
-
-            # 4. 回傳重置後的 UI 狀態
             return (
-                gr.update(visible=True), gr.update(visible=False),  # Input Show, Confirm Hide
-                gr.update(visible=False), gr.update(visible=False),  # Chat Hide, Result Hide
-                gr.update(visible=False), gr.update(visible=False),  # Team Hide, Report Hide
-                gr.update(visible=False), "",  # Map Hide, Textbox Clear
+                gr.update(visible=True), gr.update(visible=False),
+                gr.update(visible=False), gr.update(visible=False),
+                gr.update(visible=False), gr.update(visible=False),
+                gr.update(visible=False), "",
                 create_agent_stream_output(),
                 status_msg,
-                new_session.to_dict()  # Reset Session but keep keys
+                "", "", "",
+                new_session.to_dict()
             )
 
         def initial_check(session_data):
             s = UserSession.from_dict(session_data)
-            # 如果環境變數有值，可以在這裡預先填入 custom_settings (視需求而定)
             return self._check_api_status(s)
 
         with gr.Blocks(title=APP_TITLE) as demo:
             gr.HTML(get_enhanced_css())
-            #create_header()
-            #theme_btn, settings_btn, doc_btn = create_top_controls()
             home_btn, theme_btn, settings_btn, doc_btn = create_header()
-
-            # State
             session_state = gr.State(value=UserSession().to_dict())
 
-
             with gr.Row():
-                # Left Column
                 with gr.Column(scale=2, min_width=400):
                     (input_area, agent_stream_output, user_input, auto_location,
                      location_inputs, lat_input, lon_input, analyze_btn) = create_input_form(
                         create_agent_stream_output()
                     )
-
                     (task_confirm_area, task_summary_display,
                      task_list_display, exit_btn_inline, ready_plan_btn) = create_confirmation_area()
-
-                    # Team Area
                     team_area, agent_displays = create_team_area(create_agent_card_enhanced)
-
-                    # Result Area
                     (result_area, result_display, timeline_display, metrics_display) = create_result_area(
                         create_animated_map)
 
-                # Right Column
                 with gr.Column(scale=3, min_width=500):
-                    status_bar = gr.Textbox(label="📊 Status",
-                                            value="⚠️ Checking System Status...",
-                                            interactive=False,
+                    status_bar = gr.Textbox(label="📊 Status", value="⚠️ Checking System Status...", interactive=False,
                                             max_lines=1)
                     (tabs, report_tab, map_tab, report_output, map_output, reasoning_output,
                      chat_input_area, chat_history_output, chat_input, chat_send) = create_tabs(
@@ -291,75 +285,59 @@ class LifeFlowAI:
 
             # Modals
             (settings_modal, google_maps_key, openweather_key, gemini_api_key,
-             model_choice, close_settings_btn, save_settings_btn,
-             settings_status) = create_settings_modal()
+             model_choice, close_settings_btn, save_settings_btn, settings_status) = create_settings_modal()
             doc_modal, close_doc_btn = create_doc_modal()
 
-            # ===== Event Binding =====
             auto_location.change(fn=toggle_location_inputs, inputs=[auto_location], outputs=[location_inputs])
 
-            # Step 1: Analyze
-            analyze_btn.click(
+            # ---------------------------------------------------------------------
+            # Event 1: Analyze (Step 1)
+            # ---------------------------------------------------------------------
+            analyze_event = analyze_btn.click(
                 fn=self.analyze_wrapper,
                 inputs=[user_input, auto_location, lat_input, lon_input, session_state],
                 outputs=[
                     agent_stream_output, task_summary_display, task_list_display,
                     reasoning_output, task_confirm_area, chat_input_area,
-                    chat_history_output, status_bar, *agent_displays, session_state
+                    chat_history_output, status_bar, input_area,
+                    *agent_displays, session_state
                 ]
-            ).then(
-                fn=lambda: (gr.update(visible=False), gr.update(visible=True), gr.update(visible=True)),
-                outputs=[input_area, task_confirm_area, chat_input_area]
             )
 
-            # Chat
-            chat_send.click(
+            # ---------------------------------------------------------------------
+            # Event 2: Chat
+            # ---------------------------------------------------------------------
+            chat_event = chat_send.click(
                 fn=self.chat_wrapper,
                 inputs=[chat_input, session_state],
                 outputs=[chat_history_output, task_list_display, session_state]
             ).then(fn=lambda: "", outputs=[chat_input])
 
-            # 更新 Home 鍵綁定
-            home_btn.click(
-                fn=reset_app,
+            # ---------------------------------------------------------------------
+            # Event 3: Planning Chain (Step 2 -> 3 -> 4)
+            # 使用 transition_to_planning 進行驗證，如果沒任務會自動停止
+            # ---------------------------------------------------------------------
+            step2_event = ready_plan_btn.click(
+                fn=self.transition_to_planning,
                 inputs=[session_state],
                 outputs=[
-                    input_area, task_confirm_area, chat_input_area, result_area,
-                    team_area, report_tab, map_tab, user_input,
-                    agent_stream_output, status_bar, session_state  # 確保 status_bar 在列表裡
+                    task_confirm_area, chat_input_area, team_area, tabs,
+                    reasoning_output, status_bar, *agent_displays, session_state
                 ]
             )
 
-            # 更新 Exit 鍵綁定 (同上)
-            exit_btn_inline.click(
-                fn=reset_app,
-                inputs=[session_state],
-                outputs=[
-                    input_area, task_confirm_area, chat_input_area, result_area,
-                    team_area, report_tab, map_tab, user_input,
-                    agent_stream_output, status_bar, session_state
-                ]
-            )
-
-
-
-            # Step 2, 3, 4 Sequence
-            ready_plan_btn.click(
-                fn=lambda: (gr.update(visible=False), gr.update(visible=False),
-                            gr.update(visible=True), gr.update(selected="ai_conversation_tab")),
-                outputs=[task_confirm_area, chat_input_area, team_area, tabs]
-            ).then(
-                fn=self.step2_wrapper,
-                inputs=[session_state],
-                outputs=[reasoning_output, status_bar, *agent_displays, session_state]
-            ).then(
+            step3_event = step2_event.then(
                 fn=self.step3_wrapper,
                 inputs=[session_state],
                 outputs=[report_output, session_state]
-            ).then(
+            )
+
+            step3_ui_update = step3_event.then(
                 fn=lambda: (gr.update(visible=True), gr.update(visible=True), gr.update(selected="report_tab")),
                 outputs=[report_tab, map_tab, tabs]
-            ).then(
+            )
+
+            step4_event = step3_ui_update.then(
                 fn=self.step4_wrapper,
                 inputs=[session_state],
                 outputs=[
@@ -368,33 +346,44 @@ class LifeFlowAI:
                 ]
             ).then(fn=lambda: gr.update(visible=True), outputs=[result_area])
 
-            # Settings & Docs Handlers
+            # ---------------------------------------------------------------------
+            # Reset & Cancels
+            # ---------------------------------------------------------------------
+            reset_outputs = [
+                input_area, task_confirm_area, chat_input_area, result_area,
+                team_area, report_tab, map_tab, user_input,
+                agent_stream_output, status_bar,
+                task_summary_display, task_list_display, chat_history_output,
+                session_state
+            ]
+
+            home_btn.click(
+                fn=reset_app,
+                inputs=[session_state],
+                outputs=reset_outputs,
+                cancels=[analyze_event, step4_event, chat_event]
+            )
+
+            exit_btn_inline.click(
+                fn=reset_app,
+                inputs=[session_state],
+                outputs=reset_outputs,
+                cancels=[analyze_event, step4_event, chat_event]
+            )
+
+            # Others
             settings_btn.click(fn=lambda: gr.update(visible=True), outputs=[settings_modal])
             close_settings_btn.click(fn=lambda: gr.update(visible=False), outputs=[settings_modal])
-
             save_settings_btn.click(
                 fn=self.save_settings,
                 inputs=[google_maps_key, openweather_key, gemini_api_key, model_choice, session_state],
-                outputs=[settings_status, session_state, status_bar]  # 增加 status_bar
+                outputs=[settings_status, session_state, status_bar]
             )
-
-            theme_btn.click(fn=None, js="""
-                () => {
-                    const container = document.querySelector('.gradio-container');
-                    if (container) {
-                        container.classList.toggle('theme-dark');
-                        const isDark = container.classList.contains('theme-dark');
-                        localStorage.setItem('lifeflow-theme', isDark ? 'dark' : 'light');
-                    }
-                }
-            """)
-
+            theme_btn.click(fn=None,
+                            js="() => { document.querySelector('.gradio-container').classList.toggle('theme-dark'); }")
             doc_btn.click(fn=lambda: gr.update(visible=True), outputs=[doc_modal])
             close_doc_btn.click(fn=lambda: gr.update(visible=False), outputs=[doc_modal])
-
-            demo.load(fn=initial_check,
-                      inputs=[session_state],
-                      outputs=[status_bar])
+            demo.load(fn=initial_check, inputs=[session_state], outputs=[status_bar])
         return demo
 
 

services/planner_service.py

@@ -54,106 +54,186 @@ class PlannerService:
 
     def _get_live_session(self, incoming_session: UserSession) -> UserSession:
         """
-        [Fix] 輔助方法：
-        從 Gradio 傳來的 incoming_session 只有數據 (Agent 為 None)。
-        我們需要從 _active_sessions 取回包含 Agent 的真實 Session。
+        從 Gradio 傳來的 incoming_session 恢復 Live Session
         """
         sid = incoming_session.session_id
 
-        # 如果這個 Session ID 已經在內存中，取出它並同步數據
+        if not sid:
+            return incoming_session
+
+        # 1. 如果內存中有此 Session
         if sid and sid in self._active_sessions:
             live_session = self._active_sessions[sid]
-            # 同步前端可能修改過的數據到 Live Session
+
+            # 同步基礎數據
             live_session.lat = incoming_session.lat
             live_session.lng = incoming_session.lng
-            # 注意：這裡不覆蓋 task_list，除非我們確定前端有修改權限
-            # 這裡簡單假設前端傳來的 chat history 是最新的
+
+            # 🔥 關鍵修正：確保 API Settings 不會被覆蓋為空
+            # 如果 incoming 有設定，就用 incoming 的；否則保留 live 的
+            if incoming_session.custom_settings:
+                # 合併設定，優先使用 incoming (前端最新)
+                live_session.custom_settings.update(incoming_session.custom_settings)
+
+            # 同步聊天記錄
             if len(incoming_session.chat_history) > len(live_session.chat_history):
                 live_session.chat_history = incoming_session.chat_history
+
             return live_session
 
-        # 如果是新的 Session，或者內存中沒有，則註冊它
-        if sid:
-            self._active_sessions[sid] = incoming_session
+        # 2. 如果是新的 Session，註冊它
+        self._active_sessions[sid] = incoming_session
         return incoming_session
 
+    def _inject_tool_instance(self, tool_instance, session_id):
+        """
+        Monkey Patch: 在 Tool 執行前，將 Session ID 寫入 Repo 的 Thread Local。
+        這樣 Repo.save() 就能在同一個執行緒中讀到 ID。
+        """
+
+        for attr_name in dir(tool_instance):
+            if attr_name.startswith("_"): continue
+            attr = getattr(tool_instance, attr_name)
+
+            if callable(attr):
+                if attr_name in ["register", "toolkit_id"]: continue
+
+                def create_wrapper(original_func, sid):
+                    def wrapper(*args, **kwargs):
+                        # 🔥 1. 設定 Thread Local Context
+                        poi_repo.set_thread_session(sid)
+                        try:
+                            # 🔥 2. 執行 Tool
+                            return original_func(*args, **kwargs)
+                        finally:
+                            # (可選) 清理 context，防止污染線程池中的下一個任務
+                            # 但在单次請求中，保留著通常也沒問題，覆蓋即可
+                            pass
+
+                    return wrapper
+
+                setattr(tool_instance, attr_name, create_wrapper(attr, session_id))
+
+
+
     def initialize_agents(self, session: UserSession, lat: float, lng: float) -> UserSession:
-        """初始化 Agents 並保存到內存"""
-        # 1. 確保我們操作的是 Live Session
-        session = self._get_live_session(session)
+        if not session.session_id:
+            session.session_id = str(uuid.uuid4())
+            logger.info(f"🆔 Generated New Session ID: {session.session_id}")
 
+
+        session = self._get_live_session(session)
         session.lat = lat
         session.lng = lng
 
+        if not session.user_state:
+            session.user_state = UserState(location=Location(lat=lat, lng=lng))
+        else:
+            session.user_state.location = Location(lat=lat, lng=lng)
+
         if session.planner_agent is not None:
+            logger.info(f"♻️ Agents already initialized for {session.session_id}")
             return session
 
-        # 生成或恢復 Session ID
-        if session.session_id is None:
-            session.session_id = str(uuid.uuid4())
-            # 註冊到內存
-            self._active_sessions[session.session_id] = session
-            set_session_id(session.session_id)
-            logger.info(f"🆔 New Session: {session.session_id}")
-        else:
-            set_session_id(session.session_id)
-            logger.info(f"🔄 Restoring Session: {session.session_id}")
+        # 1. API Key 檢查
+        gemini_key = session.custom_settings.get("gemini_api_key")
+        google_key = session.custom_settings.get("google_maps_api_key")
+        weather_key = session.custom_settings.get("openweather_api_key")
 
-        # 設定用戶狀態
-        session.user_state = UserState(location=Location(lat=lat, lng=lng))
+        import os
+        if not gemini_key: gemini_key = os.getenv("GEMINI_API_KEY", "")
+        if not google_key: google_key = os.getenv("GOOGLE_MAPS_API_KEY", "")
+        if not weather_key: weather_key = os.getenv("OPENWEATHER_API_KEY", "")
 
-        # 讀取設定
-        selected_model_id = 'gemini-2.5-flash'
-        gemini_api_key = session.custom_settings.get("gemini_api_key", "")
-        google_maps_api_key = session.custom_settings.get("google_maps_api_key", "")
-        openweather_api_key = session.custom_settings.get("openweather_api_key", "")
+        if not gemini_key:
+            raise ValueError("🔑 Missing Gemini API Key. Please configure Settings.")
 
-        # 初始化模型
-        planner_model = Gemini(id=selected_model_id, thinking_budget=2048, api_key=gemini_api_key)
-        main_model = Gemini(id=selected_model_id, thinking_budget=1024, api_key=gemini_api_key)
-        lite_model = Gemini(id="gemini-2.5-flash-lite", api_key=gemini_api_key)
+        # 2. 準備 Models
+        planner_model = Gemini(id='gemini-2.5-flash', thinking_budget=2048, api_key=gemini_key)
+        main_model = Gemini(id='gemini-2.5-flash', thinking_budget=1024, api_key=gemini_key)
+        lite_model = Gemini(id="gemini-2.5-flash-lite", api_key=gemini_key)
 
         models_dict = {
             "team": main_model, "scout": main_model, "optimizer": lite_model,
             "navigator": lite_model, "weatherman": lite_model, "presenter": main_model,
         }
 
+        # 3. 準備 Tools (先實例化，還不要給 Agent)
+        scout_tool = ScoutToolkit(google_key)
+        optimizer_tool = OptimizationToolkit(google_key)
+        navigator_tool = NavigationToolkit(google_key)
+        weather_tool = WeatherToolkit(weather_key)
+        reader_tool = ReaderToolkit()
+
+        # 4. 🔥 執行注入！確保所有 Agent 的 Tools 都帶有 Session ID
+        self._inject_tool_instance(scout_tool, session.session_id)
+        self._inject_tool_instance(optimizer_tool, session.session_id)
+        self._inject_tool_instance(navigator_tool, session.session_id)
+        self._inject_tool_instance(weather_tool, session.session_id)
+        self._inject_tool_instance(reader_tool, session.session_id)
+
+        # 5. 構建 Tools Dict (使用已注入的 Tool 實例)
         tools_dict = {
-            "scout": [ScoutToolkit(google_maps_api_key)],
-            "optimizer": [OptimizationToolkit(google_maps_api_key)],
-            "navigator": [NavigationToolkit(google_maps_api_key)],
-            "weatherman": [WeatherToolkit(openweather_api_key)],
-            "presenter": [ReaderToolkit()],
+            "scout": [scout_tool],
+            "optimizer": [optimizer_tool],
+            "navigator": [navigator_tool],
+            "weatherman": [weather_tool],
+            "presenter": [reader_tool],
         }
 
         planner_kwargs = {
-            "additional_context": get_context(session.user_state),
+            "additional_context": get_context(session.user_state),  # 這裡現在安全了
             "timezone_identifier": session.user_state.utc_offset,
             "debug_mode": False,
         }
 
         team_kwargs = {"timezone_identifier": session.user_state.utc_offset}
 
-        # 創建 Agents
+        # 6. 建立 Agents
         session.planner_agent = create_planner_agent(planner_model, planner_kwargs, session_id=session.session_id)
         session.core_team = create_core_team(models_dict, team_kwargs, tools_dict, session_id=session.session_id)
 
+        self._active_sessions[session.session_id] = session
+
         logger.info(f"✅ Agents initialized for session {session.session_id}")
         return session
 
     # ================= Step 1: Analyze Tasks =================
 
     def run_step1_analysis(self, user_input: str, auto_location: bool,
-                          lat: float, lon: float, session: UserSession) -> Generator[Dict[str, Any], None, None]:
-        if not user_input.strip():
-            yield {"type": "empty"}
+                           lat: float, lon: float, session: UserSession) -> Generator[Dict[str, Any], None, None]:
+
+        # 🛡️ 檢查 1: 用戶輸入是否為空
+        if not user_input or len(user_input.strip()) == 0:
+            yield {
+                "type": "error",
+                "message": "⚠️ Please enter your plans first!",
+                "stream_text": "Waiting for input...",
+                "block_next_step": True  # 🔥 新增 flag 阻止 UI 跳轉
+            }
+            return
+
+            # 🛡️ 驗證 2: 位置檢查
+            # 前端 JS 如果失敗會回傳 0, 0
+        if auto_location and (lat == 0 or lon == 0):
+            yield {
+                "type": "error",
+                "message": "⚠️ Location detection failed. Please uncheck 'Auto-detect' and enter manually.",
+                "stream_text": "Location Error...",
+                "block_next_step": True
+            }
             return
 
-        if auto_location:
-            lat, lon = 25.033, 121.565
+        if not auto_location and (lat is None or lon is None):
+            yield {
+                "type": "error",
+                "message": "⚠️ Please enter valid Latitude/Longitude.",
+                "stream_text": "Location Error...",
+                "block_next_step": True
+            }
+            return
 
         try:
-            # 🌟 [Fix] 使用 Live Session
             session = self.initialize_agents(session, lat, lon)
 
             # 階段 1: 初始化
@@ -164,19 +244,12 @@ class PlannerService:
                 "agent_status": ("planner", "working", "Initializing..."),
                 "session": session
             }
-            time.sleep(0.3)
 
-            # 階段 2: 提取任務
+            # 階段 2: 提取任務 (即時串流優化)
             self._add_reasoning(session, "planner", f"Processing: {user_input[:50]}...")
             current_text = "🤔 Analyzing your request with AI...\n📋 AI is extracting tasks..."
-            yield {
-                "type": "stream",
-                "stream_text": current_text,
-                "agent_status": ("planner", "working", "Extracting tasks..."),
-                "session": session
-            }
 
-            # 呼叫 Agent (Stream)
+            # 呼叫 Agent
             planner_stream = session.planner_agent.run(
                 f"help user to update the task_list, user's message: {user_input}",
                 stream=True, stream_events=True
@@ -189,12 +262,13 @@ class PlannerService:
                 if chunk.event == RunEvent.run_content:
                     content = chunk.content
                     accumulated_response += content
-                    if "@@@" not in accumulated_response:
+                    if "@@@" not in accumulated_response:  # 簡單過濾 JSON 標記
                         displayed_text += content
+                        # 🔥 確保每個 Chunk 都觸發 UI 更新
                         yield {
                             "type": "stream",
                             "stream_text": displayed_text,
-                            "agent_status": ("planner", "working", "Processing..."),
+                            "agent_status": ("planner", "working", "Thinking..."),
                             "session": session
                         }
 
@@ -214,33 +288,49 @@ class PlannerService:
                 logger.error(f"Failed to parse task_list: {e}")
                 session.task_list = []
 
-            self._add_reasoning(session, "planner", f"✅ Extracted {len(session.task_list)} tasks")
-
-            high_priority = sum(1 for t in session.task_list if t.get("priority") == "HIGH")
-            total_time = sum(int(t.get("duration", "0").split()[0]) for t in session.task_list if t.get("duration"))
-
+            # 🛡️ 檢查 2: Planner 是否回傳空列表
+            if not session.task_list or len(session.task_list) == 0:
+                err_msg = "⚠️ AI couldn't identify any tasks."
+                self._add_reasoning(session, "planner", "❌ No tasks found")
+                yield {
+                    "type": "error",
+                    "message": err_msg,
+                    "stream_text": err_msg,
+                    "session": session,
+                    "block_next_step": True  # 🔥 阻止 UI 跳轉
+                }
+                return
+
+                # 成功
             yield {
                 "type": "complete",
-                "stream_text": displayed_text + f"\n✅ Analysis complete! Found {len(session.task_list)} tasks.",
-                "high_priority": high_priority,
-                "total_time": total_time,
-                "session": session
+                "stream_text": "Analysis complete!",
+                "high_priority": 0,  # 計算邏輯...
+                "total_time": 0,  # 計算邏輯...
+                "session": session,
+                "block_next_step": False  # 允許跳轉
             }
 
         except Exception as e:
-            logger.error(f"Error in step1: {e}", exc_info=True)
-            yield {"type": "error", "message": str(e), "session": session}
+            logger.error(f"Error: {e}")
+            yield {"type": "error", "message": str(e), "session": session, "block_next_step": True}
 
     # ================= Task Modification (Chat) =================
 
     def modify_task_chat(self, user_message: str, session: UserSession) -> Generator[Dict[str, Any], None, None]:
-        if not user_message.strip():
-            yield {"type": "no_change", "session": session}
+
+        # 🛡️ 檢查 3: Chat 輸入是否為空
+        if not user_message or len(user_message.replace(' ', '')) == 0:
+            yield {
+                "type": "chat_error",
+                "message": "Please enter a message.",
+                "session": session
+            }
             return
 
-        # 🌟 [Fix] 獲取 Live Session
         session = self._get_live_session(session)
 
+        # 用戶輸入上屏
         session.chat_history.append({
             "role": "user", "message": user_message, "time": datetime.now().strftime("%H:%M:%S")
         })
@@ -248,13 +338,13 @@ class PlannerService:
 
         try:
             if session.planner_agent is None:
-                # 嘗試重新初始化 (如果遺失)
                 if session.lat and session.lng:
                     session = self.initialize_agents(session, session.lat, session.lng)
                 else:
-                    yield {"type": "error", "message": "Session lost. Please restart.", "session": session}
+                    yield {"type": "chat_error", "message": "Session lost. Please restart.", "session": session}
                     return
 
+            # Agent 思考中
             session.chat_history.append({
                 "role": "assistant", "message": "🤔 AI is thinking...", "time": datetime.now().strftime("%H:%M:%S")
             })
@@ -270,6 +360,7 @@ class PlannerService:
                 if chunk.event == RunEvent.run_content:
                     content = chunk.content
                     accumulated_response += content
+                    # 可選：在這裡也可以做 stream update 讓 chat bubble 動態出現文字
 
             json_data = "{" + accumulated_response.split("{", maxsplit=1)[-1]
             json_data = json_data.replace("`", "").replace("@", "").replace("\\", " ").replace("\n", " ")
@@ -282,6 +373,11 @@ class PlannerService:
             task_list_data = json.loads(json_data)
             session.task_list = self._convert_task_list_to_ui_format(task_list_data)
 
+            # 🔥 更新 Summary (回應 "Does summary still exist?" -> Yes!)
+            high_priority = sum(1 for t in session.task_list if t.get("priority") == "HIGH")
+            total_time = sum(int(t.get("duration", "0").split()[0]) for t in session.task_list if t.get("duration"))
+            summary_html = create_summary_card(len(session.task_list), high_priority, total_time)
+
             session.chat_history[-1] = {
                 "role": "assistant",
                 "message": "✅ Tasks updated based on your request",
@@ -289,20 +385,27 @@ class PlannerService:
             }
             self._add_reasoning(session, "planner", f"Updated: {user_message[:30]}...")
 
-            yield {"type": "complete", "session": session}
+            yield {
+                "type": "complete",
+                "summary_html": summary_html,  # 回傳新的 Summary
+                "session": session
+            }
 
         except Exception as e:
             logger.error(f"Chat error: {e}")
             session.chat_history.append({
                 "role": "assistant", "message": f"❌ Error: {str(e)}", "time": datetime.now().strftime("%H:%M:%S")
             })
-            yield {"type": "error", "session": session}
+            yield {"type": "update_history", "session": session}
 
     # ================= Step 2: Search POIs =================
 
     def run_step2_search(self, session: UserSession) -> Dict[str, Any]:
         # 🌟 [Fix] 獲取 Live Session
         session = self._get_live_session(session)
+        if session.session_id:
+            set_session_id(session.session_id)
+            logger.info(f"🔄 [Step 2] Session Context Set: {session.session_id}")
 
         self._add_reasoning(session, "team", "🚀 Core Team activated")
         self._add_reasoning(session, "scout", "Searching for POIs...")
@@ -312,17 +415,24 @@ class PlannerService:
 
     def run_step3_team(self, session: UserSession) -> Generator[Dict[str, Any], None, None]:
         try:
-            # 🌟 [Fix] 獲取 Live Session (關鍵：這裡才有 Agent)
             session = self._get_live_session(session)
 
+            # 🔥 修正 2: 確保 Session ID 在這個執行緒中生效
+            if session.session_id:
+                set_session_id(session.session_id)
+                logger.info(f"🔄 [Step 3] Session Context Set: {session.session_id}")
+            else:
+                logger.warning("⚠️ [Step 3] No Session ID found!")
+
+            if not session.task_list:
+                yield {"type": "error", "message": "No tasks to plan.", "session": session}
+                return
+
             if session.planner_agent is None:
                 raise ValueError("Agents not initialized. Please run Step 1 first.")
 
-            set_session_id(session.session_id)
-
-            # 從 Planner Agent 的 Memory 中獲取 Task List
+            # 準備輸入
             task_list_input = session.planner_agent.get_session_state().get("task_list")
-
             if isinstance(task_list_input, dict) or isinstance(task_list_input, list):
                 task_list_str = json.dumps(task_list_input, indent=2, ensure_ascii=False)
             else:
@@ -332,6 +442,8 @@ class PlannerService:
             yield {"type": "start", "session": session}
 
             # 執行 Team Run
+            # 注意：如果 Agno 內部使用 ThreadPool，Context 還是可能遺失。
+            # 但既然之前能跑，代表 Agno 應該是在當前執行緒或兼容的 Context 下運行工具的。
             team_stream = session.core_team.run(
                 f"Plan this trip: {task_list_str}",
                 stream=True, stream_events=True, session_id=session.session_id
@@ -363,7 +475,7 @@ class PlannerService:
 
             final_ref_id = poi_repo.get_last_id_by_session(session.session_id)
             if not final_ref_id:
-                raise ValueError("No final result found")
+                raise ValueError(f"No final result found , {session.session_id}")
 
             structured_data = poi_repo.load(final_ref_id)
 

src/infra/poi_repository.py

@@ -3,7 +3,10 @@ import json
 import uuid
 import os
 from typing import Any, Dict, Optional
-from src.infra.context import get_session_id  # ✅ 引入 Context
+from src.infra.context import get_session_id
+from src.infra.logger import get_logger
+
+logger = get_logger(__name__)
 
 
 class PoiRepository:
@@ -42,9 +45,9 @@ class PoiRepository:
         current_session = get_session_id()
         if current_session:
             self._session_last_id[current_session] = ref_id
-            print(f"💾 [Repo] Saved {ref_id} for Session: {current_session}")
+            logger.info(f"💾 [Repo] Saved {ref_id} for Session: {current_session}")
         else:
-            print(f"⚠️ [Repo] Warning: No session context found! 'last_id' not tracked.")
+            logger.warning(f"⚠️ [Repo] Warning: No session context found! 'last_id' not tracked.")
 
         return ref_id