Sync ling-space changes from GitHub commit 8d05d99

README.md

@@ -16,3 +16,14 @@ secrets:
 # Ling Space
 
 这是一个用于与 Ling 系列模型进行交互的 Gradio 应用。
+
+## 本地开发 (Local Development)
+
+为了方便本地开发，本项目提供了一个基于 `watchfiles` 的热重载开发服务器。当代码文件发生变化时，应用会自动重启，无需手动干预。
+
+要启动开发服务器，请在 `ling-space/` 目录下运行：
+
+```bash
+python run_dev_server.py
+```
+

app.py

@@ -1,55 +1,94 @@
 import gradio as gr
-import uuid
 import logging
+import uuid
 from datetime import datetime
-from gradio.analytics import ANALYTICS_URL
 import pandas as pd
+from i18n import get_text
 from model_handler import ModelHandler
 from tab_chat import create_chat_tab
+from tab_chat import update_language as update_chat_language
 from tab_code import create_code_tab
+from tab_code import update_language as update_code_language
 from tab_smart_writer import create_smart_writer_tab
-from tab_test import run_model_handler_test, run_clear_chat_test
+from tab_smart_writer import update_language as update_writer_language
+from tab_welcome import create_welcome_tab
+from tab_welcome import update_language as update_welcome_language
 
 # Configure logging
 logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
 )
 logger = logging.getLogger(__name__)
 
-def get_history_df(history):
+
+def get_history_df_from_app(history):
     if not history:
-        return pd.DataFrame({'ID': [], '对话': []})
+        return pd.DataFrame(
+            {"ID": pd.Series(dtype="str"), "对话": pd.Series(dtype="str")}
+        )
     df = pd.DataFrame(history)
-    return df[['id', 'title']].rename(columns={'id': 'ID', 'title': '对话'})
+    if "id" in df.columns and "title" in df.columns:
+        return df[["id", "title"]].rename(columns={"id": "ID", "对话": "对话"})
+    return pd.DataFrame({"ID": pd.Series(dtype="str"), "对话": pd.Series(dtype="str")})
+
 
-def on_app_load(history, conv_id):
+def on_app_load(request: gr.Request, history, conv_id, current_lang_state):
     """
     Handles the application's initial state on load.
-    - If no history exists, creates a new conversation.
-    - If the last conversation ID is invalid, loads the most recent one.
-    - Otherwise, loads the last active conversation.
+    - Determines language from URL parameter.
+    - Loads conversation history or creates a new one.
     """
+    # --- Language Detection ---
+    query_params = dict(request.query_params)
+    url_lang = query_params.get("lang")
+
+    updated_lang = current_lang_state  # Start with the default
+    if url_lang and url_lang in ["en", "zh"]:
+        updated_lang = url_lang
+
+    # --- History Loading Logic ---
     if not history:
-        # First time ever loading, create a new chat
+        # First time ever, create a new conversation
         conv_id = str(uuid.uuid4())
-        new_convo = { "id": conv_id, "title": "(新对话)", "messages": [], "timestamp": datetime.now().isoformat() }
+        new_convo_title = get_text("chat_new_conversation_title", updated_lang)
+        new_convo = {
+            "id": conv_id,
+            "title": new_convo_title,
+            "messages": [],
+            "timestamp": datetime.now().isoformat(),
+        }
         history = [new_convo]
-        return conv_id, history, gr.update(value=get_history_df(history)), []
+        return (
+            conv_id,
+            history,
+            gr.update(value=get_history_df_from_app(history)),
+            [],
+            updated_lang,
+        )
 
-    # Check if the last used conv_id is valid
     if conv_id and any(c["id"] == conv_id for c in history):
-        # It's valid, load it
+        # Valid last session, load it
         for convo in history:
             if convo["id"] == conv_id:
-                return conv_id, history, gr.update(value=get_history_df(history)), convo["messages"]
-    
-    # Last used conv_id is invalid or doesn't exist, load the most recent conversation
-    most_recent_convo = history[0] # Assumes history is sorted by timestamp desc
-    conv_id = most_recent_convo["id"]
-    return conv_id, history, gr.update(value=get_history_df(history)), most_recent_convo["messages"]
-
-    
+                return (
+                    conv_id,
+                    history,
+                    gr.update(value=get_history_df_from_app(history)),
+                    convo["messages"],
+                    updated_lang,
+                )
+
+    # Fallback to most recent conversation
+    most_recent_convo = history[0]
+    return (
+        most_recent_convo["id"],
+        history,
+        gr.update(value=get_history_df_from_app(history)),
+        most_recent_convo["messages"],
+        updated_lang,
+    )
+
+
 CSS = """
 
 #chatbot {
@@ -74,56 +113,188 @@ if __name__ == "__main__":
     logger.info("Starting Ling Space Application...")
     model_handler = ModelHandler()
 
-    with gr.Blocks(analytics_enabled=False,
-                   fill_height=True,
-                   fill_width=True) as demo:
-        with gr.Tabs(elem_id='indicator-space-app') as tabs:
+    with gr.Blocks(analytics_enabled=False, fill_height=True, fill_width=True) as demo:
+        # Language State
+        current_lang_state = gr.State("en")
+
+        # --- Collect all components that need language updates ---
+        all_i18n_outputs = []
 
-            with gr.TabItem("文��聊天") as chat_tab:
-                conversation_store, current_conversation_id, history_df, chatbot = create_chat_tab()
+        with gr.Tabs(elem_id="indicator-space-app") as tabs:
+            welcome_components = create_welcome_tab(current_lang_state.value)
+
+            # The order of components MUST be consistent
+            welcome_outputs = [
+                welcome_components["tab"],
+                welcome_components["header"],
+                welcome_components["description"],
+                welcome_components["chat_description"],
+                welcome_components["code_description"],
+                welcome_components["writer_description"],
+                welcome_components["lang_select_header"],
+                welcome_components["en_button"],
+                welcome_components["zh_button"],
+            ]
+            all_i18n_outputs.extend(welcome_outputs)
+
+            # --- Chat Tab ---
+            with gr.TabItem(
+                get_text("chat_tab_title", current_lang_state.value)
+            ) as chat_tab:
+                chat_components = create_chat_tab(
+                    current_lang_state.value, current_lang_state
+                )
+
+            chat_outputs = [
+                chat_tab,
+                chat_components["new_chat_btn"],
+                chat_components["history_df"],
+                chat_components["chatbot"],
+                chat_components["textbox"],
+                chat_components["submit_btn"],
+                chat_components["recommended_title"],
+                chat_components["recommended_dataset"],
+                chat_components["system_prompt_textbox"],
+                chat_components["temperature_slider"],
+            ]
+            all_i18n_outputs.extend(chat_outputs)
 
             chat_tab.select(
                 fn=None,
                 js="() => {window.dispatchEvent(new CustomEvent('tabSelect.chat')); console.log('this'); return null;}",
             )
 
-            with gr.TabItem("代码生成") as code_tab:
-                create_code_tab()
+            # --- Code Tab ---
+            with gr.TabItem(
+                get_text("code_tab_title", current_lang_state.value)
+            ) as code_tab:
+                code_components = create_code_tab(
+                    current_lang_state.value, current_lang_state
+                )
+
+            code_outputs = [
+                code_tab,
+                code_components["prompt_input"],
+                code_components["overall_style_input"],
+                code_components["decoration_input"],
+                code_components["palette_display"],
+                code_components["generate_style_btn"],
+                code_components["examples_title"],
+                code_components["examples_dataset"],
+                code_components["generate_button"],
+                code_components["preview_tab"],
+                code_components["preview_header"],
+                code_components["source_code_tab"],
+                code_components["source_code_header"],
+                code_components["code_output"],
+                code_components["refresh_button"],
+                code_components["log_chatbot"],
+                code_components["js_error_channel"],
+                # fullscreen_button is updated in its own handler, so it's excluded here
+            ]
+            all_i18n_outputs.extend(code_outputs)
 
             code_tab.select(
                 fn=None,
                 js="() => {window.dispatchEvent(new CustomEvent('tabSelect.code')); return null;}",
             )
 
-            with gr.TabItem("写作助手") as writer_tab:
-                create_smart_writer_tab()
+            # --- Writer Tab ---
+            with gr.TabItem(
+                get_text("writer_tab_title", current_lang_state.value)
+            ) as writer_tab:
+                writer_components = create_smart_writer_tab(current_lang_state.value)
+
+            writer_outputs = [
+                writer_tab,
+                writer_components["style_input"],
+                writer_components["kb_accordion"],
+                writer_components["kb_input"],
+                writer_components["btn_suggest_kb"],
+                writer_components["suggested_kb_dataframe"],
+                writer_components["short_outline_accordion"],
+                writer_components["short_outline_input"],
+                writer_components["btn_sync_outline"],
+                writer_components["long_outline_accordion"],
+                writer_components["long_outline_input"],
+                writer_components["flow_suggestion_display"],
+                writer_components["btn_accept_flow"],
+                writer_components["btn_change_flow"],
+                writer_components["inspiration_prompt_input"],
+                writer_components["prompt_suggestions_dataset"],
+                writer_components["refresh_suggestions_btn"],
+                writer_components["btn_generate_para"],
+                writer_components["btn_change_para"],
+                writer_components["btn_accept_para"],
+                writer_components["para_suggestion_display"],
+                writer_components["polish_title"],
+                writer_components["polish_soon"],
+                writer_components["stats_display"],
+                writer_components["editor"],
+            ]
+            all_i18n_outputs.extend(writer_outputs)
 
             writer_tab.select(
                 fn=None,
                 js="() => {window.dispatchEvent(new CustomEvent('tabSelect.writing')); return null;}",
             )
 
-            with gr.TabItem("测试", visible=False):
-                gr.Markdown("# 功能测试")
-                with gr.Column():
-                    test_log_output = gr.Textbox(label="测试日志", interactive=False, lines=10)
-                    gr.Button("运行 ModelHandler 测试").click(run_model_handler_test, outputs=test_log_output)
-                    gr.Button("运行 清除聊天 测试").click(run_clear_chat_test, outputs=test_log_output)
+        # --- Language Change Handler ---
+        def on_language_change(lang):
+            # Dispatch updates for each tab
+            welcome_updates = update_welcome_language(lang, welcome_components)
+            chat_updates = update_chat_language(lang, chat_components)
+            chat_updates[chat_tab] = gr.update(label=get_text("chat_tab_title", lang))
+
+            code_updates = update_code_language(lang, code_components)
+            code_updates[code_tab] = gr.update(label=get_text("code_tab_title", lang))
+
+            writer_updates = update_writer_language(lang, writer_components)
+            writer_updates[writer_tab] = gr.update(
+                label=get_text("writer_tab_title", lang)
+            )
+
+            all_updates = {
+                **welcome_updates,
+                **chat_updates,
+                **code_updates,
+                **writer_updates,
+            }
+            return tuple(all_updates.get(comp) for comp in all_i18n_outputs)
+
+        current_lang_state.change(
+            fn=on_language_change,
+            inputs=[current_lang_state],
+            outputs=all_i18n_outputs,
+            show_progress="hidden",
+        )
+
+        # --- App Load Handler ---
+        conversation_store = chat_components["conversation_store"]
+        current_conversation_id = chat_components["current_conversation_id"]
+        history_df = chat_components["history_df"]
+        chatbot = chat_components["chatbot"]
 
-        # Bind on_app_load to demo.load
         demo.load(
             on_app_load,
-            inputs=[conversation_store, current_conversation_id],
-            outputs=[current_conversation_id, conversation_store, history_df, chatbot],
-            js="() => {window.dispatchEvent(new CustomEvent('appStart')); console.log('appStart'); return {};}"
+            inputs=[conversation_store, current_conversation_id, current_lang_state],
+            outputs=[
+                current_conversation_id,
+                conversation_store,
+                history_df,
+                chatbot,
+                current_lang_state,
+            ],
+            js="() => {window.dispatchEvent(new CustomEvent('appStart')); console.log('appStart'); return {};}",
         )
 
-    demo.queue(default_concurrency_limit=32,
-               max_size=128)
+    demo.queue(default_concurrency_limit=32, max_size=128)
     # Launch the Gradio application
-    demo.launch(theme=gr.themes.Default(),
+    demo.launch(
+        theme=gr.themes.Default(),
         ssr_mode=False,
         max_threads=64,
         css=CSS,
         head="",
-        head_paths=['./static/toastify.html', './static/app.html'])
+        head_paths=["./static/toastify.html", "./static/app.html"],
+    )

i18n/__init__.py

@@ -0,0 +1,15 @@
+# ling-space/i18n/__init__.py
+from .core import I18nManager
+import gradio as gr
+
+# Global instance
+i18n_manager = I18nManager()
+
+# Helper function to access translations easily if needed in Python
+def get_text(key: str, lang_state: str | gr.State) -> str:
+    lang = lang_state.value if isinstance(lang_state, gr.State) else lang_state
+    return i18n_manager.get(key, lang, default=key)
+
+# Expose the dictionaries for frontend injection
+def get_ui_translations():
+    return i18n_manager.get_all_ui_translations()

i18n/common.py

@@ -0,0 +1,27 @@
+# ling-space/i18n/common.py
+
+ui_translations = {
+    # Common UI elements (Fallback/Generic)
+    "tab_chat": {
+        "en": "Chat",
+        "zh": "文本聊天"
+    },
+    "tab_code": {
+        "en": "Code",
+        "zh": "代码生成"
+    },
+    "tab_writer": {
+        "en": "Writer",
+        "zh": "写作助手"
+    },
+    "tab_test": {
+        "en": "Test",
+        "zh": "测试"
+    },
+    "new_conversation_title": {
+        "en": "(New Conversation)",
+        "zh": "(新对话)"
+    }
+}
+
+prompt_fragments = {}

i18n/core.py

@@ -0,0 +1,61 @@
+# ling-space/i18n/core.py
+from typing import Dict
+from . import common, tab_chat, tab_code, tab_smart_writer, tab_welcome
+
+MODULES = [common, tab_chat, tab_code, tab_smart_writer, tab_welcome]
+
+class I18nManager:
+    def __init__(self):
+        self.ui_translations: Dict[str, Dict[str, str]] = {}
+        self.prompt_fragments: Dict[str, Dict[str, str]] = {}
+        self._load_translations()
+
+    def _load_translations(self):
+        """
+        Load and merge translations from all registered modules.
+        Structure:
+        {
+            "key_name": {
+                "en": "English Text",
+                "zh": "中文文本"
+            },
+            ...
+        }
+        """
+        for module in MODULES:
+            # Merge UI Translations
+            if hasattr(module, "ui_translations"):
+                for key, trans_map in module.ui_translations.items():
+                    if key in self.ui_translations:
+                        print(f"[I18n] Warning: Duplicate UI key '{key}' in {module}. Overwriting.")
+                    self.ui_translations[key] = trans_map
+            
+            # Merge Prompt Fragments
+            if hasattr(module, "prompt_fragments"):
+                for key, trans_map in module.prompt_fragments.items():
+                    if key in self.prompt_fragments:
+                        print(f"[I18n] Warning: Duplicate prompt key '{key}' in {module}. Overwriting.")
+                    self.prompt_fragments[key] = trans_map
+
+    def get_all_ui_translations(self) -> Dict[str, Dict[str, str]]:
+        """Returns the complete dictionary for UI translations."""
+        return self.ui_translations
+
+    def get_all_prompt_translations(self) -> Dict[str, Dict[str, str]]:
+        """Returns the complete dictionary for prompt fragments."""
+        return self.prompt_fragments
+
+    def get(self, key: str, lang: str, default: str) -> str:
+        """
+        Get a specific translation.
+        Checks UI translations first, then prompt fragments.
+        """
+        # Check UI dict
+        if key in self.ui_translations:
+            return self.ui_translations[key].get(lang, default or self.ui_translations[key].get("en", key))
+        
+        # Check Prompt dict
+        if key in self.prompt_fragments:
+            return self.prompt_fragments[key].get(lang, default or self.prompt_fragments[key].get("en", key))
+            
+        return default or key

i18n/tab_chat.py

@@ -0,0 +1,63 @@
+# ling-space/i1n/tab_chat.py
+
+ui_translations = {
+    # Tab Name (used in app.py)
+    "chat_tab_title": {
+        "en": "Chat",
+        "zh": "文本聊天"
+    },
+    # Components
+    "chat_new_chat_button": {
+        "en": "➕ New Chat",
+        "zh": "➕ 新对话"
+    },
+    "chat_history_dataframe_header": {
+        "en": "History",
+        "zh": "对话记录"
+    },
+    "chat_chatbot_placeholder": {
+        "en": "Enter message...",
+        "zh": "输入消息..."
+    },
+    "chat_textbox_placeholder": {
+        "en": "Enter message...",
+        "zh": "输入消息..."
+    },
+    "chat_submit_button": {
+        "en": "Send",
+        "zh": "发送"
+    },
+    "chat_recommended_dialogues_title": {
+        "en": "### Recommended Dialogues",
+        "zh": "### 推荐对话"
+    },
+    "chat_recommended_dataset_label": {
+        "en": "Recommended Scenarios",
+        "zh": "推荐场景"
+    },
+    "chat_recommended_dataset_header": {
+        "en": "Try a scenario",
+        "zh": "选择一个场景试试"
+    },
+    "chat_system_prompt_label": {
+        "en": "System Prompt",
+        "zh": "系统提示词"
+    },
+    "chat_system_prompt_placeholder": {
+        "en": "Enter system prompt...",
+        "zh": "输入系统提示词..."
+    },
+    "chat_temperature_slider_label": {
+        "en": "Temperature",
+        "zh": "温度参数"
+    },
+
+    # Logic-related text
+    "chat_new_conversation_title": {
+        "en": "(New Conversation)",
+        "zh": "(新对话)"
+    }
+}
+
+# Prompt fragments can be added here later if needed
+prompt_fragments = {}

i18n/tab_code.py

@@ -0,0 +1,122 @@
+# ling-space/i18n/tab_code.py
+
+ui_translations = {
+    # Tab Name (used in app.py)
+    "code_tab_title": {
+        "en": "Code Generation",
+        "zh": "代码生成"
+    },
+    # Components
+    "code_prompt_label": {
+        "en": "Prompt",
+        "zh": "提示词"
+    },
+    "code_prompt_placeholder": {
+        "en": "e.g., create a simple page with a title and a button",
+        "zh": "例如：创建一个带标题和按钮的简单页面"
+    },
+    "code_overall_style_label": {
+        "en": "Overall Style",
+        "zh": "整体风格"
+    },
+    "code_overall_style_placeholder": {
+        "en": "e.g., like a parchment book",
+        "zh": "例如：类似一本羊皮纸的书"
+    },
+    "code_decoration_style_label": {
+        "en": "Decoration Style",
+        "zh": "装饰风格"
+    },
+    "code_decoration_style_placeholder": {
+        "en": "e.g., thick borders, no rounded corners",
+        "zh": "例如：粗边框，无圆角"
+    },
+    "code_palette_label": {
+        "en": "Style Palette",
+        "zh": "风格色板"
+    },
+    "code_palette_placeholder": {
+        "en": "(Displays after generating style)",
+        "zh": "(生成风格后展示)"
+    },
+    "code_generate_style_button": {
+        "en": "🎲 Generate Random Style",
+        "zh": "🎲 随机生成风格"
+    },
+    "code_examples_title": {
+        "en": "### Examples",
+        "zh": "### 示例"
+    },
+    "code_examples_dataset_label": {
+        "en": "Examples",
+        "zh": "示例"
+    },
+    "code_examples_dataset_header": {
+        "en": "Select an example",
+        "zh": "选择一个示例"
+    },
+    "code_generate_code_button": {
+        "en": "Generate Code",
+        "zh": "生成代码"
+    },
+    "code_preview_tab_title": {
+        "en": "Live Preview",
+        "zh": "实时预览"
+    },
+    "code_preview_header": {
+        "en": "### Live Preview",
+        "zh": "### 实时预览"
+    },
+    "code_fullscreen_button": {
+        "en": "Fullscreen",
+        "zh": "全屏预览"
+    },
+    "code_exit_fullscreen_button": {
+        "en": "Exit Fullscreen",
+        "zh": "退出全屏"
+    },
+    "code_preview_placeholder": {
+        "en": "<p>Preview will be displayed here.</p>",
+        "zh": "<p>预览将在此处显示。</p>"
+    },
+    "code_source_code_tab_title": {
+        "en": "Generated Source Code",
+        "zh": "生成的源代码"
+    },
+    "code_source_code_header": {
+        "en": "### Generated Source Code",
+        "zh": "### 生成的源代码"
+    },
+    "code_source_code_label": {
+        "en": "Generated Code",
+        "zh": "生成的代码"
+    },
+    "code_refresh_preview_button": {
+        "en": "Refresh Preview",
+        "zh": "刷新预览"
+    },
+    "code_log_chatbot_label": {
+        "en": "Generation Log",
+        "zh": "生成日志"
+    },
+    "code_debug_channel_label": {
+        "en": "Debug Error Channel",
+        "zh": "Debug Error Channel"
+    },
+
+    # Logic-related text
+    "code_log_no_code_warning": {
+        "en": "⚠️ **Warning**: No code available to refresh.",
+        "zh": "⚠️ **警告**: 没有代码可供刷新。"
+    },
+    "code_log_refreshed_state": {
+        "en": "🔄 **Status**: Preview has been manually refreshed.",
+        "zh": "🔄 **状态**: 预览已手动刷新。"
+    },
+    "code_log_runtime_error": {
+        "en": "🚨 **A runtime exception was detected in the preview!**\n```\n{error_text}\n```",
+        "zh": "🚨 **在预览中发现运行时异常!**\n```\n{error_text}\n```"
+    }
+}
+
+prompt_fragments = {}

i18n/tab_smart_writer.py

@@ -0,0 +1,92 @@
+# ling-space/i18n/tab_smart_writer.py
+
+ui_translations = {
+    # Tab Name (used in app.py)
+    "writer_tab_title": {"en": "Writing Assistant", "zh": "写作助手"},
+    # Left Column: Entity Console
+    "writer_style_input_label": {
+        "en": "Overall Story and Style",
+        "zh": "整体故事和风格",
+    },
+    "writer_kb_accordion_label": {"en": "Writing Knowledge Base", "zh": "写作知识库"},
+    "writer_kb_dataframe_headers": {
+        "en": ["Name", "Description"],
+        "zh": ["名称", "说明"],
+    },
+    "writer_suggest_kb_button": {"en": "🔍 Extract New Terms", "zh": "🔍 提取新词条"},
+    "writer_suggested_kb_label": {"en": "Recommended Terms", "zh": "推荐词条"},
+    "writer_short_outline_accordion_label": {
+        "en": "Current Chapter Outline",
+        "zh": "当前章节大纲",
+    },
+    "writer_short_outline_dataframe_headers": {
+        "en": ["Done", "Task"],
+        "zh": ["完成", "任务"],
+    },
+    "writer_sync_outline_button": {"en": "🔄 Sync Status", "zh": "🔄 同步状态"},
+    "writer_long_outline_accordion_label": {
+        "en": "Overall Story Outline",
+        "zh": "故事整体大纲",
+    },
+    # Right Column: Writing Canvas
+    # Area 1: Real-time Continuation (Flow)
+    "writer_flow_suggestion_label": {
+        "en": "Real-time Continuation",
+        "zh": "实时续写建议",
+    },
+    "writer_flow_suggestion_placeholder": {
+        "en": "(Waiting for input or click 'Try another'...)",
+        "zh": "（等待输入或点击“换一个”...）",
+    },
+    "writer_accept_flow_button": {"en": "Accept (Tab)", "zh": "采纳续写 (Tab)"},
+    "writer_change_flow_button": {
+        "en": "Try another (Shift+Tab)",
+        "zh": "换一个 (Shift+Tab)",
+    },
+    "writer_debounce_loading_text": {
+        "en": "Generating suggestion...",
+        "zh": "稍后开始续写",
+    },
+    # Area 2: Paragraph Continuation (Inspiration)
+    "writer_inspiration_prompt_label": {"en": "Continuation Prompt", "zh": "续写提示"},
+    "writer_inspiration_prompt_placeholder": {
+        "en": "e.g., write a paragraph about...",
+        "zh": "例如：写一段关于...的描写",
+    },
+    "writer_prompt_suggestions_label": {
+        "en": "Recommended Prompts (Click to fill)",
+        "zh": "推荐提示 (点击填入)",
+    },
+    "writer_refresh_suggestions_button": {
+        "en": "🎲 New Suggestions",
+        "zh": "🎲 换一批建议",
+    },
+    "writer_generate_para_button": {
+        "en": "Continue Paragraph (Cmd+Enter)",
+        "zh": "整段续写 (Cmd+Enter)",
+    },
+    "writer_change_para_button": {"en": "Try another", "zh": "换一个"},
+    "writer_accept_para_button": {"en": "Accept", "zh": "采纳"},
+    "writer_para_suggestion_placeholder": {
+        "en": "(Click 'Continue Paragraph' to generate content...)",
+        "zh": "（点击“整段续写”生成内容...）",
+    },
+    # Area 3: Adjust/Polish
+    "writer_polish_title": {"en": "#### 🛠️ Adjust & Polish", "zh": "#### 🛠️ 调整润色"},
+    "writer_coming_soon": {"en": "(Coming Soon)", "zh": "(敬请期待)"},
+    # Editor & Stats
+    "writer_editor_label": {"en": "Immersive Writing Canvas", "zh": "沉浸写作画布"},
+    "writer_editor_placeholder": {
+        "en": "Start your creation...",
+        "zh": "开始你的创作...",
+    },
+    "writer_stats_words": {"en": "Words", "zh": "字"},
+    "writer_stats_mins": {"en": "mins", "zh": "分钟"},
+    "writer_stats_format": {
+        "en": "{words} Words | ~{read_time} mins",
+        "zh": "{words} 字 | 约 {read_time} 分钟",
+    },
+    "writer_stats_default": {"en": "0 Words | 0 mins", "zh": "0 字 | 0 分钟"},
+}
+
+prompt_fragments = {}

i18n/tab_welcome.py

@@ -0,0 +1,40 @@
+# ling-space/i18n/tab_welcome.py
+
+ui_translations = {
+    "welcome_tab_title": {
+        "en": "Welcome",
+        "zh": "欢迎"
+    },
+    "welcome_header": {
+        "en": "Welcome to Ling Space",
+        "zh": "欢迎来到 Ling Space"
+    },
+    "welcome_description": {
+        "en": "Experience the power of Ling Series Models through these demos.",
+        "zh": "通过这些演示体验 Ling 系列模型的能力。"
+    },
+    "welcome_chat_desc": {
+        "en": "Text Generation Chat: Converse with the model naturally.",
+        "zh": "文本聊天：与模型进行自然对话。"
+    },
+    "welcome_code_desc": {
+        "en": "Code Generation: Generate and preview code snippets.",
+        "zh": "代码生成：生成并预览代码片段。"
+    },
+    "welcome_writer_desc": {
+        "en": "Smart Writing Assistant: Get help with your writing tasks.",
+        "zh": "写作助手：获取写作任务的帮助。"
+    },
+    "welcome_select_language": {
+        "en": "Select Language",
+        "zh": "选择语言"
+    },
+    "lang_en": {
+        "en": "English",
+        "zh": "English"
+    },
+    "lang_zh": {
+        "en": "中文",
+        "zh": "中文"
+    },
+}

requirements.txt

@@ -1,5 +1,6 @@
 gradio==6.0.1
 python-dotenv
 httpx
+watchfiles
 # transformers
 # torch

run_dev_server.py

@@ -0,0 +1,28 @@
+import watchfiles
+import logging
+import sys
+
+# Configure logging to provide feedback on the watcher's status
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+if __name__ == '__main__':
+    """
+    This script uses 'watchfiles' to monitor for file changes in the current
+    directory (and subdirectories) and automatically restarts the Gradio
+    application.
+
+    It's a convenient way to develop without manually stopping and restarting
+    the server after each code change.
+
+    To run:
+        python run_dev_server.py
+    """
+    logging.info("Starting file watcher and development server for app.py...")
+    
+    # run_process will watch for changes in the current path ('.')
+    # and restart the target command.
+    watchfiles.run_process(
+        '.',  # Watch the current directory
+        target=f'{sys.executable} app.py --color',  # Command to run
+        target_type='command'
+    )

static/app.html

@@ -5,9 +5,73 @@
 
     // --- Logger utility (structured, levelled, timestamped) ---
     const SpaceApp = {
+      
+        STORAGE_KEY_LANG: 'ling_space_locale',
+        URL_PARAM_LANG: 'lang',
 
         hasBooted: false,
         fnUnloadLastTab: null,
+        
+        supportedLangs: function() {
+            return ['en', 'zh'];
+        },
+        
+        setLanguage: function(lang, reload = true) {
+            if (!SpaceApp.supportedLangs().includes(lang)) {
+                console.error(`[I18n] Unsupported language: ${lang}`);
+                return;
+            }
+    
+            localStorage.setItem(SpaceApp.STORAGE_KEY_LANG, lang);
+            console.log(`[I18n] Language set to: ${lang}`);
+    
+            if (reload) {
+                // Update URL to reflect language or just reload
+                const url = new URL(window.location);
+                url.searchParams.set(SpaceApp.URL_PARAM_LANG, lang);
+                window.location.href = url.toString();
+            }
+        },
+        
+        detectLanguage: function() {
+          
+            // 1. Check URL Parameter, if any.
+            const urlParams = new URLSearchParams(window.location.search);
+            const urlLang = urlParams.get(SpaceApp.URL_PARAM_LANG);
+            if (urlLang && SpaceApp.supportedLangs().includes(urlLang)) {
+                console.log(`[I18n] Detected language from URL: ${urlLang}`);
+                return urlLang;
+            } else {
+                console.log(`[I18n] No valid language found in URL parameters, found: ${urlLang}`);
+            }
+    
+            // 2. Check LocalStorage, if any.
+            const storedLang = localStorage.getItem(SpaceApp.STORAGE_KEY_LANG);
+            if (storedLang && SpaceApp.supportedLangs().includes(storedLang)) {
+                console.log(`[I18n] Detected language from LocalStorage: ${storedLang}`);
+                return storedLang;
+            } else {
+                console.log(`[I18n] No valid language found in LocalStorage, found: ${storedLang}`);
+            }
+    
+            // 3. Check Browser User Agent
+            const browserLang = navigator.language || navigator.userLanguage;
+            if (browserLang) {
+                // Extract primary language code (e.g., 'zh-CN' -> 'zh')
+                const primaryLang = browserLang.split('-')[0].toLowerCase();
+                if (SpaceApp.supportedLangs().includes(primaryLang)) {
+                    console.log(`[I18n] Detected language from UserAgent: ${primaryLang} (of ${browserLang})`);
+                    return primaryLang;
+                } else {
+                    console.log(`[I18n] No valid language found in UserAgent, found: ${browserLang}`);
+                }
+            } else {
+                console.log(`[I18n] No language found in UserAgent, navigator is ${JSON.stringify(navigator)}`);
+            }
+    
+            console.log(`[I18n] cannot determine lang, using default language: ${DEFAULT_LOCALE}`);
+            return DEFAULT_LOCALE;
+        },
 
         toastInfo: function(...args) {
             // use toastify
@@ -16,7 +80,9 @@
                 duration: 3000,
                 gravity: "top",
                 position: "right",
-                backgroundColor: "green",
+                style: {
+                  background: "green"
+                }
             }).showToast();
             console.info("TOAST_INFO", ...args);
         },
@@ -27,7 +93,9 @@
                 duration: 5000,
                 gravity: "top",
                 position: "right",
-                backgroundColor: "red",
+                style: {
+                  background: "green"
+                }
             }).showToast();
             console.error("TOAST_ERROR", ...args);
         },
@@ -105,6 +173,14 @@
                 'tabSelect.writing': () => SpaceApp.WritingAssistantTab.toggle(),
                 // New listener for fullscreen toggle
                 'tab.code.toggleFullscreen': (e) => SpaceApp.WebGeneratorTab.toggleFullscreen(e),
+                'langChange.SpaceApp': (e) => {
+                    const lang = e.detail.lang;
+                    if (lang) {
+                        SpaceApp.setLanguage(lang, true);
+                    } else {
+                        console.error("langChange.SpaceApp event received without 'lang' detail.");
+                    }
+                },
             };
             for (const [event, handler] of Object.entries(listeners)) {
                 window.addEventListener(event, handler);
@@ -151,6 +227,8 @@
             return;
         }
         SpaceApp.hasBooted = true;
+        const currentLang = SpaceApp.detectLanguage();
+        SpaceApp.setLanguage(currentLang, false);
         SpaceApp.toastInfo("Booting Space App...");
         SpaceApp.registerEventListeners();
         SpaceApp.TextGeneratorTab.init();

tab_chat.py

@@ -6,62 +6,58 @@ from model_handler import ModelHandler
 from config import CHAT_MODEL_SPECS, LING_1T
 from recommand_config import RECOMMENDED_INPUTS
 from ui_components.model_selector import create_model_selector
+from i18n import get_text
 
-def create_chat_tab():
+def get_history_df(history):
+    if not history:
+        # Provide explicit column names for an empty DataFrame
+        return pd.DataFrame({'ID': pd.Series(dtype='str'), '对话': pd.Series(dtype='str')})
+    df = pd.DataFrame(history)
+    # Ensure columns exist before renaming
+    if 'id' in df.columns and 'title' in df.columns:
+        return df[['id', 'title']].rename(columns={'id': 'ID', '对话': '对话'})
+    else:
+        return pd.DataFrame({'ID': pd.Series(dtype='str'), '对话': pd.Series(dtype='str')})
+
+
+def create_chat_tab(initial_lang: str, current_lang_state: gr.State):
     model_handler = ModelHandler()
 
+    # Browser-side storage for conversation history and current ID
     conversation_store = gr.BrowserState(default_value=[], storage_key="ling_conversation_history")
     current_conversation_id = gr.BrowserState(default_value=None, storage_key="ling_current_conversation_id")
 
-    def get_history_df(history):
-        if not history:
-            return pd.DataFrame({'ID': [], '对话': []})
-        df = pd.DataFrame(history)
-        return df[['id', 'title']].rename(columns={'id': 'ID', 'title': '对话'})
-
-    def handle_new_chat(history, current_conv_id=None):
-        # Try to find the current conversation
+    def handle_new_chat(history, current_conv_id, lang):
         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))
-            )
+            return current_conv_id, history, [], gr.update(value=get_history_df(history))
 
         conv_id = str(uuid.uuid4())
+        new_convo_title = get_text('chat_new_conversation_title', lang)
         new_convo = {
-            "id": conv_id, "title": "(新对话)",
+            "id": conv_id, "title": new_convo_title,
             "messages": [], "timestamp": datetime.now().isoformat()
         }
         updated_history = [new_convo] + (history or [])
-        return (
-            conv_id,
-            updated_history,
-            [],
-            gr.update(value=get_history_df(updated_history))
-        )
+        return conv_id, updated_history, [], gr.update(value=get_history_df(updated_history))
 
-    def load_conversation_from_df(df: pd.DataFrame, evt: gr.SelectData, history):
-        if evt.index is None:
+    def load_conversation_from_df(df: pd.DataFrame, evt: gr.SelectData, history, lang):
+        if evt.index is None or len(df) == 0:
             return None, []
         selected_id = df.iloc[evt.index[0]]['ID']
         for convo in history:
             if convo["id"] == selected_id:
                 return selected_id, convo["messages"]
-        # Fallback to new chat if something goes wrong
-        new_id, _, new_msgs, _ = handle_new_chat(history)
+        new_id, _, new_msgs, _ = handle_new_chat(history, None, lang)
         return new_id, new_msgs
 
     with gr.Row(equal_height=False, elem_id="indicator-chat-tab"):
         with gr.Column(scale=1):
-            new_chat_btn = gr.Button("➕ 新对话")
+            new_chat_btn = gr.Button(get_text('chat_new_chat_button', initial_lang))
             history_df = gr.DataFrame(
                 value=get_history_df(conversation_store.value),
-                headers=["ID", "对话记录"],
+                headers=["ID", get_text('chat_history_dataframe_header', initial_lang)],
                 datatype=["str", "str"],
                 interactive=False,
                 visible=True,
@@ -69,16 +65,17 @@ def create_chat_tab():
             )
 
         with gr.Column(scale=4):
-            chatbot = gr.Chatbot(height=500)
+            chatbot = gr.Chatbot(height=500, placeholder=get_text('chat_chatbot_placeholder', initial_lang))
             with gr.Row():
-                textbox = gr.Textbox(placeholder="输入消息...", container=False, scale=7)
-                submit_btn = gr.Button("发送", scale=1)
+                textbox = gr.Textbox(placeholder=get_text('chat_textbox_placeholder', initial_lang), container=False, scale=7)
+                submit_btn = gr.Button(get_text('chat_submit_button', initial_lang), scale=1)
             
-            gr.Markdown("### 推荐对话")
+            recommended_title = gr.Markdown(get_text('chat_recommended_dialogues_title', initial_lang))
             recommended_dataset = gr.Dataset(
                 components=[gr.Textbox(visible=False)],
                 samples=[[item["task"]] for item in RECOMMENDED_INPUTS],
-                label="推荐场景", headers=["选择一个场景试试"],
+                label=get_text('chat_recommended_dataset_label', initial_lang),
+                headers=[get_text('chat_recommended_dataset_header', initial_lang)],
             )
 
         with gr.Column(scale=1):
@@ -87,17 +84,16 @@ def create_chat_tab():
                 default_model_constant=LING_1T
             )
 
-            system_prompt_textbox = gr.Textbox(label="系统提示词", lines=5, placeholder="输入系统提示词...")
-            temperature_slider = gr.Slider(minimum=0, maximum=1.0, value=0.7, step=0.1, label="温度参数")
+            system_prompt_textbox = gr.Textbox(label=get_text('chat_system_prompt_label', initial_lang), lines=5, placeholder=get_text('chat_system_prompt_placeholder', initial_lang))
+            temperature_slider = gr.Slider(minimum=0, maximum=1.0, value=0.7, step=0.1, label=get_text('chat_temperature_slider_label', initial_lang))
 
         # --- Event Handlers --- #
-        # The change handler is now encapsulated within create_model_selector
-        def on_select_recommendation(evt: gr.SelectData, history, current_conv_id):
+        def on_select_recommendation(evt: gr.SelectData, history, current_conv_id, lang):
             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, current_conv_id)
+            new_id, new_history, new_messages, history_df_update = handle_new_chat(history, current_conv_id, lang)
 
             return (
                 new_id, new_history,
@@ -109,8 +105,6 @@ def create_chat_tab():
                 new_messages
             )
 
-        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:
                 yield chat_history
@@ -120,12 +114,13 @@ def create_chat_tab():
             for history_update in response_generator:
                 yield history_update
 
-        def on_chat_stream_complete(conv_id, history, final_chat_history):
+        def on_chat_stream_complete(conv_id, history, final_chat_history, lang):
             current_convo = next((c for c in history if c["id"] == conv_id), None)
             if not current_convo:
                 return history, gr.update()
-
-            if len(final_chat_history) > len(current_convo["messages"]) and current_convo["title"] == "(新对话)":
+            
+            new_convo_title = get_text('chat_new_conversation_title', lang)
+            if len(final_chat_history) > len(current_convo["messages"]) and current_convo["title"] == new_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]
 
@@ -134,6 +129,27 @@ def create_chat_tab():
 
             history = sorted([c for c in history if c["id"] != conv_id] + [current_convo], key=lambda x: x["timestamp"], reverse=True)
             return history, gr.update(value=get_history_df(history))
+        
+        # Store all components that need i18n updates
+        components = {
+            "new_chat_btn": new_chat_btn,
+            "history_df": history_df,
+            "chatbot": chatbot,
+            "textbox": textbox,
+            "submit_btn": submit_btn,
+            "recommended_title": recommended_title,
+            "recommended_dataset": recommended_dataset,
+            "system_prompt_textbox": system_prompt_textbox,
+            "temperature_slider": temperature_slider,
+            "model_dropdown": model_dropdown,
+            "model_description_markdown": model_description_markdown,
+            # Non-updatable components needed for event handlers and app.py
+            "conversation_store": conversation_store,
+            "current_conversation_id": current_conversation_id,
+        }
+
+        # Wire event handlers
+        recommended_dataset.select(on_select_recommendation, inputs=[conversation_store, current_conversation_id, current_lang_state], outputs=[current_conversation_id, conversation_store, model_dropdown, system_prompt_textbox, temperature_slider, textbox, history_df, chatbot], show_progress="none")
 
         submit_btn.click(
             chat_stream,
@@ -141,7 +157,7 @@ def create_chat_tab():
             [chatbot]
         ).then(
             on_chat_stream_complete,
-            [current_conversation_id, conversation_store, chatbot],
+            [current_conversation_id, conversation_store, chatbot, current_lang_state],
             [conversation_store, history_df]
         )
         textbox.submit(
@@ -150,11 +166,28 @@ def create_chat_tab():
             [chatbot]
         ).then(
             on_chat_stream_complete,
-            [current_conversation_id, conversation_store, chatbot],
+            [current_conversation_id, conversation_store, chatbot, current_lang_state],
             [conversation_store, 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
+        new_chat_btn.click(handle_new_chat, inputs=[conversation_store, current_conversation_id, current_lang_state], outputs=[current_conversation_id, conversation_store, chatbot, history_df])
+        history_df.select(load_conversation_from_df, inputs=[history_df, conversation_store, current_lang_state], outputs=[current_conversation_id, chatbot])
+
+    return components
+
+def update_language(lang: str, components: dict):
+    """
+    Returns a dictionary mapping components to their gr.update calls for language change.
+    """
+    updates = {
+        components["new_chat_btn"]: gr.update(value=get_text('chat_new_chat_button', lang)),
+        components["history_df"]: gr.update(headers=["ID", get_text('chat_history_dataframe_header', lang)]),
+        components["chatbot"]: gr.update(placeholder=get_text('chat_chatbot_placeholder', lang)),
+        components["textbox"]: gr.update(placeholder=get_text('chat_textbox_placeholder', lang)),
+        components["submit_btn"]: gr.update(value=get_text('chat_submit_button', lang)),
+        components["recommended_title"]: gr.update(value=get_text('chat_recommended_dialogues_title', lang)),
+        components["recommended_dataset"]: gr.update(label=get_text('chat_recommended_dataset_label', lang), headers=[get_text('chat_recommended_dataset_header', lang)]),
+        components["system_prompt_textbox"]: gr.update(label=get_text('chat_system_prompt_label', lang), placeholder=get_text('chat_system_prompt_placeholder', lang)),
+        components["temperature_slider"]: gr.update(label=get_text('chat_temperature_slider_label', lang)),
+    }
+    return updates

tab_code.py

@@ -1,16 +1,17 @@
 import gradio as gr
 import logging
-from config import CHAT_MODEL_SPECS, LING_1T, CODE_FRAMEWORK_SPECS, STATIC_PAGE
+from config import CHAT_MODEL_SPECS, LING_1T, CODE_FRAMEWORK_SPECS, REACT_TAILWIND
 from ui_components.model_selector import create_model_selector
 from ui_components.code_framework_selector import create_code_framework_selector
 from code_kit.agent_code_generator import code_generation_agent
 from code_kit.agent_style_generator import generate_random_style
 from code_kit.code_examples import CODE_EXAMPLES
+from i18n import get_text
 
 # Configure logging
 logger = logging.getLogger(__name__)
 
-def refresh_preview(code_type_display_name, current_code, chatbot_history):
+def refresh_preview(code_type_display_name, current_code, chatbot_history, lang):
     """
     Refresh the preview and add a log entry.
     Refactored to rely solely on the HTML content for preview, assuming all frameworks
@@ -21,7 +22,7 @@ def refresh_preview(code_type_display_name, current_code, chatbot_history):
     
     # Simple validation: Check if code seems to be HTML
     if not current_code or not isinstance(current_code, str):
-         chatbot_history.append({"role": "assistant", "content": "⚠️ **警告**: 没有代码可供刷新。"})
+         chatbot_history.append({"role": "assistant", "content": get_text('code_log_no_code_warning', lang)})
          return gr.update(), chatbot_history
 
     # For all currently supported frameworks (Static, React+Tailwind, R3F, Old School), 
@@ -35,16 +36,16 @@ def refresh_preview(code_type_display_name, current_code, chatbot_history):
         </iframe>
     </div>
     """
-    chatbot_history.append({"role": "assistant", "content": "🔄 **状态**: 预览已手动刷新。"})
+    chatbot_history.append({"role": "assistant", "content": get_text('code_log_refreshed_state', lang)})
     logger.info("Refreshed preview.")
     return gr.HTML(final_preview_html), chatbot_history
 
-def toggle_fullscreen(is_fullscreen):
+def toggle_fullscreen(is_fullscreen, lang):
     logger.info(f"--- [Toggle Fullscreen] Called ---")
     logger.info(f"Current state before toggle: {is_fullscreen}")
     
     is_fullscreen = not is_fullscreen
-    new_button_text = "退出全屏" if is_fullscreen else "全屏预览"
+    new_button_text = get_text('code_exit_fullscreen_button', lang) if is_fullscreen else get_text('code_fullscreen_button', lang)
     
     logger.info(f"New state: {is_fullscreen}")
     
@@ -53,12 +54,12 @@ def toggle_fullscreen(is_fullscreen):
         gr.update(value=new_button_text)
     )
 
-def log_js_error(error_text, chatbot_history):
+def log_js_error(error_text, chatbot_history, lang):
     """Appends a JavaScript error received from the frontend to the log chatbot."""
     if not error_text:
         return chatbot_history
         
-    formatted_error = f"🚨 **在预览中发现运行时异常!**\n```\n{error_text}\n```"
+    formatted_error = get_text('code_log_runtime_error', lang).format(error_text=error_text)
     
     # Check if the last message is the same error to prevent flooding
     if chatbot_history and chatbot_history[-1]["content"] == formatted_error:
@@ -67,15 +68,8 @@ def log_js_error(error_text, chatbot_history):
     chatbot_history.append({"role": "assistant", "content": formatted_error})
     return chatbot_history
 
-def create_code_tab():
-    # Inject custom CSS to hide components
-    gr.HTML("""
-    <style>
-        .hidden-component {
-            display: none;
-        }
-    </style>
-    """)
+def create_code_tab(initial_lang: str, current_lang_state: gr.State):
+    gr.HTML("""<style>.hidden-component { display: none; }</style>""")
     fullscreen_state = gr.State(False)
     
     # JavaScript to dispatch a custom event for fullscreen toggle
@@ -110,55 +104,43 @@ def create_code_tab():
             with gr.Column(scale=1): # Settings Panel    
                 code_framework_dropdown = create_code_framework_selector(
                     framework_specs=CODE_FRAMEWORK_SPECS,
-                    default_framework_constant=STATIC_PAGE
+                    default_framework_constant=REACT_TAILWIND
                 )
                 model_choice_dropdown, model_description_markdown = create_model_selector(
                     model_specs=CHAT_MODEL_SPECS,
                     default_model_constant=LING_1T
                 )
-
-                prompt_input = gr.Textbox(lines=5, placeholder="例如：创建一个带标题和按钮的简单页面", label="提示词")
-                
-                overall_style_input = gr.Textbox(label="整体风格", placeholder="例如：类似一本羊皮纸的书", lines=2)
-
-                decoration_input = gr.Textbox(label="装饰风格", placeholder="例如：粗边框，无圆角", lines=2)
-
-                # Hidden textbox to store the raw palette string for the prompt
+                prompt_input = gr.Textbox(lines=5, placeholder=get_text('code_prompt_placeholder', initial_lang), label=get_text('code_prompt_label', initial_lang))
+                overall_style_input = gr.Textbox(label=get_text('code_overall_style_label', initial_lang), placeholder=get_text('code_overall_style_placeholder', initial_lang), lines=2)
+                decoration_input = gr.Textbox(label=get_text('code_decoration_style_label', initial_lang), placeholder=get_text('code_decoration_style_placeholder', initial_lang), lines=2)
                 palette_input = gr.Textbox(label="Palette (Raw)", elem_classes="hidden-component")
-                
-                palette_display = gr.HTML(value='<div style="color: #999; font-size: 12px;">(生成风格后展示)</div>',
-                    container=True,
-                    label="风格色板",
-                    show_label=True)
-
-                generate_style_btn = gr.Button("🎲 随机生成风格", size="sm")
-
+                palette_display = gr.HTML(value=f"<div style='color: #999; font-size: 12px;'>{get_text('code_palette_placeholder', initial_lang)}</div>", container=True, label=get_text('code_palette_label', initial_lang), show_label=True)
+                generate_style_btn = gr.Button(get_text('code_generate_style_button', initial_lang), size="sm")
                 with gr.Column():
-                    gr.Markdown("### 示例")
+                    examples_title = gr.Markdown(get_text('code_examples_title', initial_lang))
                     examples_dataset = gr.Dataset(
                         components=[gr.Textbox(visible=False)],
                         samples=[[item["task"]] for item in CODE_EXAMPLES],
-                        label="示例",
-                        headers=["选择一个示例"],
+                        label=get_text('code_examples_dataset_label', initial_lang),
+                        headers=[get_text('code_examples_dataset_header', initial_lang)],
                     )
-                generate_button = gr.Button("生成代码", variant="primary")
+                generate_button = gr.Button(get_text('code_generate_code_button', initial_lang), variant="primary")
 
         with gr.Column(scale=4):
             with gr.Tabs(elem_id="result_tabs") as result_tabs:
-                with gr.TabItem("实时预览", id=0):
+                with gr.TabItem(get_text('code_preview_tab_title', initial_lang), id=0) as preview_tab:
                     with gr.Row():
-                        gr.Markdown("### 实时预览")
-                        fullscreen_button = gr.Button("全屏预览", scale=0)
-                    preview_output = gr.HTML(value="<p>预览将在此处显示。</p>")
-                with gr.TabItem("生成的源代码", id=1):
-                    gr.Markdown("### 生成的源代码")
-                    code_output = gr.Code(language="html", label="生成的代码", interactive=True)
-                    refresh_button = gr.Button("刷新预览")
+                        preview_header = gr.Markdown(get_text('code_preview_header', initial_lang))
+                        fullscreen_button = gr.Button(get_text('code_fullscreen_button', initial_lang), scale=0)
+                    preview_output = gr.HTML(value=get_text('code_preview_placeholder', initial_lang))
+                with gr.TabItem(get_text('code_source_code_tab_title', initial_lang), id=1) as source_code_tab:
+                    source_code_header = gr.Markdown(get_text('code_source_code_header', initial_lang))
+                    code_output = gr.Code(language="html", label=get_text('code_source_code_label', initial_lang), interactive=True)
+                    refresh_button = gr.Button(get_text('code_refresh_preview_button', initial_lang))
 
         with gr.Column(scale=1, elem_id="right-panel") as right_panel:
-            log_chatbot = gr.Chatbot(label="生成日志", height=300)
-
-            js_error_channel = gr.Textbox(visible=True, elem_classes=["js_error_channel"], label="Debug Error Channel", interactive=False)
+            log_chatbot = gr.Chatbot(label=get_text('code_log_chatbot_label', initial_lang), height=300)
+            js_error_channel = gr.Textbox(visible=True, elem_classes=["js_error_channel"], label=get_text('code_debug_channel_label', initial_lang), interactive=False)
 
     # Event Handler for Example Selection
     def on_select_example(evt: gr.SelectData):
@@ -173,7 +155,7 @@ def create_code_tab():
         fn=on_select_example,
         inputs=None,
         outputs=[prompt_input, model_choice_dropdown],
-        show_progress="none"
+        show_progress="hidden"
     )
 
     # Event Handler for Style Generation
@@ -185,7 +167,7 @@ def create_code_tab():
 
     refresh_button.click(
         fn=refresh_preview,
-        inputs=[code_framework_dropdown, code_output, log_chatbot],
+        inputs=[code_framework_dropdown, code_output, log_chatbot, current_lang_state], 
         outputs=[preview_output, log_chatbot]
     )
 
@@ -205,13 +187,46 @@ def create_code_tab():
     
     fullscreen_button.click(
         fn=toggle_fullscreen,
-        inputs=[fullscreen_state],
+        inputs=[fullscreen_state, current_lang_state],
         outputs=[fullscreen_state, fullscreen_button],
         js=dispatch_fullscreen_event_js
     )
 
     js_error_channel.change(
-        fn=log_js_error,
-        inputs=[js_error_channel, log_chatbot],
+        fn=log_js_error, 
+        inputs=[js_error_channel, log_chatbot, current_lang_state],
         outputs=log_chatbot
     )
+
+    return {
+        "prompt_input": prompt_input, "overall_style_input": overall_style_input,
+        "decoration_input": decoration_input, "palette_display": palette_display,
+        "generate_style_btn": generate_style_btn, "examples_title": examples_title,
+        "examples_dataset": examples_dataset, "generate_button": generate_button,
+        "preview_tab": preview_tab, "preview_header": preview_header,
+        "fullscreen_button": fullscreen_button, "preview_output": preview_output,
+        "source_code_tab": source_code_tab, "source_code_header": source_code_header,
+        "code_output": code_output, "refresh_button": refresh_button,
+        "log_chatbot": log_chatbot, "js_error_channel": js_error_channel
+    }
+
+def update_language(lang: str, components: dict):
+    return {
+        components["prompt_input"]: gr.update(label=get_text('code_prompt_label', lang), placeholder=get_text('code_prompt_placeholder', lang)),
+        components["overall_style_input"]: gr.update(label=get_text('code_overall_style_label', lang), placeholder=get_text('code_overall_style_placeholder', lang)),
+        components["decoration_input"]: gr.update(label=get_text('code_decoration_style_label', lang), placeholder=get_text('code_decoration_style_placeholder', lang)),
+        components["palette_display"]: gr.update(label=get_text('code_palette_label', lang)),
+        components["generate_style_btn"]: gr.update(value=get_text('code_generate_style_button', lang)),
+        components["examples_title"]: gr.update(value=get_text('code_examples_title', lang)),
+        components["examples_dataset"]: gr.update(label=get_text('code_examples_dataset_label', lang), headers=[get_text('code_examples_dataset_header', lang)]),
+        components["generate_button"]: gr.update(value=get_text('code_generate_code_button', lang)),
+        components["preview_tab"]: gr.update(label=get_text('code_preview_tab_title', lang)),
+        components["preview_header"]: gr.update(value=get_text('code_preview_header', lang)),
+        # Fullscreen button is updated in its own event handler
+        components["source_code_tab"]: gr.update(label=get_text('code_source_code_tab_title', lang)),
+        components["source_code_header"]: gr.update(value=get_text('code_source_code_header', lang)),
+        components["code_output"]: gr.update(label=get_text('code_source_code_label', lang)),
+        components["refresh_button"]: gr.update(value=get_text('code_refresh_preview_button', lang)),
+        components["log_chatbot"]: gr.update(label=get_text('code_log_chatbot_label', lang)),
+        components["js_error_channel"]: gr.update(label=get_text('code_debug_channel_label', lang)),
+    }

tab_smart_writer.py

@@ -1,5 +1,4 @@
 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
 from smart_writer_kit.agent_for_paragraph_continuation import fetch_paragraph_continuation_agent
@@ -7,6 +6,7 @@ from smart_writer_kit.agent_for_prompt_suggestion import fetch_prompt_suggestion
 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
+from i18n import get_text
 
 # --- Mock Data (for UI population only) ---
 
@@ -16,7 +16,7 @@ MOCK_STYLE = """故事：人类逐渐走向消亡时，人形机器人的休闲
 """
 
 MOCK_KNOWLEDGE_BASE = [
-    ["Alpha", "故事的主角，女性人形机器人，外表与人类无异。性格有线"],
+    ["Alpha", "故事的主角，女性人形机器人，外表与人类无异。性格悠闲"],
     ["横滨", "故事发生的主要城市。由于海平面上升，城市部分地区被淹没，形成独特的水上景观。"]
 ]
 
@@ -35,71 +35,73 @@ MOCK_LONG_TERM_OUTLINE = [
 ]
 
 # --- UI Helper Functions ---
-def get_stats(text):
+def get_stats(text, lang):
     """Calculate word count and read time."""
     if not text:
-        return "0 Words | 0 mins"
+        return get_text("writer_stats_default", lang)
     words = len(text.split())
     read_time = max(1, words // 200) # Average reading speed
-    return f"{words} Words | ~{read_time} mins"
+    return get_text("writer_stats_format", lang).format(
+        words=words, read_time=read_time
+    )
 
 # --- UI Construction ---
 
-def create_smart_writer_tab():
-    # Initialize DebounceManager
-    debounce_manager = DebounceManager(debounce_time=2.0, tick_time=0.3, loading_text="稍后开始续写")
+def create_smart_writer_tab(initial_lang: str):
+    debounce_manager = DebounceManager(debounce_time=2.0, tick_time=0.3, loading_text=get_text("writer_debounce_loading_text", initial_lang))
 
     with gr.Row(equal_height=False, elem_id="indicator-writing-tab"):
         # --- Left Column: Entity Console ---
         with gr.Column(scale=1) as left_panel:
             
             style_input = gr.Textbox(
-                label="整体故事和风格", 
+                label=get_text("writer_style_input_label", initial_lang),
                 lines=8, 
                 value=MOCK_STYLE,
                 interactive=True
             )
             
-            with gr.Accordion("写作知识库", open=True):
-                
+            with gr.Accordion(
+                get_text("writer_kb_accordion_label", initial_lang), open=True
+            ) as kb_accordion:
                 kb_input = gr.Dataframe(
-                    headers=["名称", "说明"],
+                    headers=[get_text("writer_kb_dataframe_headers", initial_lang), '?'],
                     datatype=["str", "str"],
                     value=MOCK_KNOWLEDGE_BASE,
                     interactive=True,
                     wrap=True
                 )
                 with gr.Row():
-                    btn_suggest_kb = gr.Button("🔍 提取新词条", size="sm")
+                    btn_suggest_kb = gr.Button(get_text("writer_suggest_kb_button", initial_lang), size="sm")
                 
                 suggested_kb_dataframe = gr.Dataframe(
                     headers=["Term", "Description"],
                     datatype=["str", "str"],
                     visible=False, 
                     interactive=False,
-                    label="推荐词条"
+                    label=get_text("writer_suggested_kb_label", initial_lang),
                 )
 
-            with gr.Accordion("当前章节大纲", open=True):
+            with gr.Accordion(get_text("writer_short_outline_accordion_label", initial_lang), open=True) as short_outline_accordion:
                 
                 short_outline_input = gr.Dataframe(
-                    headers=["Done", "Task"],
+                    headers=[get_text("writer_short_outline_dataframe_headers", initial_lang), '?'],
                     datatype=["bool", "str"],
                     value=MOCK_SHORT_TERM_OUTLINE,
                     interactive=True,
-                    label="当前章节大纲",
+                    label="???",
                     col_count=(2, "fixed"),
                 )
                 with gr.Row():
-                    btn_sync_outline = gr.Button("🔄 同步状态", size="sm")
+                    btn_sync_outline = gr.Button(get_text("writer_sync_outline_button", initial_lang), size="sm")
 
-            with gr.Accordion("故事整体大纲", open=False):
+            with gr.Accordion(get_text("writer_long_outline_accordion_label", initial_lang), open=False) as long_outline_accordion:
                 long_outline_input = gr.Dataframe(
-                    headers=["Done", "Task"],
+                    headers=[get_text("writer_short_outline_dataframe_headers", initial_lang), '?'],
                     datatype=["bool", "str"],
                     value=MOCK_LONG_TERM_OUTLINE,
                     interactive=True,
-                    label="故事总纲",
+                    label="???",
                     col_count=(2, "fixed"),
                 )
 
@@ -114,62 +116,63 @@ def create_smart_writer_tab():
 
                     flow_suggestion_display = gr.Textbox(
                         show_label=True,
-                        label="实时续写建议",
-                        placeholder="（等待输入或点击“换一个”...）",
+                        label=get_text("writer_flow_suggestion_label", initial_lang),
+                        placeholder=get_text("writer_flow_suggestion_placeholder", initial_lang),
                         lines=3,
                         interactive=False,
                         elem_classes=["flow-suggestion-box"],
                     )
 
-                    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')
+                    btn_accept_flow = gr.Button(get_text("writer_accept_flow_button", initial_lang),size="sm",variant="primary",elem_id="btn-action-accept-flow")
+                    btn_change_flow = gr.Button(get_text("writer_change_flow_button", initial_lang),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 
+                    debounce_progress.visible = True
 
                 # Area 2: Paragraph Continuation (Inspiration)
                 with gr.Column(scale=1, min_width=200):
                     inspiration_prompt_input = gr.Textbox(
-                        label="续写提示",
-                        placeholder="例如：写一段关于...的描写",
+                        label=get_text("writer_inspiration_prompt_label", initial_lang),
+                        placeholder=get_text("writer_inspiration_prompt_placeholder", initial_lang),
                         lines=2
                     )
-                    
                     prompt_suggestions_dataset = gr.Dataset(
-                        label="推荐提示 (点击填入)",
+                        label=get_text("writer_prompt_suggestions_label", initial_lang),
                         components=[gr.Textbox(visible=False)],
                         samples=[["生成建议..."], ["生成建议..."], ["生成建议..."]],
                         type="values"
                     )
-                    
-                    refresh_suggestions_btn = gr.Button("🎲 换一批建议", size="sm", variant="secondary") # Combined trigger
-
+                    refresh_suggestions_btn = gr.Button(
+                        get_text("writer_refresh_suggestions_button", initial_lang),
+                        size="sm",
+                        variant="secondary",
+                    )
                     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")
-                        btn_accept_para = gr.Button("采纳", size="sm")
+                        btn_generate_para = gr.Button(get_text("writer_generate_para_button", initial_lang),size="sm",variant="primary",elem_id="btn-action-create-paragraph")
+                        btn_change_para = gr.Button(get_text("writer_change_para_button", initial_lang),size="sm")
+                        btn_accept_para = gr.Button(get_text("writer_accept_para_button", initial_lang),size="sm")
 
                     para_suggestion_display = gr.Textbox(
                         show_label=False,
-                        placeholder="（点击“整段续写”生成内容...）",
+                        placeholder=get_text("writer_para_suggestion_placeholder", initial_lang),
                         lines=3,
                         interactive=False
                     )
                 
                 # Area 3: Adjust/Polish (Placeholder)
                 with gr.Column(scale=1, min_width=200):
-                    gr.Markdown("#### 🛠️ 调整润色")
-                    gr.Markdown("(Coming Soon)")
+                    polish_title = gr.Markdown(get_text("writer_polish_title", initial_lang))
+                    polish_soon = gr.Markdown(get_text("writer_coming_soon", initial_lang))
 
             # --- TOOLBAR ---
             with gr.Row(elem_classes=["toolbar"]):
-                stats_display = gr.Markdown("0 Words | 0 mins")
-            
-            # --- EDITOR ---
+                # --- EDITOR ---
+                stats_display = gr.Markdown(get_text("writer_stats_default", initial_lang))
+
             editor = gr.Textbox(
-                label="沉浸写作画布", 
-                placeholder="开始你的创作...", 
+                label=get_text("writer_editor_label", initial_lang),
+                placeholder=get_text("writer_editor_placeholder", initial_lang),
                 lines=25, # Reduced lines slightly to accommodate ribbon
                 elem_classes=["writing-editor"],
                 elem_id="writing-editor",
@@ -269,4 +272,111 @@ def create_smart_writer_tab():
         fn=suggest_new_kb_terms_agent,
         inputs=[kb_input, editor],
         outputs=[suggested_kb_dataframe]
-    )
+    )
+
+    return {
+        "style_input": style_input,
+        "kb_accordion": kb_accordion,
+        "kb_input": kb_input,
+        "btn_suggest_kb": btn_suggest_kb,
+        "suggested_kb_dataframe": suggested_kb_dataframe,
+        "short_outline_accordion": short_outline_accordion,
+        "short_outline_input": short_outline_input,
+        "btn_sync_outline": btn_sync_outline,
+        "long_outline_accordion": long_outline_accordion,
+        "long_outline_input": long_outline_input,
+        "flow_suggestion_display": flow_suggestion_display,
+        "btn_accept_flow": btn_accept_flow,
+        "btn_change_flow": btn_change_flow,
+        "inspiration_prompt_input": inspiration_prompt_input,
+        "prompt_suggestions_dataset": prompt_suggestions_dataset,
+        "refresh_suggestions_btn": refresh_suggestions_btn,
+        "btn_generate_para": btn_generate_para,
+        "btn_change_para": btn_change_para,
+        "btn_accept_para": btn_accept_para,
+        "para_suggestion_display": para_suggestion_display,
+        "polish_title": polish_title,
+        "polish_soon": polish_soon,
+        "stats_display": stats_display,
+        "editor": editor,
+    }
+
+
+def update_language(lang: str, components: dict):
+    return {
+        components["style_input"]: gr.update(
+            label=get_text("writer_style_input_label", lang)
+        ),
+        components["kb_accordion"]: gr.update(
+            label=get_text("writer_kb_accordion_label", lang)
+        ),
+        components["kb_input"]: gr.update(
+            headers=get_text("writer_kb_dataframe_headers", lang)
+        ),
+        components["btn_suggest_kb"]: gr.update(
+            value=get_text("writer_suggest_kb_button", lang)
+        ),
+        components["suggested_kb_dataframe"]: gr.update(
+            label=get_text("writer_suggested_kb_label", lang)
+        ),
+        components["short_outline_accordion"]: gr.update(
+            label=get_text("writer_short_outline_accordion_label", lang)
+        ),
+        components["short_outline_input"]: gr.update(
+            headers=get_text("writer_short_outline_dataframe_headers", lang)
+        ),
+        components["btn_sync_outline"]: gr.update(
+            value=get_text("writer_sync_outline_button", lang)
+        ),
+        components["long_outline_accordion"]: gr.update(
+            label=get_text("writer_long_outline_accordion_label", lang)
+        ),
+        components["long_outline_input"]: gr.update(
+            headers=get_text("writer_short_outline_dataframe_headers", lang)
+        ),  # Assuming same headers
+        components["flow_suggestion_display"]: gr.update(
+            label=get_text("writer_flow_suggestion_label", lang),
+            placeholder=get_text("writer_flow_suggestion_placeholder", lang),
+        ),
+        components["btn_accept_flow"]: gr.update(
+            value=get_text("writer_accept_flow_button", lang)
+        ),
+        components["btn_change_flow"]: gr.update(
+            value=get_text("writer_change_flow_button", lang)
+        ),
+        components["inspiration_prompt_input"]: gr.update(
+            label=get_text("writer_inspiration_prompt_label", lang),
+            placeholder=get_text("writer_inspiration_prompt_placeholder", lang),
+        ),
+        components["prompt_suggestions_dataset"]: gr.update(
+            label=get_text("writer_prompt_suggestions_label", lang)
+        ),
+        components["refresh_suggestions_btn"]: gr.update(
+            value=get_text("writer_refresh_suggestions_button", lang)
+        ),
+        components["btn_generate_para"]: gr.update(
+            value=get_text("writer_generate_para_button", lang)
+        ),
+        components["btn_change_para"]: gr.update(
+            value=get_text("writer_change_para_button", lang)
+        ),
+        components["btn_accept_para"]: gr.update(
+            value=get_text("writer_accept_para_button", lang)
+        ),
+        components["para_suggestion_display"]: gr.update(
+            placeholder=get_text("writer_para_suggestion_placeholder", lang)
+        ),
+        components["polish_title"]: gr.update(
+            value=get_text("writer_polish_title", lang)
+        ),
+        components["polish_soon"]: gr.update(
+            value=get_text("writer_coming_soon", lang)
+        ),
+        components["editor"]: gr.update(
+            label=get_text("writer_editor_label", lang),
+            placeholder=get_text("writer_editor_placeholder", lang),
+        ),
+        components["stats_display"]: gr.update(
+            value=get_text("writer_stats_default", lang)
+        ),  # Reset stats on lang change
+    }

tab_test.py

@@ -1,27 +0,0 @@
-import time
-
-def run_model_handler_test():
-    """
-    Simulates a test for the ModelHandler's get_response method.
-    """
-    log = []
-    log.append("Running ModelHandler test...")
-    # Simulate some test logic
-    time.sleep(1)
-    log.append("ModelHandler test passed: Placeholder response received.")
-    print("\n".join(log)) # Also print to stdio
-    return "\n".join(log)
-
-def run_clear_chat_test():
-    """
-    Simulates a test for the clear_chat functionality.
-    """
-    log = []
-    log.append("Running clear_chat test...")
-    # Simulate some test logic
-    time.sleep(1)
-    log.append("clear_chat test passed: Chatbot and textbox cleared.")
-    print("\n".join(log)) # Also print to stdio
-    return "\n".join(log)
-
-# You can add more test functions here

tab_welcome.py

@@ -0,0 +1,72 @@
+import gradio as gr
+from i18n import get_text
+
+def create_welcome_tab(initial_lang: str):
+    """
+    Creates the UI components for the Welcome Tab.
+    Returns a dictionary of all component handles that need dynamic updates.
+    """
+    with gr.TabItem(get_text("welcome_tab_title", initial_lang)) as welcome_tab:
+        with gr.Column(elem_classes=["welcome-container"]):
+            welcome_header_md = gr.Markdown(f"# {get_text('welcome_header', initial_lang)}")
+            welcome_desc_md = gr.Markdown(get_text('welcome_description', initial_lang))
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    welcome_chat_desc_md = gr.Markdown(f"### {get_text('tab_chat', initial_lang)}\n{get_text('welcome_chat_desc', initial_lang)}")
+                with gr.Column(scale=1):
+                    welcome_code_desc_md = gr.Markdown(f"### {get_text('tab_code', initial_lang)}\n{get_text('welcome_code_desc', initial_lang)}")
+                with gr.Column(scale=1):
+                    welcome_writer_desc_md = gr.Markdown(f"### {get_text('tab_writer', initial_lang)}\n{get_text('welcome_writer_desc', initial_lang)}")
+
+            gr.Markdown("---")
+            
+            with gr.Row():
+                welcome_lang_select_md = gr.Markdown(f"### {get_text('welcome_select_language', initial_lang)}")
+            
+            with gr.Row():
+                en_button = gr.Button(get_text('lang_en', initial_lang))
+                zh_button = gr.Button(get_text('lang_zh', initial_lang))
+            
+            en_button.click(
+                fn=None,
+                inputs=[],
+                js="() => { window.dispatchEvent(new CustomEvent('langChange.SpaceApp', { detail: { lang: 'en' } })); }"
+            )
+            zh_button.click(
+                fn=None,
+                inputs=[],
+                js="() => { window.dispatchEvent(new CustomEvent('langChange.SpaceApp', { detail: { lang: 'zh' } })); }"
+            )
+
+    # Return a dictionary for easier access in app.py
+    components = {
+        "tab": welcome_tab,
+        "header": welcome_header_md,
+        "description": welcome_desc_md,
+        "chat_description": welcome_chat_desc_md,
+        "code_description": welcome_code_desc_md,
+        "writer_description": welcome_writer_desc_md,
+        "lang_select_header": welcome_lang_select_md,
+        "en_button": en_button,
+        "zh_button": zh_button
+    }
+    
+    return components
+
+def update_language(lang: str, components: dict):
+    """
+    Returns a dictionary mapping components to their gr.update calls.
+    """
+    updates = {
+        components["tab"]: gr.update(label=get_text("welcome_tab_title", lang)),
+        components["header"]: gr.update(value=f"# {get_text('welcome_header', lang)}"),
+        components["description"]: gr.update(value=get_text('welcome_description', lang)),
+        components["chat_description"]: gr.update(value=f"### {get_text('tab_chat', lang)}\n{get_text('welcome_chat_desc', lang)}"),
+        components["code_description"]: gr.update(value=f"### {get_text('tab_code', lang)}\n{get_text('welcome_code_desc', lang)}"),
+        components["writer_description"]: gr.update(value=f"### {get_text('tab_writer', lang)}\n{get_text('welcome_writer_desc', lang)}"),
+        components["lang_select_header"]: gr.update(value=f"### {get_text('welcome_select_language', lang)}"),
+        components["en_button"]: gr.update(value=get_text('lang_en', lang)),
+        components["zh_button"]: gr.update(value=get_text('lang_zh', lang)),
+    }
+    return updates