Sync ling-space changes from GitHub commit 86dd25a

model_handler.py

@@ -68,6 +68,16 @@ class OpenAICompatibleProvider(ModelProvider):
         # Initialize assistant's response in chat_history
         chat_history.append({"role": "assistant", "content": ""}) # Placeholder for assistant's streaming response
 
+        # 日志输出 - 在这里打印完整的请求数据(system, history, user, model_id)
+        print("\n>>> DEBUG: get_response")
+        print(">>> DEBUG: Sending request to OpenAI-compatible API")
+        print(">>>      : System prompt:", repr(system_prompt))
+        print(">>>      : Chat history:", repr(chat_history))
+        print(">>>      : User message:", repr(message))
+        print(">>>      : Model ID:", repr(model_id))
+        print(">>>      : Temperature:", repr(temperature))
+
+        full_response = ""
         try:
             with httpx.stream(
                 "POST",
@@ -88,12 +98,14 @@ class OpenAICompatibleProvider(ModelProvider):
                                 delta = data["choices"][0].get("delta", {})
                                 content_chunk = delta.get("content")
                                 if content_chunk:
+                                    full_response += content_chunk
                                     chat_history[-1]["content"] += content_chunk
                                     yield chat_history
                         except json.JSONDecodeError:
                             print(f"Error decoding JSON chunk: {chunk}")
+                print(f"DEBUG: Full code response: {full_response}")
         except Exception as e:
-            print(f"Error during API call: {e}")
+            print(f"XXX DEBUG: Error during API call: {e}")
             # Ensure the last message (assistant's placeholder) is updated with the error
             if chat_history and chat_history[-1]["role"] == "assistant":
                 chat_history[-1]["content"] = f"An error occurred: {e}"
@@ -122,7 +134,15 @@ class OpenAICompatibleProvider(ModelProvider):
             "stream": True,
             "temperature": temperature,
         }
-
+        
+        print("\n>>> DEBUG: get_code_response")
+        print(">>> DEBUG: Sending request to OpenAI-compatible API")
+        print(">>>      : System prompt:", repr(system_prompt))
+        print(">>>      : User message:", repr(user_prompt))
+        print(">>>      : Model ID:", repr(model_id))
+        print(">>>      : Temperature:", repr(temperature))
+
+        full_response = ""
         try:
             with httpx.stream("POST", f"{self.api_base}/chat/completions", headers=headers, json=json_data, timeout=120) as response:
                 response.raise_for_status()
@@ -137,9 +157,11 @@ class OpenAICompatibleProvider(ModelProvider):
                                 delta = data["choices"][0].get("delta", {})
                                 content_chunk = delta.get("content")
                                 if content_chunk:
+                                    full_response += content_chunk
                                     yield content_chunk
                         except json.JSONDecodeError:
                             print(f"Error decoding JSON chunk: {chunk}")
+                print(f"DEBUG: Full code response: {full_response}")
         except Exception as e:
             print(f"Error during API call: {e}")
             yield f"An error occurred: {e}"
@@ -188,7 +210,7 @@ class ModelHandler:
         
         yield from provider.get_response(model_id, message, chat_history, system_prompt, temperature)
 
-    def generate_code(self, system_prompt, user_prompt, code_type, model_choice):
+    def generate_code(self, system_prompt, user_prompt, model_choice):
         """
         Generates code using the specified model.
         """
@@ -197,7 +219,6 @@ class ModelHandler:
              # Fallback if display name not found, maybe model_choice is the constant itself
              model_constant = model_choice if model_choice in CHAT_MODEL_SPECS else "LING_1T"
 
-
         model_spec = self.config.get(model_constant, {})
         provider_name = model_spec.get("provider")
         model_id = model_spec.get("model_id")

smart_writer_kit/__init__.py

@@ -0,0 +1 @@
+# This file makes the directory a Python package

smart_writer_kit/agent_for_inspiration_expansion.py

@@ -0,0 +1,101 @@
+import gradio as gr
+import pandas as pd
+from model_handler import ModelHandler
+from config import LING_1T
+
+def _format_df_to_string(df: pd.DataFrame, title: str) -> str:
+    """Formats a pandas DataFrame into a markdown-like string for the prompt."""
+    if df is None or df.empty:
+        return ""
+    
+    header = f"### {title}\n"
+    rows = []
+    for _, row in df.iterrows():
+        if 'Done' in df.columns and 'Task' in df.columns:
+            status = "[x]" if row['Done'] else "[ ]"
+            rows.append(f"- {status} {row['Task']}")
+        elif 'Term' in df.columns and 'Description' in df.columns:
+            rows.append(f"- **{row['Term']}**: {row['Description']}")
+    
+    return header + "\n".join(rows) + "\n\n"
+
+def fetch_inspiration_agent(prompt: str, editor_content: str, style: str, kb_df: pd.DataFrame, short_outline_df: pd.DataFrame, long_outline_df: pd.DataFrame):
+    """
+    Agent for fetching inspiration options using a real LLM.
+    """
+    print("\n[Agent][fetch_inspiration_agent] === 推理类型：灵感扩写 ===")
+    print("【发出的完整上下文】")
+    print("prompt:", repr(prompt))
+    print("editor_content:", repr(editor_content))
+    print("style:", repr(style))
+    print("kb_df:", repr(kb_df.to_dict("records")))
+    print("short_outline_df:", repr(short_outline_df.to_dict("records")))
+    print("long_outline_df:", repr(long_outline_df.to_dict("records")))
+
+    try:
+        # 1. Format context from UI inputs
+        style_context = f"### 整体章程\n{style}\n\n"
+        kb_context = _format_df_to_string(kb_df, "知识库")
+        short_outline_context = _format_df_to_string(short_outline_df, "当前章节大纲")
+        long_outline_context = _format_df_to_string(long_outline_df, "故事总纲")
+
+        # 2. Build System Prompt
+        system_prompt = (
+            "你是一个富有创意的长篇小说家，你的任务是根据提供的背景设定和当前文本，创作三个不同的、有创意的剧情发展方向。\n"
+            "请严格遵守以下格式：直接开始写第一个选项，然后用 `[END_OF_CHOICE]` 作为分隔符，接着写第二个选项，再用 `[END_OF_CHOICE]` 分隔，最后写第三个选项。不要有任何额外的解释或编号。\n"
+            "例如：\n"
+            "剧情发展一的内容...[END_OF_CHOICE]剧情发展二的内容...[END_OF_CHOICE]剧情发展三的内容..."
+        )
+        
+        # 3. Build User Prompt
+        full_context = style_context + kb_context + long_outline_context + short_outline_context
+        user_prompt = (
+            f"### 背景设定与大纲\n{full_context}\n"
+            f"### 当前已写内容 (末尾部分)\n{editor_content[-2000:]}\n\n"
+            f"### 用户指令\n{prompt if prompt else '请基于当前内容，自然地延续剧情。'}"
+        )
+
+        # 4. Call LLM
+        model_handler = ModelHandler()
+        response_generator = model_handler.generate_code(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            model_choice=LING_1T
+        )
+        
+        full_response = "".join(chunk for chunk in response_generator)
+
+        print("【收到的完整上下文】")
+        print("full_response:", repr(full_response))
+
+        # 5. Parse response and update UI
+        choices = full_response.split("[END_OF_CHOICE]")
+        # Ensure we have exactly 3 choices, padding with placeholders if necessary
+        choices += ["（模型未生成足够选项）"] * (3 - len(choices))
+        
+        print(f"[Agent] LLM Choices Received: {len(choices)}")
+
+        return gr.update(visible=True), choices[0].strip(), choices[1].strip(), choices[2].strip()
+
+    except Exception as e:
+        print(f"[Agent] Error fetching inspiration: {e}")
+        error_message = f"获取灵感时出错: {e}"
+        return gr.update(visible=True), error_message, "请检查日志", "请检查日志"
+
+
+def apply_inspiration_agent(current_text: str, inspiration_text: str):
+    """
+    Agent for applying selected inspiration to the editor.
+    """
+    print("\n[Agent][apply_inspiration_agent] === 推理类型：应用灵感 ===")
+    print("【发出的完整上下文】")
+    print("current_text:", repr(current_text))
+    print("inspiration_text:", repr(inspiration_text))
+    if not current_text:
+        new_text = inspiration_text
+    else:
+        new_text = current_text + "\n\n" + inspiration_text
+    print("【收到的完整上下文】")
+    print("new_text:", repr(new_text))
+    # Return a tuple that unpacks into the outputs for the Gradio event handler
+    return new_text, gr.update(visible=False), ""

smart_writer_kit/agent_for_kb_update.py

@@ -0,0 +1,75 @@
+import gradio as gr
+import pandas as pd
+import json
+from model_handler import ModelHandler
+from config import LING_1T
+
+def _format_kb_for_prompt(df: pd.DataFrame) -> str:
+    """Formats the knowledge base DataFrame into a simple list for the prompt."""
+    if df is None or df.empty:
+        return "无。"
+    terms = [f"- {row['Term']}" for _, row in df.iterrows()]
+    return "\n".join(terms)
+
+def suggest_new_kb_terms_agent(kb_df: pd.DataFrame, editor_content: str):
+    """
+    Agent to extract new terms from the text to recommend for the knowledge base using a real LLM.
+    """
+    
+    if editor_content is None or len(editor_content.strip()) < 50:
+        print("[Agent] Editor content too short, skipping KB suggestion.")
+        # Return empty data and keep components hidden
+        return gr.update(value=[], visible=False), gr.update(visible=False)
+
+    try:
+        # 1. Prepare Prompts
+        system_prompt = (
+            "你是一个实体提取机器人。你的任务是从给定文本中识别出新的、重要的、值得记录的专有名词（如人名、地名、组织、物品）或核心概念，并为它们提供一句简洁的描述。\n"
+            "你的回答必须是一个遵循以下规则的 JSON 数组：\n"
+            "1. 数组中的每个元素都是一个对象。\n"
+            "2. 每个对象必须包含两个键：`Term` (词条名) 和 `Description` (描述)。\n"
+            "3. 不要提取已经存在于'现有知识库'中的词条。\n"
+            "4. 最多返回 5 个最重要的词条。\n"
+            "5. 不要返回除了这个 JSON 数组之外的任何其他文本、解释或代码块标记。"
+        )
+        
+        kb_str = _format_kb_for_prompt(kb_df)
+        user_prompt = (
+            f"### 现有知识库\n{kb_str}\n\n"
+            f"### 当前文本\n{editor_content[-4000:]}\n\n"
+            "### 指令\n请根据'当前文本'，分析并提取出新的知识库词条，并返回 JSON 数组。"
+        )
+        
+        # 2. Call LLM
+        model_handler = ModelHandler()
+        response_generator = model_handler.generate_code(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            model_choice=LING_1T 
+        )
+        full_response = "".join(chunk for chunk in response_generator)
+        
+        # 3. Parse JSON and format for DataFrame
+        print("【收到的完整上下文】")
+        print("full_response:", repr(full_response))
+        
+        if full_response.strip().startswith("```json"):
+            full_response = full_response.strip()[7:-3].strip()
+            
+        suggested_terms = json.loads(full_response)
+        
+        # Convert list of dicts to list of lists for Gradio Dataframe
+        df_data = [[item.get("Term", ""), item.get("Description", "")] for item in suggested_terms]
+        
+        print("【收到的完整上下文】")
+        print("suggested_terms:", repr(suggested_terms))
+        
+        # Make components visible and return data
+        return gr.update(value=df_data, visible=True), gr.update(visible=True)
+
+    except json.JSONDecodeError:
+        print(f"[Agent] Error: Failed to decode JSON from LLM response for KB: {full_response}")
+        return gr.update(visible=False), gr.update(visible=False)
+    except Exception as e:
+        print(f"[Agent] Error suggesting new KB terms: {e}")
+        return gr.update(visible=False), gr.update(visible=False)

smart_writer_kit/agent_for_outline_update.py

@@ -0,0 +1,78 @@
+import gradio as gr
+import pandas as pd
+import json
+from model_handler import ModelHandler
+from config import LING_FLASH_2_0
+
+def _format_outline_for_prompt(df: pd.DataFrame) -> str:
+    """Formats the outline DataFrame into a simple numbered list for the prompt."""
+    if df is None or df.empty:
+        return "无任务。"
+    
+    tasks = [f"{i+1}. {row['Task']}" for i, row in df.iterrows()]
+    return "\n".join(tasks)
+
+def update_outline_status_agent(short_outline_df: pd.DataFrame, editor_content: str):
+    """
+    Agent to analyze text and update the outline's completion status using a real LLM.
+    """
+
+    if editor_content is None or len(editor_content.strip()) < 20:
+        return short_outline_df # Return original df
+
+    try:
+        # 1. Prepare Prompts
+        system_prompt = (
+            "你是一个任务分析机器人。请仔细阅读用户提供的'已完成大纲'和'当前文本'，判断大纲中的每项任务是否已经在文本中被完成。\n"
+            "你的回答必须是一个遵循以下规则的 JSON 对象：\n"
+            "1. JSON 的 key 是大纲中的任务原文。\n"
+            "2. JSON 的 value 是一个布尔值 (`true` 或 `false`)，`true` 代表任务已完成，`false` 代表未完成。\n"
+            "3. 不要返回除了这个 JSON 对象之外的任何其他文本、解释或代码块标记。"
+        )
+        
+        outline_str = _format_outline_for_prompt(short_outline_df)
+        user_prompt = (
+            f"### 已有大纲\n{outline_str}\n\n"
+            f"### 当前文本\n{editor_content[-4000:]}\n\n"
+            "### 指令\n请根据上述'当前文本'，分析'已有大纲'中的任务完成情况，并返回 JSON 对象。"
+        )
+
+        # 2. Call LLM
+        model_handler = ModelHandler()
+        response_generator = model_handler.generate_code(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            model_choice=LING_FLASH_2_0
+        )
+        full_response = "".join(chunk for chunk in response_generator)
+        
+        # 3. Parse JSON and Update DataFrame
+        print("【收到的完整上下文】")
+        print("full_response:", repr(full_response))
+        
+        # Clean up potential markdown code block
+        if full_response.strip().startswith("```json"):
+            full_response = full_response.strip()[7:-3].strip()
+
+        completion_status = json.loads(full_response)
+        
+        # Create a copy to avoid modifying the original df in place
+        updated_df = short_outline_df.copy()
+        
+        for i, row in updated_df.iterrows():
+            task_text = row['Task']
+            if task_text in completion_status:
+                updated_df.at[i, 'Done'] = bool(completion_status[task_text])
+
+        print("【收到的完整上下文】")
+        print("updated_df:\n", updated_df.to_string())
+        return updated_df
+
+    except json.JSONDecodeError:
+        print(f"[Agent] Error: Failed to decode JSON from LLM response: {full_response}")
+        # On JSON error, we don't want to change anything.
+        return short_outline_df
+    except Exception as e:
+        print(f"[Agent] Error updating outline status: {e}")
+        # On other errors, also return the original dataframe.
+        return short_outline_df

smart_writer_kit/agent_for_streaming_completion.py

@@ -0,0 +1,56 @@
+from model_handler import ModelHandler
+from config import LING_FLASH_2_0
+
+def fetch_flow_suggestion_agent(editor_content: str):
+    """
+    Agent for fetching a short, real-time continuation.
+    This agent calls a real LLM.
+    """
+
+    if not editor_content or len(editor_content.strip()) < 5:
+        return "（请输入更多内容以获取建议...）"
+
+    try:
+        model_handler = ModelHandler()
+        
+        # For a simple continuation, we can use a concise system prompt.
+        system_prompt = "你是一个写作助手，请根据用户输入的内容，紧接着写一句简短、流畅的续写。不要重复用户已输入的内容，直接开始写你续写的部分即可。**尤其关注用户输入的最后几个字**。"
+        
+
+        
+        # We use editor_content as the user prompt.
+        # Let's take the last N characters to be more efficient.
+        user_prompt = editor_content[-1000:]
+        
+        # Use generate_code as it's a simple generator for direct content.
+        # We need to provide a dummy code_type and a model_choice.
+        # The model_choice here is the display name, but we can pass the constant.
+        response_generator = model_handler.generate_code(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            model_choice=LING_FLASH_2_0 
+        )
+        
+        # Assemble the streamed response
+        full_response = "".join(chunk for chunk in response_generator)
+        print("【收到的完整上下文】")
+        print("full_response:", repr(full_response))
+        return full_response.strip()
+
+    except Exception as e:
+        print(f"[Agent] Error fetching flow suggestion: {e}")
+        return f"（获取建议时出错: {e}）"
+
+
+def accept_flow_suggestion_agent(current_text: str, suggestion: str):
+    """
+    Agent for accepting a flow suggestion.
+    """
+
+    if not suggestion or "等待输入" in suggestion or "出错" in suggestion:
+        result = current_text
+    else:
+        result = current_text + suggestion
+    print("【收到的完整上下文】")
+    print("result:", repr(result))
+    return result

tab_code.py

@@ -78,7 +78,7 @@ def generate_code(code_type, model_choice, user_prompt, chatbot_history):
         buffer = ""
         is_thinking = False
 
-        for code_chunk in model_handler.generate_code(system_prompt, user_prompt, code_type, model_choice):
+        for code_chunk in model_handler.generate_code(system_prompt, user_prompt, model_choice):
             full_code_with_think += code_chunk
             buffer += code_chunk
             

tab_smart_writer.py

@@ -1,8 +1,11 @@
 import gradio as gr
 import time
-import random
+from smart_writer_kit.agent_for_streaming_completion import fetch_flow_suggestion_agent, accept_flow_suggestion_agent
+from smart_writer_kit.agent_for_inspiration_expansion import fetch_inspiration_agent, apply_inspiration_agent
+from smart_writer_kit.agent_for_outline_update import update_outline_status_agent
+from smart_writer_kit.agent_for_kb_update import suggest_new_kb_terms_agent
 
-# --- Mock Data ---
+# --- Mock Data (for UI population only) ---
 
 MOCK_STYLE = """风格：赛博朋克 / 黑色电影
 视角：第三人称限制视角（主角：凯）
@@ -33,97 +36,23 @@ MOCK_LONG_TERM_OUTLINE = [
     [False, "与荒坂公司的最终决战。"]
 ]
 
-MOCK_INSPIRATIONS = [
-    "霓虹灯光在雨后的路面上破碎成无数光斑，凯拉紧了风衣的领口，义体手臂在寒风中隐隐作痛。来生酒吧的招牌在雾气中若隐若现，像是一只在黑暗中窥视的电子眼。",
-    "\"你来晚了。\"接头人的声音经过变声器处理，听起来像是指甲划过玻璃。他坐在阴影里，只有指尖的一点红光在闪烁——那是他正在抽的廉价合成烟。",
-    "突如其来的爆炸声震碎了酒吧的玻璃，人群尖叫着四散奔逃。凯本能地拔出了腰间的动能手枪，他的视觉系统瞬间切换到了战斗模式，周围的一切都变成了数据流。"
-]
-
-MOCK_FLOW_SUGGESTIONS = [
-    "他感觉到了...",
-    "空气中弥漫着...",
-    "那是他从未见过的...",
-    "就在这一瞬间..."
-]
-
-# --- Logic Functions ---
-
+# --- UI Helper Functions ---
 def get_stats(text):
-    """Mock word count and read time."""
+    """Calculate word count and read time."""
     if not text:
         return "0 Words | 0 mins"
-    words = len(text)
-    read_time = max(1, words // 500)
+    words = len(text.split())
+    read_time = max(1, words // 200) # Average reading speed
     return f"{words} Words | ~{read_time} mins"
 
-def fetch_inspiration(prompt):
-    """Simulate fetching inspiration options based on user prompt."""
-    time.sleep(1)
-    
-    # Simple Mock Logic based on prompt keywords
-    if prompt and "打斗" in prompt:
-        opts = [
-            "凯侧身闪过那一记重拳，义体关节发出尖锐的摩擦声。他顺势抓住对方的手腕，电流顺着接触点瞬间爆发。",
-            "激光刃切开空气，留下一道灼热的残影。凯没有退缩，他的视觉系统已经计算出了对方唯一的破绽。",
-            "周围的空气仿佛凝固了，只剩下心跳声和能量枪充能的嗡嗡声。谁先动，谁就会死。"
-        ]
-    elif prompt and "风景" in prompt:
-        opts = [
-            "酸雨冲刷着生锈的金属外墙，流下一道道黑色的泪痕。远处的全息广告牌在雨雾中显得格外刺眼。",
-            "清晨的阳光穿透厚重的雾霾，无力地洒在贫民窟的屋顶上。这里没有希望，只有生存。",
-            "夜之城的地下就像是一个巨大的迷宫，管道交错，蒸汽弥漫，老鼠和瘾君子在阴影中通过眼神交流。"
-        ]
-    else:
-        opts = MOCK_INSPIRATIONS
-        
-    return gr.update(visible=True), opts[0], opts[1], opts[2]
-
-def apply_inspiration(current_text, inspiration_text):
-    """Append selected inspiration to the editor."""
-    if not current_text:
-        new_text = inspiration_text
-    else:
-        new_text = current_text + "\n\n" + inspiration_text
-    return new_text, gr.update(visible=False), "" # Clear prompt
-
 def dismiss_inspiration():
     return gr.update(visible=False)
 
-def fetch_flow_suggestion(current_text):
-    """Simulate fetching a short continuation."""
-    # If text ends with newline, maybe don't suggest? Or suggest new paragraph start.
-    time.sleep(0.5)
-    return random.choice(MOCK_FLOW_SUGGESTIONS)
-
-def accept_flow_suggestion(current_text, suggestion):
-    if not suggestion or "等待输入" in suggestion:
-        return current_text
-    return current_text + suggestion
-
-def refresh_context(current_outline):
-    """Mock refreshing the outline context (auto-complete task or add new one)."""
-    new_outline = [row[:] for row in current_outline] 
-    
-    # Try to complete the first pending task
-    task_completed = False
-    for row in new_outline:
-        if not row[0]:
-            row[0] = True 
-            task_completed = True
-            break
-            
-    # If all done, or randomly, add a new event
-    if not task_completed or random.random() > 0.7:
-         new_outline.append([False, f"新的动态事件: 突发情况 #{random.randint(100, 999)}"])
-
-    return new_outline
-
 # --- UI Construction ---
 
 def create_smart_writer_tab():
-    # Hidden Buttons for JS triggers
-    btn_accept_flow_trigger = gr.Button(visible=False, elem_id="btn_accept_flow_trigger")
-    btn_refresh_context_trigger = gr.Button(visible=False, elem_id="btn_refresh_context_trigger")
+    debounce_state = gr.State({"last_change": 0, "active": False})
+    debounce_timer = gr.Timer(0.5, active=False)
 
     with gr.Row(equal_height=False, elem_id="indicator-writing-tab"):
         # --- Left Column: Entity Console ---
@@ -147,6 +76,18 @@ def create_smart_writer_tab():
                     label="知识库",
                     wrap=True
                 )
+                with gr.Row():
+                    btn_suggest_kb = gr.Button("🔍 提取新词条", size="sm")
+                
+                md_suggested_terms_header = gr.Markdown("#### 推荐词条", visible=False) # Placeholder for suggested terms
+                suggested_kb_dataframe = gr.Dataframe(
+                    headers=["Term", "Description"],
+                    datatype=["str", "str"],
+                    visible=False, # Initially hidden
+                    interactive=False,
+                    label="推荐词条"
+                )
+
                 
             with gr.Accordion("当前章节大纲 (Short-Term)", open=True):
                 short_outline_input = gr.Dataframe(
@@ -157,6 +98,8 @@ def create_smart_writer_tab():
                     label="当前章节大纲",
                     col_count=(2, "fixed"),
                 )
+                with gr.Row():
+                    btn_sync_outline = gr.Button("🔄 同步状态", size="sm")
 
             with gr.Accordion("故事总纲 (Long-Term)", open=False):
                 long_outline_input = gr.Dataframe(
@@ -173,7 +116,7 @@ def create_smart_writer_tab():
             # Toolbar
             with gr.Row(elem_classes=["toolbar"]):
                 stats_display = gr.Markdown("0 Words | 0 mins")
-                inspiration_btn = gr.Button("✨ 灵感扩写 (Cmd+Enter)", size="sm", variant="primary")
+                inspiration_btn = gr.Button("✨ 继续整段 (Cmd/Ctrl+Enter)", size="sm", variant="primary", elem_id="btn-action-create-paragraph")
             
             # 主要编辑器区域
             editor = gr.Textbox(
@@ -188,14 +131,17 @@ def create_smart_writer_tab():
             # Flow Suggestion
             with gr.Row(variant="panel"):
                 flow_suggestion_display = gr.Textbox(
-                    label="AI 实时续写建议 (按 Tab 采纳)", 
-                    value="（等待输入...）", 
+                    label="AI 实时续写建议 (按 Tab 采纳)",
+                    value="（等待输入...）",
                     interactive=False,
                     scale=4,
                     elem_classes=["flow-suggestion-box"]
                 )
-                accept_flow_btn = gr.Button("采纳", scale=1, elem_id='btn-action-accept-flow')
-                refresh_flow_btn = gr.Button("换一个", scale=1)
+                accept_flow_btn = gr.Button("采纳(Tab)", scale=1, elem_id='btn-action-accept-flow')
+                refresh_flow_btn = gr.Button("换一个(Shift+Tab)", scale=1, elem_id='btn-action-change-flow')
+
+            # Debounce Progress
+            debounce_progress = gr.HTML(value="", visible=False)
 
             # Inspiration Modal
             with gr.Group(visible=False) as inspiration_modal:
@@ -206,12 +152,12 @@ def create_smart_writer_tab():
                     placeholder="例如：写一段激烈的打斗 / 描写赛博朋克夜景...",
                     lines=1
                 )
-                refresh_inspiration_btn = gr.Button("生成选项")
+                refresh_inspiration_btn = gr.Button("生成选项(Shift+Enter)")
 
                 with gr.Row():
-                    opt1_btn = gr.Button(MOCK_INSPIRATIONS[0], elem_classes=["inspiration-card"])
-                    opt2_btn = gr.Button(MOCK_INSPIRATIONS[1], elem_classes=["inspiration-card"])
-                    opt3_btn = gr.Button(MOCK_INSPIRATIONS[2], elem_classes=["inspiration-card"])
+                    opt1_btn = gr.Button("...", elem_classes=["inspiration-card"])
+                    opt2_btn = gr.Button("...", elem_classes=["inspiration-card"])
+                    opt3_btn = gr.Button("...", elem_classes=["inspiration-card"])
                 cancel_insp_btn = gr.Button("取消")
 
     # --- Interactions ---
@@ -220,43 +166,61 @@ def create_smart_writer_tab():
     editor.change(fn=get_stats, inputs=editor, outputs=stats_display)
 
     # 2. Inspiration Workflow
-    # Open Modal (reset prompt)
-    inspiration_btn.click(
-        fn=lambda: (gr.update(visible=True), ""),
-        outputs=[inspiration_modal, inspiration_prompt_input]
-    )
+    # Open Modal (triggered by visible button or hidden trigger button for Cmd+Enter)
+    open_inspiration_modal_fn = lambda: (gr.update(visible=True), "")
+    inspiration_btn.click(fn=open_inspiration_modal_fn, outputs=[inspiration_modal, inspiration_prompt_input])
     
     # Generate Options based on Prompt
     refresh_inspiration_btn.click(
-        fn=fetch_inspiration,
-        inputs=[inspiration_prompt_input],
+        fn=fetch_inspiration_agent,
+        inputs=[inspiration_prompt_input, editor, style_input, kb_input, short_outline_input, long_outline_input],
         outputs=[inspiration_modal, opt1_btn, opt2_btn, opt3_btn]
     )
 
     # Apply Option
     for btn in [opt1_btn, opt2_btn, opt3_btn]:
         btn.click(
-            fn=apply_inspiration,
+            fn=apply_inspiration_agent,
             inputs=[editor, btn],
             outputs=[editor, inspiration_modal, inspiration_prompt_input]
         )
     
-    cancel_insp_btn.click(fn=dismiss_inspiration, outputs=inspiration_modal)
-
-    # 3. Flow Suggestion
-    editor.change(fn=fetch_flow_suggestion, inputs=editor, outputs=flow_suggestion_display)
-    refresh_flow_btn.click(fn=fetch_flow_suggestion, inputs=editor, outputs=flow_suggestion_display)
-    
-    # Accept Flow (Triggered by Button or Tab Key via JS)
+    cancel_insp_btn.click(fn=dismiss_inspiration, outputs=inspiration_modal, show_progress="hidden")
+
+    # 3. Flow Suggestion with Debounce
+    def start_debounce(editor_content):
+        return {"last_change": time.time(), "active": True}, gr.update(active=True), gr.update(visible=True, value="<progress value='0' max='100'></progress> 补全中... 3.0s")
+
+    def update_debounce(debounce_state, editor_content):
+        if not debounce_state["active"]:
+            return gr.update(), gr.update(), debounce_state, gr.update()
+        elapsed = time.time() - debounce_state["last_change"]
+        if elapsed >= 3:
+            suggestion = fetch_flow_suggestion_agent(editor_content)
+            return gr.update(visible=False), suggestion, {"last_change": 0, "active": False}, gr.update(active=False)
+        else:
+            progress = int((elapsed / 3) * 100)
+            remaining = 3 - elapsed
+            progress_html = f"<progress value='{progress}' max='100'></progress> 补全中... {remaining:.1f}s"
+            return gr.update(value=progress_html), gr.update(), debounce_state, gr.update()
+
+    editor.change(fn=start_debounce, inputs=editor, outputs=[debounce_state, debounce_timer, debounce_progress])
+    debounce_timer.tick(fn=update_debounce, inputs=[debounce_state, editor], outputs=[debounce_progress, flow_suggestion_display, debounce_state, debounce_timer])
+    refresh_flow_btn.click(fn=fetch_flow_suggestion_agent, inputs=editor, outputs=flow_suggestion_display)
+
+    # Accept Flow (Triggered by visible Button or hidden Tab Key trigger)
     accept_flow_fn_inputs = [editor, flow_suggestion_display]
     accept_flow_fn_outputs = [editor]
-    
-    accept_flow_btn.click(fn=accept_flow_suggestion, inputs=accept_flow_fn_inputs, outputs=accept_flow_fn_outputs)
-    btn_accept_flow_trigger.click(fn=accept_flow_suggestion, inputs=accept_flow_fn_inputs, outputs=accept_flow_fn_outputs)
+    accept_flow_btn.click(fn=accept_flow_suggestion_agent, inputs=accept_flow_fn_inputs, outputs=accept_flow_fn_outputs, show_progress="hidden")
 
-    # 4. Context Refresh (Triggered by Enter Key via JS)
-    btn_refresh_context_trigger.click(
-        fn=refresh_context,
-        inputs=[short_outline_input],
+    # 4. Agent-based Context Updates
+    btn_sync_outline.click(
+        fn=update_outline_status_agent,
+        inputs=[short_outline_input, editor],
         outputs=[short_outline_input]
     )
+    btn_suggest_kb.click(
+        fn=suggest_new_kb_terms_agent,
+        inputs=[kb_input, editor],
+        outputs=[suggested_kb_dataframe, md_suggested_terms_header]
+    )