Sync ling-space changes from GitHub commit d5d4701

app.py

@@ -10,9 +10,9 @@ from tab_test import run_model_handler_test, run_clear_chat_test
 
 def get_history_df(history):
     if not history:
-        return pd.DataFrame({'ID': [], 'Conversation': []})
+        return pd.DataFrame({'ID': [], '对话': []})
     df = pd.DataFrame(history)
-    return df[['id', 'title']].rename(columns={'id': 'ID', 'title': 'Conversation'})
+    return df[['id', 'title']].rename(columns={'id': 'ID', 'title': '对话'})
 
 def on_app_load(history, conv_id):
     """
@@ -24,7 +24,7 @@ def on_app_load(history, conv_id):
     if not history:
         # First time ever loading, create a new chat
         conv_id = str(uuid.uuid4())
-        new_convo = { "id": conv_id, "title": "New Conversation", "messages": [], "timestamp": datetime.now().isoformat() }
+        new_convo = { "id": conv_id, "title": "(新对话)", "messages": [], "timestamp": datetime.now().isoformat() }
         history = [new_convo]
         return conv_id, history, gr.update(value=get_history_df(history)), []
 
@@ -51,6 +51,13 @@ CSS = """
 footer { 
     display: none !important; 
 }
+
+/* Disable transition and animation for no-transition class */
+.no-transition, .no-transition * {
+    transition: none !important;
+    animation: none !important;
+    animation-play-state: paused !important;
+}
 """
 
 if __name__ == "__main__":

config.py

@@ -42,42 +42,42 @@ CHAT_MODEL_SPECS = {
         "provider": "openai_compatible",
         "model_id": "inclusionai/ling-mini-2.0",
         "display_name": "🦉 Ling-mini-2.0",
-        "description": "A lightweight conversational model optimized for efficient operation on consumer-grade hardware, ideal for mobile or localized deployment scenarios.",
+        "description": "轻量级对话模型，专为消费级硬件的高效运行而优化，是移动端或本地化部署场景的理想选择。",
         "url": "https://huggingface.co/inclusionai"
     },
     LING_1T: {
         "provider": "openai_compatible",
         "model_id": "inclusionai/ling-1t",
         "display_name": "🦉 Ling-1T",
-        "description": "A trillion-parameter large language model designed for complex natural language understanding and generation tasks that require extreme performance and high fluency.",
+        "description": "万亿参数的大型语言模型，专为需要极致性能和高流畅度的复杂自然语言理解与生成任务而设计。",
         "url": "https://huggingface.co/inclusionai"
     },
     LING_FLASH_2_0: {
         "provider": "openai_compatible",
         "model_id": "inclusionai/ling-flash-2.0",
         "display_name": "🦉 Ling-flash-2.0",
-        "description": "A high-performance billion-parameter model optimized for scenarios requiring high-speed response and complex instruction following.",
+        "description": "高性能十亿参数模型，针对需要高速响应和复杂指令遵循的场景进行了优化。",
         "url": "https://huggingface.co/inclusionai"
     },
     RING_1T: {
         "provider": "openai_compatible",
         "model_id": "inclusionai/ring-1t",
         "display_name": "💍️ Ring-1T",
-        "description": "A brand-new trillion-parameter reasoning model with powerful code generation and tool use capabilities.",
+        "description": "全新的万亿参数推理模型，具备强大的代码生成和工具使用能力。",
         "url": "https://huggingface.co/inclusionai"
     },
     RING_FLASH_2_0: {
         "provider": "openai_compatible",
         "model_id": "inclusionai/ring-flash-2.0",
         "display_name": "💍️ Ring-flash-2.0",
-        "description": "A billion-parameter reasoning model that strikes a good balance between performance and cost, suitable for general-purpose tasks that require step-by-step thinking or code generation.",
+        "description": "十亿参数推理模型，在性能与成本之间取得了良好的平衡，适用于需要逐步思考或代码生成的通用任务。",
         "url": "https://huggingface.co/inclusionai"
     },
     RING_MINI_2_0: {
         "provider": "openai_compatible",
         "model_id": "inclusionai/ring-mini-2.0",
         "display_name": "💍️ Ring-mini-2.0",
-        "description": "A quantized and extremely efficient reasoning model designed for resource-constrained environments with strict speed and efficiency requirements (such as edge computing).",
+        "description": "一款专为资源受限环境设计的量化且极其高效的推理模型，满足严格的速度和效率要求（如边缘计算）。",
         "url": "https://huggingface.co/inclusionai"
     }
 }

smart_writer_kit/agent_common_utils.py

@@ -0,0 +1,17 @@
+import pandas as pd
+
+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"

smart_writer_kit/agent_for_inspiration_expansion.py

@@ -2,26 +2,12 @@ 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"
+from .agent_common_utils import format_df_to_string
 
 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.
+    (Original 3-option expansion logic)
     """
     print("\n[Agent][fetch_inspiration_agent] === 推理类型：灵感扩写 ===")
     print("【发出的完整上下文】")
@@ -35,9 +21,9 @@ def fetch_inspiration_agent(prompt: str, editor_content: str, style: str, kb_df:
     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, "故事总纲")
+        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 = (
@@ -82,50 +68,6 @@ def fetch_inspiration_agent(prompt: str, editor_content: str, style: str, kb_df:
         error_message = f"获取灵感时出错: {e}"
         return gr.update(visible=True), error_message, "请检查日志", "请检查日志"
 
-
-def fetch_paragraph_continuation_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 a single paragraph continuation (Ribbon UI version).
-    """
-    print("\n[Agent][fetch_paragraph_continuation_agent] === 推理类型：整段续写 (Single) ===")
-    try:
-        # 1. Format context
-        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"
-            "请直接输出续写内容，不要包含任何解释、前缀或后缀。"
-        )
-        
-        # 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)
-        return full_response.strip()
-
-    except Exception as e:
-        print(f"[Agent] Error fetching paragraph continuation: {e}")
-        return f"获取续写时出错: {e}"
-
-
-
 def apply_inspiration_agent(current_text: str, inspiration_text: str):
     """
     Agent for applying selected inspiration to the editor.
@@ -141,4 +83,4 @@ def apply_inspiration_agent(current_text: str, inspiration_text: str):
     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), ""
+    return new_text, gr.update(visible=False), ""

smart_writer_kit/agent_for_paragraph_continuation.py

@@ -0,0 +1,46 @@
+import pandas as pd
+from model_handler import ModelHandler
+from config import LING_1T
+from .agent_common_utils import format_df_to_string
+
+def fetch_paragraph_continuation_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 a single paragraph continuation (Ribbon UI version).
+    """
+    print("\n[Agent][fetch_paragraph_continuation_agent] === 推理类型：整段续写 (Single) ===")
+    try:
+        # 1. Format context
+        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"
+            "请直接输出续写内容，不要包含任何解释、前缀或后缀。"
+        )
+        
+        # 3. Build User Prompt
+        full_context = style_context + kb_context + long_outline_context + short_outline_context
+        user_instruction = prompt if prompt else '请基于当前内容，自然地延续剧情，写一个完整的段落。'
+        user_prompt = (
+            f"### 背景设定与大纲\n{full_context}\n"
+            f"### 当前已写内容 (末尾部分)\n{editor_content[-2000:]}\n\n"
+            f"### 用户指令\n{user_instruction}"
+        )
+
+        # 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)
+        return full_response.strip()
+
+    except Exception as e:
+        print(f"[Agent] Error fetching paragraph continuation: {e}")
+        return f"获取续写时出错: {e}"

smart_writer_kit/agent_for_prompt_suggestion.py

@@ -0,0 +1,54 @@
+import pandas as pd
+from model_handler import ModelHandler
+from config import LING_MINI_2_0
+from .agent_common_utils import format_df_to_string
+
+def fetch_prompt_suggestions_agent(editor_content: str, style: str, kb_df: pd.DataFrame, short_outline_df: pd.DataFrame, long_outline_df: pd.DataFrame):
+    """
+    Agent for fetching short prompt suggestions using LING_MINI_2_0.
+    """
+    print("\n[Agent][fetch_prompt_suggestions_agent] === 推理类型：续写提示推荐 ===")
+    try:
+        # 1. Format context
+        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, "当前章节大纲")
+
+        # 2. Build System Prompt
+        system_prompt = (
+            "你是一个辅助写作的创意助手。请根据提供的故事背景和知识库，结合“互动”、“冲突”、“发展”、“对话”等动作，生成3个简短的续写提示短语。\n"
+            "要求：\n"
+            "1. 短语简洁明了，例如：“和Alpha争吵”、“探索废弃的地铁站”、“回忆起旧照片的往事”。\n"
+            "2. 尽量使用知识库中的专有名词。\n"
+            "3. 请严格遵守以下格式：输出3个短语，用 `|` 分隔。不要包含其他内容。\n"
+            "例如：和Alpha争吵|探索废弃的地铁站|回忆起旧照片的往事"
+        )
+        
+        # 3. Build User Prompt
+        full_context = style_context + kb_context + short_outline_context
+        user_prompt = (
+            f"### 背景设定\n{full_context}\n"
+            f"### 当前已写内容 (末尾部分)\n{editor_content[-500:]}\n\n" # Only need a little context
+            f"### 任务\n生成3个续写提示。"
+        )
+
+        # 4. Call LLM
+        model_handler = ModelHandler()
+        response_generator = model_handler.generate_code(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            model_choice=LING_MINI_2_0 
+        )
+        
+        full_response = "".join(chunk for chunk in response_generator)
+        print("【收到的建议】", full_response)
+        
+        suggestions = full_response.split("|")
+        # Ensure 3 suggestions
+        suggestions += ["继续推进剧情"] * (3 - len(suggestions))
+        
+        return suggestions[0].strip(), suggestions[1].strip(), suggestions[2].strip()
+
+    except Exception as e:
+        print(f"[Agent] Error fetching prompt suggestions: {e}")
+        return "生成失败", "生成失败", "生成失败"

tab_chat.py

@@ -15,14 +15,26 @@ def create_chat_tab():
 
     def get_history_df(history):
         if not history:
-            return pd.DataFrame({'ID': [], 'Conversation': []})
+            return pd.DataFrame({'ID': [], '对话': []})
         df = pd.DataFrame(history)
-        return df[['id', 'title']].rename(columns={'id': 'ID', 'title': 'Conversation'})
+        return df[['id', 'title']].rename(columns={'id': 'ID', 'title': '对话'})
+
+    def handle_new_chat(history, current_conv_id=None):
+        # Try to find the current conversation
+        current_convo = next((c for c in history if c["id"] == current_conv_id), None) if history else None
+
+        # If current conversation exists and is empty, reuse it
+        if current_convo and not current_convo.get("messages", []):
+            return (
+                current_conv_id,
+                history,
+                [],
+                gr.update(value=get_history_df(history))
+            )
 
-    def handle_new_chat(history):
         conv_id = str(uuid.uuid4())
         new_convo = {
-            "id": conv_id, "title": "New Conversation",
+            "id": conv_id, "title": "(新对话)",
             "messages": [], "timestamp": datetime.now().isoformat()
         }
         updated_history = [new_convo] + (history or [])
@@ -41,7 +53,8 @@ def create_chat_tab():
             if convo["id"] == selected_id:
                 return selected_id, convo["messages"]
         # Fallback to new chat if something goes wrong
-        return handle_new_chat(history)[0], handle_new_chat(history)[2]
+        new_id, _, new_msgs, _ = handle_new_chat(history)
+        return new_id, new_msgs
 
     with gr.Row(equal_height=False, elem_id="indicator-chat-tab"):
         with gr.Column(scale=1):
@@ -79,12 +92,12 @@ def create_chat_tab():
 
         # --- Event Handlers --- #
         # The change handler is now encapsulated within create_model_selector
-        def on_select_recommendation(evt: gr.SelectData, history):
+        def on_select_recommendation(evt: gr.SelectData, history, current_conv_id):
             selected_task = evt.value[0]
             item = next((i for i in RECOMMENDED_INPUTS if i["task"] == selected_task), None)
             if not item: return gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update()
 
-            new_id, new_history, new_messages, history_df_update = handle_new_chat(history)
+            new_id, new_history, new_messages, history_df_update = handle_new_chat(history, current_conv_id)
 
             return (
                 new_id, new_history,
@@ -96,7 +109,7 @@ def create_chat_tab():
                 new_messages
             )
 
-        recommended_dataset.select(on_select_recommendation, inputs=[conversation_store], outputs=[current_conversation_id, conversation_store, model_dropdown, system_prompt_textbox, temperature_slider, textbox, history_df, chatbot], show_progress="none")
+        recommended_dataset.select(on_select_recommendation, inputs=[conversation_store, current_conversation_id], outputs=[current_conversation_id, conversation_store, model_dropdown, system_prompt_textbox, temperature_slider, textbox, history_df, chatbot], show_progress="none")
 
         def chat_stream(conv_id, history, model_display_name, message, chat_history, system_prompt, temperature):
             if not message:
@@ -112,7 +125,7 @@ def create_chat_tab():
             if not current_convo:
                 return history, gr.update()
 
-            if len(final_chat_history) > len(current_convo["messages"]) and current_convo["title"] == "New Conversation":
+            if len(final_chat_history) > len(current_convo["messages"]) and current_convo["title"] == "(新对话)":
                 user_message = final_chat_history[-2]["content"] if len(final_chat_history) > 1 else final_chat_history[0]["content"]
                 current_convo["title"] = user_message[:50]
 
@@ -141,7 +154,7 @@ def create_chat_tab():
             [conversation_store, history_df]
         )
 
-        new_chat_btn.click(handle_new_chat, inputs=[conversation_store], outputs=[current_conversation_id, conversation_store, chatbot, history_df])
+        new_chat_btn.click(handle_new_chat, inputs=[conversation_store, current_conversation_id], outputs=[current_conversation_id, conversation_store, chatbot, history_df])
         history_df.select(load_conversation_from_df, inputs=[history_df, conversation_store], outputs=[current_conversation_id, chatbot])
 
     return conversation_store, current_conversation_id, history_df, chatbot

tab_smart_writer.py

@@ -1,9 +1,12 @@
 import gradio as gr
 import time
 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, fetch_paragraph_continuation_agent
+from smart_writer_kit.agent_for_inspiration_expansion import fetch_inspiration_agent, apply_inspiration_agent
+from smart_writer_kit.agent_for_paragraph_continuation import fetch_paragraph_continuation_agent
+from smart_writer_kit.agent_for_prompt_suggestion import fetch_prompt_suggestions_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
+from ui_components.debounce_manager import DebounceManager
 
 # --- Mock Data (for UI population only) ---
 
@@ -43,9 +46,8 @@ def get_stats(text):
 # --- UI Construction ---
 
 def create_smart_writer_tab():
-    debounce_state = gr.State({"last_change": 0, "active": False, "style": "", "kb": [], "short_outline": [], "long_outline": []})
-    debounce_timer = gr.Timer(0.1, active=True)
-    
+    # Initialize DebounceManager
+    debounce_manager = DebounceManager(debounce_time=2.0, tick_time=0.3, loading_text="稍后开始续写")
 
     with gr.Row(equal_height=False, elem_id="indicator-writing-tab"):
         # --- Left Column: Entity Console ---
@@ -109,24 +111,40 @@ def create_smart_writer_tab():
                 
                 # Area 1: Real-time Continuation (Flow)
                 with gr.Column(scale=1, min_width=200):
-                    gr.Markdown("#### ⚡️ 实时续写")
-                    with gr.Row():
-                        btn_accept_flow = gr.Button("采纳续写 (Tab)", size="sm", variant="primary", elem_id='btn-action-accept-flow')
-                        btn_change_flow = gr.Button("换一个 (Shift+Tab)", size="sm", elem_id='btn-action-change-flow')
-                    
+
                     flow_suggestion_display = gr.Textbox(
-                        show_label=False,
+                        show_label=True,
+                        label="实时续写建议",
                         placeholder="（等待输入或点击“换一个”...）",
                         lines=3,
                         interactive=False,
-                        elem_classes=["flow-suggestion-box"]
+                        elem_classes=["flow-suggestion-box"],
                     )
-                    # Debounce Progress Indicator
-                    debounce_progress = gr.HTML(value="", visible=False)
+
+                    btn_accept_flow = gr.Button("采纳续写 (Tab)", size="sm", variant="primary", elem_id='btn-action-accept-flow')
+                    btn_change_flow = gr.Button("换一个 (Shift+Tab)", size="sm", elem_id='btn-action-change-flow')
+
+                    # Debounce Progress Indicator (Using Manager)
+                    debounce_state, debounce_timer, debounce_progress = debounce_manager.create_ui()
+                    debounce_progress.visible = True 
 
                 # Area 2: Paragraph Continuation (Inspiration)
                 with gr.Column(scale=1, min_width=200):
-                    gr.Markdown("#### ✨ 整段续写")
+                    inspiration_prompt_input = gr.Textbox(
+                        label="续写提示",
+                        placeholder="例如：写一段关于...的描写",
+                        lines=2
+                    )
+                    
+                    prompt_suggestions_dataset = gr.Dataset(
+                        label="推荐提示 (点击填入)",
+                        components=[gr.Textbox(visible=False)],
+                        samples=[["生成建议..."], ["生成建议..."], ["生成建议..."]],
+                        type="values"
+                    )
+                    
+                    refresh_suggestions_btn = gr.Button("🎲 换一批建议", size="sm", variant="secondary") # Combined trigger
+
                     with gr.Row():
                         btn_generate_para = gr.Button("整段续写 (Cmd+Enter)", size="sm", variant="primary", elem_id="btn-action-create-paragraph")
                         btn_change_para = gr.Button("换一个", size="sm")
@@ -164,25 +182,26 @@ def create_smart_writer_tab():
     # 1. Stats
     editor.change(fn=get_stats, inputs=editor, outputs=stats_display)
 
-    # 2. Flow Suggestion Logic
-    def start_debounce(editor_content, style, kb, short_outline, long_outline):
-        return {"last_change": time.time(), "active": True, "style": style, "kb": kb, "short_outline": short_outline, "long_outline": long_outline}, 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, debounce_state["style"], debounce_state["kb"], debounce_state["short_outline"], debounce_state["long_outline"])
-            return gr.update(visible=False), suggestion, {"last_change": 0, "active": False, "style": "", "kb": [], "short_outline": [], "long_outline": []}, 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, style_input, kb_input, short_outline_input, long_outline_input], 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])
+    # 2. Flow Suggestion Logic (Using DebounceManager)
+    
+    # Bind reset logic to editor change
+    editor.change(
+        fn=debounce_manager.reset, 
+        inputs=[editor, style_input, kb_input, short_outline_input, long_outline_input], # Capture all context as payload
+        outputs=[debounce_state, debounce_timer, debounce_progress]
+    )
+
+    # Bind tick logic
+    def flow_suggestion_trigger(editor_content, style, kb, short_outline, long_outline):
+         return fetch_flow_suggestion_agent(editor_content, style, kb, short_outline, long_outline)
+
+    # Note: debounce_manager.tick calls the trigger function. 
+    # The lambda is used to pass the specific trigger function for this tab.
+    debounce_timer.tick(
+        fn=lambda s: debounce_manager.tick(s, flow_suggestion_trigger), 
+        inputs=[debounce_state], 
+        outputs=[debounce_progress, debounce_state, debounce_timer, flow_suggestion_display]
+    )
     
     btn_change_flow.click(fn=fetch_flow_suggestion_agent, inputs=[editor, style_input, kb_input, short_outline_input, long_outline_input], outputs=flow_suggestion_display)
 
@@ -191,18 +210,17 @@ def create_smart_writer_tab():
     btn_accept_flow.click(
         fn=lambda e, s: (accept_flow_suggestion_agent(e, s), ""), # Accept and clear suggestion
         inputs=accept_flow_fn_inputs, 
-        outputs=[editor, flow_suggestion_display], 
-        show_progress="hidden"
+        outputs=[editor, flow_suggestion_display]
     )
 
-    # 3. Paragraph Continuation Logic
-    def generate_paragraph_wrapper(editor_val, style, kb, short, long_):
-        return fetch_paragraph_continuation_agent(None, editor_val, style, kb, short, long_)
+    # 3. Paragraph Continuation Logic (Updated with prompt input)
+    def generate_paragraph_wrapper(prompt_val, editor_val, style, kb, short, long_):
+        return fetch_paragraph_continuation_agent(prompt_val, editor_val, style, kb, short, long_)
 
     for btn in [btn_generate_para, btn_change_para]:
         btn.click(
             fn=generate_paragraph_wrapper,
-            inputs=[editor, style_input, kb_input, short_outline_input, long_outline_input],
+            inputs=[inspiration_prompt_input, editor, style_input, kb_input, short_outline_input, long_outline_input],
             outputs=[para_suggestion_display]
         )
     
@@ -217,6 +235,29 @@ def create_smart_writer_tab():
         inputs=[editor, para_suggestion_display],
         outputs=[editor, para_suggestion_display]
     )
+    
+    # Suggestions Logic
+    # Trigger for suggestion generation
+    def refresh_suggestions_wrapper(editor_content, style, kb, short_outline, long_outline):
+        s1, s2, s3 = fetch_prompt_suggestions_agent(editor_content, style, kb, short_outline, long_outline)
+        # Return a gr.update object to properly update the Dataset component
+        return gr.update(samples=[[s1], [s2], [s3]])
+
+    refresh_suggestions_btn.click(
+        fn=refresh_suggestions_wrapper,
+        inputs=[editor, style_input, kb_input, short_outline_input, long_outline_input],
+        outputs=[prompt_suggestions_dataset]
+    )
+    
+    # Dataset click -> fill prompt input
+    def fill_prompt_from_dataset(val):
+        return val[0]
+
+    prompt_suggestions_dataset.click(
+        fn=fill_prompt_from_dataset,
+        inputs=prompt_suggestions_dataset,
+        outputs=inspiration_prompt_input
+    )
 
     # 4. Agent-based Context Updates
     btn_sync_outline.click(
@@ -228,4 +269,4 @@ def create_smart_writer_tab():
         fn=suggest_new_kb_terms_agent,
         inputs=[kb_input, editor],
         outputs=[suggested_kb_dataframe]
-    )
+    )

ui_components/debounce_manager.py

@@ -0,0 +1,111 @@
+import gradio as gr
+import time
+
+class DebounceManager:
+    def __init__(self, debounce_time: float, tick_time: float, loading_text: str):
+        """
+        Manages debounce logic and UI updates.
+
+        Args:
+            debounce_time (float): The time in seconds to wait before triggering the action.
+            tick_time (float): The interval in seconds for the timer tick.
+            loading_text (str): The text to display while waiting.
+        """
+        self.debounce_time = debounce_time
+        self.tick_time = tick_time
+        self.loading_text = loading_text
+
+    def _generate_progress_html(self, progress_percent: int, remaining_time: float = None) -> str:
+        """
+        Generates the HTML string for the progress bar.
+        
+        Args:
+            progress_percent (int): Current progress percentage (0-100).
+            remaining_time (float, optional): Remaining time in seconds. If None, uses debounce_time.
+        
+        Returns:
+            str: HTML string for the progress bar.
+        """
+        if remaining_time is None:
+            display_time = self.debounce_time
+        else:
+            display_time = remaining_time
+            
+        return f"<div style='height: 20px; display: flex; align-items: center;'><progress value='{progress_percent}' max='100' style='width: 100px; margin-right: 10px;'></progress> <span>{self.loading_text} {display_time:.1f}s</span></div>"
+
+    def create_ui(self):
+        """
+        Creates the necessary UI components for the debounce mechanism.
+
+        Returns:
+            tuple: (debounce_state, debounce_timer, debounce_progress)
+        """
+        # State to store: last_change timestamp, active status, and payload (context)
+        debounce_state = gr.State({"last_change": 0, "active": False, "payload": None})
+        debounce_timer = gr.Timer(self.tick_time, active=False)
+        # Use the new method for initial value
+        initial_progress_html = self._generate_progress_html(0) 
+        debounce_progress = gr.HTML(value=initial_progress_html, visible=True, elem_classes=["no-transition"])
+        return debounce_state, debounce_timer, debounce_progress
+
+    def reset(self, *args):
+        """
+        Resets the debounce timer. Call this when the monitored input changes.
+        Passes through any arguments as the 'payload' to be stored in state.
+        """
+        # Store all arguments as payload
+        payload = args if len(args) > 1 else (args[0] if args else None)
+        
+        # Use the new method for progress HTML
+        progress_html = self._generate_progress_html(0) # Start at 0%
+
+        return {
+            "last_change": time.time(),
+            "active": True,
+            "payload": payload
+        }, gr.update(active=True), gr.update(visible=True, value=progress_html)
+
+    def tick(self, debounce_state, trigger_fn):
+        """
+        Called on every timer tick. checks if debounce time has passed.
+
+        Args:
+            debounce_state (dict): The current debounce state.
+            trigger_fn (callable): The function to execute when debounce completes. 
+                                   It should accept the stored 'payload' as arguments.
+
+        Returns:
+             tuple: Updates for (debounce_progress, debounce_state, debounce_timer) + result of trigger_fn
+        """
+        # 1. If not active, do nothing
+        if not debounce_state["active"]:
+            # Return empty updates for UI components, and a dummy update for the trigger output
+            return gr.update(), debounce_state, gr.update(), gr.update()
+
+        elapsed = time.time() - debounce_state["last_change"]
+
+        # 2. Check if time is up
+        if elapsed >= self.debounce_time:
+            # Execute the trigger function with the stored payload
+            payload = debounce_state["payload"]
+            if isinstance(payload, tuple):
+                result = trigger_fn(*payload)
+            else:
+                result = trigger_fn(payload)
+            
+            # Reset state to inactive
+            new_state = {"last_change": 0, "active": False, "payload": None}
+            
+            # Return: Hide Progress, Update State, Stop Timer, Trigger Result
+            return gr.update(value=self._generate_progress_html(0)), new_state, gr.update(active=False), result
+        
+        else:
+            # 3. Update Progress
+            progress_percent = int((elapsed / self.debounce_time) * 100)
+            remaining = self.debounce_time - elapsed
+            
+            # Use the new method for progress HTML
+            progress_html = self._generate_progress_html(progress_percent, remaining)
+            
+            # Return: Update Progress, Keep State, Keep Timer, Dummy Update for Result
+            return gr.update(value=progress_html, visible=True), debounce_state, gr.update(), gr.update()