Sync ling-space changes from GitHub commit 9773e54

app.py

@@ -5,7 +5,7 @@ from datetime import datetime
 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 create_chat_tab, get_history_df, on_app_load
 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
@@ -20,75 +20,6 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-
-def get_history_df_from_app(history):
-    if not history:
-        return pd.DataFrame(
-            {"ID": pd.Series(dtype="str"), "对话": pd.Series(dtype="str")}
-        )
-    df = pd.DataFrame(history)
-    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(request: gr.Request, history, conv_id, current_lang_state):
-    """
-    Handles the application's initial state on load.
-    - 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, create a new conversation
-        conv_id = str(uuid.uuid4())
-        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_from_app(history)),
-            [],
-            updated_lang,
-        )
-
-    if conv_id and any(c["id"] == conv_id for c in history):
-        # Valid last session, load it
-        for convo in history:
-            if convo["id"] == conv_id:
-                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 {
@@ -161,7 +92,7 @@ if __name__ == "__main__":
 
             chat_tab.select(
                 fn=None,
-                js="() => {window.dispatchEvent(new CustomEvent('tabSelect.chat')); console.log('this'); return null;}",
+                js="() => {window.dispatchEvent(new CustomEvent('tabSelect.chat')); return null;}",
             )
 
             # --- Code Tab ---

config.py

@@ -7,6 +7,7 @@ API keys, and system prompts for different functionalities.
 
 import os
 from dotenv import load_dotenv
+from i18n.model_config import model_descriptions
 
 # Load environment variables from .secrets file
 load_dotenv(dotenv_path='.secrets')
@@ -38,50 +39,51 @@ RING_MINI_2_0 = "ring-mini-2.0"
 
 
 CHAT_MODEL_SPECS = {
-    LING_MINI_2_0: {
-        "provider": "openai_compatible",
-        "model_id": "inclusionai/ling-mini-2.0",
-        "display_name": "🦉 Ling-mini-2.0",
-        "description": "轻量级对话模型，专为消费级硬件的高效运行而优化，是移动端或本地化部署场景的理想选择。",
-        "url": "https://huggingface.co/inclusionai"
-    },
     LING_1T: {
         "provider": "openai_compatible",
         "model_id": "inclusionai/ling-1t",
         "display_name": "🦉 Ling-1T",
-        "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": "高性能十亿参数模型，针对需要高速响应和复杂指令遵循的场景进行了优化。",
-        "url": "https://huggingface.co/inclusionai"
+        "description": model_descriptions["ling-1t-desc"],
+        "url": "https://huggingface.co/inclusionAI/Ling-1T"
     },
     RING_1T: {
         "provider": "openai_compatible",
         "model_id": "inclusionai/ring-1t",
         "display_name": "💍️ Ring-1T",
-        "description": "全新的万亿参数推理模型，具备强大的代码生成和工具使用能力。",
-        "url": "https://huggingface.co/inclusionai"
+        "description": model_descriptions["ring-1t-desc"],
+        "url": "https://huggingface.co/inclusionAI/Ring-1T"
+    },
+    LING_FLASH_2_0: {
+        "provider": "openai_compatible",
+        "model_id": "inclusionai/ling-flash-2.0",
+        "display_name": "🦉 Ling-flash-2.0",
+        "description": model_descriptions["ling-flash-2.0-desc"],
+        "url": "https://huggingface.co/inclusionAI/Ling-flash-2.0"
     },
     RING_FLASH_2_0: {
         "provider": "openai_compatible",
         "model_id": "inclusionai/ring-flash-2.0",
         "display_name": "💍️ Ring-flash-2.0",
-        "description": "十亿参数推理模型，在性能与成本之间取得了良好的平衡，适用于需要逐步思考或代码生成的通用任务。",
-        "url": "https://huggingface.co/inclusionai"
+        "description": model_descriptions["ring-flash-2.0-desc"],
+        "url": "https://huggingface.co/inclusionAI/Ring-flash-2.0"
+    },
+    LING_MINI_2_0: {
+        "provider": "openai_compatible",
+        "model_id": "inclusionai/ling-mini-2.0",
+        "display_name": "🦉 Ling-mini-2.0",
+        "description": model_descriptions["ling-mini-2.0-desc"],
+        "url": "https://huggingface.co/inclusionAI/Ling-mini-2.0"
     },
     RING_MINI_2_0: {
         "provider": "openai_compatible",
         "model_id": "inclusionai/ring-mini-2.0",
         "display_name": "💍️ Ring-mini-2.0",
-        "description": "一款专为资源受限环境设计的量化且极其高效的推理模型，满足严格的速度和效率要求（如边缘计算）。",
-        "url": "https://huggingface.co/inclusionai"
+        "description": model_descriptions["ring-mini-2.0-desc"],
+        "url": "https://huggingface.co/inclusionAI/Ring-mini-2.0"
     }
 }
 
+
 # --- Code Framework Specifications ---
 
 # Constants for easy referencing of code frameworks
@@ -140,4 +142,4 @@ def get_model_display_name(model_constant: str) -> str:
     Retrieves the display name for a given model constant.
     This is what's shown in the UI.
     """
-    return CHAT_MODEL_SPECS.get(model_constant, {}).get("display_name", model_constant)
+    return CHAT_MODEL_SPECS.get(model_constant, {}).get("display_name", model_constant)

i18n/common.py

@@ -21,6 +21,10 @@ ui_translations = {
     "new_conversation_title": {
         "en": "(New Conversation)",
         "zh": "(新对话)"
+    },
+    "model_selector_label": {
+        "en": "Select Model",
+        "zh": "模型选择"
     }
 }
 

i18n/model_config.py

@@ -0,0 +1,36 @@
+# ling-space/i18n/model_config.py
+
+# Constants for easy referencing of models (these are still needed for config.py's CHAT_MODEL_SPECS keys)
+LING_MINI_2_0 = "ling-mini-2.0"
+LING_1T = "ling-1t"
+LING_FLASH_2_0 = "ling-flash-2.0"
+RING_1T = "ring-1t"
+RING_FLASH_2_0 = "ring-flash-2.0"
+RING_MINI_2_0 = "ring-mini-2.0"
+
+model_descriptions = {
+    "ling-1t-desc": {
+        "zh": "万亿参数的旗舰级非“思考”模型，为通用复杂推理任务和人机协同智能而设计。擅长高效推理、代码生成、软件开发、竞赛级数学等。",
+        "en": "A trillion-parameter flagship non-\"thinking\" model designed for general-purpose complex reasoning and collaborative human-AI intelligence. Excels in efficient reasoning, code generation, software development, and competition-level mathematics."
+    },
+    "ring-1t-desc": {
+        "zh": "万亿参数的“思考”模型，专为复杂推理任务深度优化。在数学竞赛、代码生成、逻辑推理、医疗保健和创意写作等领域表现出色。",
+        "en": "A trillion-parameter \"thinking\" model, deeply optimized for complex reasoning tasks. It shows strong performance in math competitions, code generation, logical reasoning, healthcare, and creative writing."
+    },
+    "ling-flash-2.0-desc": {
+        "zh": "高性能通用语言模型，专注于推理和创意应用。在复杂推理、代码生成、前端开发和创意任务方面表现出色。",
+        "en": "A general-purpose language model focusing on reasoning and creative applications. It is strong in complex reasoning, code generation, frontend development, and creative tasks."
+    },
+    "ring-flash-2.0-desc": {
+        "zh": "高性能“思考”模型，为复杂推理深度优化。在数学竞赛、代码生成、逻辑推理、科学和医学推理及创意写作方面表现领先。",
+        "en": "A high-performance \"thinking\" model, deeply optimized for complex reasoning. It exhibits leading performance in math competitions, code generation, logical reasoning, scientific and medical reasoning, and creative writing."
+    },
+    "ling-mini-2.0-desc": {
+        "zh": "紧凑而强大的 MoE 模型，是 MoE 研究和小型 LLM 应用的理想起点。在编码、数学和知识密集型任务中表现出强大的通用和专业推理能力。",
+        "en": "A compact yet powerful MoE-based large language model, ideal for MoE research and small-size LLM applications. It demonstrates strong general and professional reasoning in coding, mathematics, and knowledge-intensive tasks."
+    },
+    "ring-mini-2.0-desc": {
+        "zh": "为推理而优化的高性能、面向推理的 MoE 模型。提供全面的推理能力，尤其擅长逻辑推理、代码生成和数学任务。",
+        "en": "A high-performance, inference-oriented MoE model optimized for reasoning. It offers comprehensive reasoning capabilities, particularly excelling in logical reasoning, code generation, and mathematical tasks."
+    }
+}

i18n/tab_chat.py

@@ -15,6 +15,10 @@ ui_translations = {
         "en": "History",
         "zh": "对话记录"
     },
+    "chat_history_summary_header": {
+        "en": "Summary",
+        "zh": "内容摘要"
+    },
     "chat_chatbot_placeholder": {
         "en": "Enter message...",
         "zh": "输入消息..."

model_handler.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 import httpx
 import json
-from config import CHAT_MODEL_SPECS, OPEN_AI_KEY, OPEN_AI_ENTRYPOINT, OPEN_AI_PROVIDER, get_model_id
+from config import CHAT_MODEL_SPECS, OPEN_AI_KEY, OPEN_AI_ENTRYPOINT, OPEN_AI_PROVIDER
 
 class ModelProvider(ABC):
     """

static/app.html

@@ -77,11 +77,12 @@
             // use toastify
             window.Toastify({
                 text: args.join(' '),
-                duration: 3000,
-                gravity: "top",
+                duration: 2000,
+                gravity: "bottom",
                 position: "right",
                 style: {
-                  background: "green"
+                  background: "green",
+                  fontSize: "0.8em"
                 }
             }).showToast();
             console.info("TOAST_INFO", ...args);

tab_chat.py

@@ -2,22 +2,136 @@ import gradio as gr
 import uuid
 from datetime import datetime
 import pandas as pd
+import re
 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 get_history_df(history):
+def on_app_load(request: gr.Request, history, conv_id, current_lang_state):
+    """
+    Handles the application's initial state on load.
+    - 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, create a new conversation
+        conv_id = str(uuid.uuid4())
+        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(),
+            "system_prompt": "",
+            "model": CHAT_MODEL_SPECS[LING_1T]["display_name"],
+            "temperature": 0.7
+        }
+        history = [new_convo]
+        return (
+            conv_id,
+            history,
+            gr.update(value=get_history_df(history, updated_lang)),
+            [],
+            updated_lang,
+        )
+
+    if conv_id and any(c["id"] == conv_id for c in history):
+        # 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, updated_lang)),
+                    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(history, updated_lang)),
+        most_recent_convo["messages"],
+        updated_lang,
+    )
+
+
+def generate_conversation_title(messages, system_prompt):
+    """
+    Generates a conversation title based on a heuristic, defensively handling
+    multiple possible message formats.
+    1. Tries to use the first user query.
+    2. Falls back to the system prompt.
+    3. Falls back to the current time.
+    """
+    first_query = None
+    
+    # Rule 1: Try to extract the first user query from various possible formats
+    if messages:
+        first_message = messages[0]
+        # Case 1: List[List[str]] -> [['user', 'assistant'], ...]
+        if isinstance(first_message, (list, tuple)) and len(first_message) > 0:
+            first_query = first_message[0]
+        # Case 2: List[Dict] (OpenAI format or others)
+        elif isinstance(first_message, dict):
+            if first_message.get("role") == "user":
+                first_query = first_message.get("content")
+            elif "text" in first_message: # Fallback for other observed formats
+                first_query = first_message["text"]
+
+    if first_query and isinstance(first_query, str):
+        # Split by common Chinese and English punctuation and whitespace
+        delimiters = r"[，。？！,?!.\s]+"
+        segments = re.split(delimiters, first_query)
+        
+        title = ""
+        for seg in segments:
+            if seg:
+                title += seg
+                if len(title) > 3:
+                    return title[:50]  # Limit title length
+        if title:
+             return title[:50]
+
+    # Rule 2: Use the system prompt
+    if system_prompt:
+        return system_prompt[:32]
+        
+    # Rule 3: Use the current time
+    return datetime.now().strftime("%H:%M")
+
+
+def get_history_df(history, lang: str):
+    """
+    Generates a language-aware DataFrame for the conversation history.
+    """
     if not history:
         # Provide explicit column names for an empty DataFrame
-        return pd.DataFrame({'ID': pd.Series(dtype='str'), '对话': pd.Series(dtype='str')})
+        return pd.DataFrame({'ID': pd.Series(dtype='str'), get_text('chat_history_dataframe_header', lang): 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', '对话': '对话'})
+        header_text = get_text('chat_history_dataframe_header', lang)
+        # Ensure title is a string
+        df['title'] = df['title'].astype(str)
+        return df[['id', 'title']].rename(columns={'id': 'ID', 'title': header_text})
     else:
-        return pd.DataFrame({'ID': pd.Series(dtype='str'), '对话': pd.Series(dtype='str')})
+        return pd.DataFrame({'ID': pd.Series(dtype='str'), get_text('chat_history_dataframe_header', lang): pd.Series(dtype='str')})
 
 
 def create_chat_tab(initial_lang: str, current_lang_state: gr.State):
@@ -31,37 +145,50 @@ def create_chat_tab(initial_lang: str, current_lang_state: gr.State):
         current_convo = next((c for c in history if c["id"] == current_conv_id), None) if history else None
 
         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, lang))
 
         conv_id = str(uuid.uuid4())
         new_convo_title = get_text('chat_new_conversation_title', lang)
         new_convo = {
             "id": conv_id, "title": new_convo_title,
-            "messages": [], "timestamp": datetime.now().isoformat()
+            "messages": [], "timestamp": datetime.now().isoformat(),
+            "system_prompt": "",
+            "model": CHAT_MODEL_SPECS[LING_1T]["display_name"],
+            "temperature": 0.7
         }
         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, lang))
 
     def load_conversation_from_df(df: pd.DataFrame, evt: gr.SelectData, history, lang):
         if evt.index is None or len(df) == 0:
-            return None, []
+            return None, [], "", CHAT_MODEL_SPECS[LING_1T]["display_name"], 0.7, ""
+
         selected_id = df.iloc[evt.index[0]]['ID']
-        for convo in history:
-            if convo["id"] == selected_id:
-                return selected_id, convo["messages"]
+        convo = next((c for c in history if c["id"] == selected_id), None)
+
+        if convo:
+            # Use .get() to provide defaults for old conversations
+            system_prompt = convo.get("system_prompt", "")
+            model = convo.get("model", CHAT_MODEL_SPECS[LING_1T]["display_name"])
+            temperature = convo.get("temperature", 0.7)
+            
+            # Return updates for all components
+            return selected_id, convo["messages"], system_prompt, model, temperature, ""
+        
+        # Fallback to creating a new chat if something goes wrong
         new_id, _, new_msgs, _ = handle_new_chat(history, None, lang)
-        return new_id, new_msgs
+        return new_id, new_msgs, "", CHAT_MODEL_SPECS[LING_1T]["display_name"], 0.7, ""
 
     with gr.Row(equal_height=False, elem_id="indicator-chat-tab"):
         with gr.Column(scale=1):
             new_chat_btn = gr.Button(get_text('chat_new_chat_button', initial_lang))
             history_df = gr.DataFrame(
-                value=get_history_df(conversation_store.value),
+                value=get_history_df(conversation_store.value, initial_lang),
                 headers=["ID", get_text('chat_history_dataframe_header', initial_lang)],
                 datatype=["str", "str"],
                 interactive=False,
                 visible=True,
-                column_widths=["0%", "99%"]
+                column_widths=["0%", "100%"]
             )
 
         with gr.Column(scale=4):
@@ -81,7 +208,9 @@ def create_chat_tab(initial_lang: str, current_lang_state: gr.State):
         with gr.Column(scale=1):
             model_dropdown, model_description_markdown = create_model_selector(
                 model_specs=CHAT_MODEL_SPECS,
-                default_model_constant=LING_1T
+                default_model_constant=LING_1T,
+                lang_state=current_lang_state,
+                initial_lang=initial_lang
             )
 
             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))
@@ -114,21 +243,28 @@ def create_chat_tab(initial_lang: str, current_lang_state: gr.State):
             for history_update in response_generator:
                 yield history_update
 
-        def on_chat_stream_complete(conv_id, history, final_chat_history, lang):
+        def on_chat_stream_complete(conv_id, history, final_chat_history, system_prompt, model_display_name, temperature, lang):
             current_convo = next((c for c in history if c["id"] == conv_id), None)
             if not current_convo:
                 return history, gr.update()
             
-            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]
+            # Check if this is the first turn of a new conversation
+            new_convo_title_default = get_text('chat_new_conversation_title', lang)
+            is_new_conversation = current_convo["title"] == new_convo_title_default
+            
+            # If it's a new conversation and we have messages, generate a title and save metadata
+            if is_new_conversation and len(final_chat_history) > len(current_convo.get("messages", [])):
+                current_convo["system_prompt"] = system_prompt
+                current_convo["model"] = model_display_name
+                current_convo["temperature"] = temperature
+                new_title = generate_conversation_title(final_chat_history, system_prompt)
+                current_convo["title"] = new_title
 
             current_convo["messages"] = final_chat_history
             current_convo["timestamp"] = datetime.now().isoformat()
 
             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))
+            return history, gr.update(value=get_history_df(history, lang))
         
         # Store all components that need i18n updates
         components = {
@@ -149,7 +285,7 @@ def create_chat_tab(initial_lang: str, current_lang_state: gr.State):
         }
 
         # 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")
+        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="hidden")
 
         submit_btn.click(
             chat_stream,
@@ -157,7 +293,7 @@ def create_chat_tab(initial_lang: str, current_lang_state: gr.State):
             [chatbot]
         ).then(
             on_chat_stream_complete,
-            [current_conversation_id, conversation_store, chatbot, current_lang_state],
+            [current_conversation_id, conversation_store, chatbot, system_prompt_textbox, model_dropdown, temperature_slider, current_lang_state],
             [conversation_store, history_df]
         )
         textbox.submit(
@@ -166,12 +302,12 @@ def create_chat_tab(initial_lang: str, current_lang_state: gr.State):
             [chatbot]
         ).then(
             on_chat_stream_complete,
-            [current_conversation_id, conversation_store, chatbot, current_lang_state],
+            [current_conversation_id, conversation_store, chatbot, system_prompt_textbox, model_dropdown, temperature_slider, current_lang_state],
             [conversation_store, history_df]
         )
 
         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])
+        history_df.select(load_conversation_from_df, inputs=[history_df, conversation_store, current_lang_state], outputs=[current_conversation_id, chatbot, system_prompt_textbox, model_dropdown, temperature_slider, textbox])
 
     return components
 

tab_code.py

@@ -108,7 +108,9 @@ def create_code_tab(initial_lang: str, current_lang_state: gr.State):
                 )
                 model_choice_dropdown, model_description_markdown = create_model_selector(
                     model_specs=CHAT_MODEL_SPECS,
-                    default_model_constant=LING_1T
+                    default_model_constant=LING_1T,
+                    lang_state=current_lang_state,
+                    initial_lang=initial_lang
                 )
                 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)
@@ -207,7 +209,9 @@ def create_code_tab(initial_lang: str, current_lang_state: gr.State):
         "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
+        "log_chatbot": log_chatbot, "js_error_channel": js_error_channel,
+        "model_choice_dropdown": model_choice_dropdown,
+        "model_description_markdown": model_description_markdown
     }
 
 def update_language(lang: str, components: dict):

ui_components/model_selector.py

@@ -1,12 +1,15 @@
 import gradio as gr
+from i18n import get_text
 
-def create_model_selector(model_specs, default_model_constant):
+def create_model_selector(model_specs, default_model_constant, lang_state, initial_lang):
     """
-    Creates a reusable Gradio model selector component.
+    Creates a reusable Gradio model selector component that is language-aware.
 
     Args:
         model_specs (dict): A dictionary containing the specifications for each model.
         default_model_constant (str): The key for the default model in the model_specs dictionary.
+        lang_state (gr.State): The Gradio state object holding the current language.
+        initial_lang (str): The initial language to set up the component.
 
     Returns:
         tuple: A tuple containing the model dropdown and the model description markdown components.
@@ -14,27 +17,53 @@ def create_model_selector(model_specs, default_model_constant):
     display_names = [d["display_name"] for d in model_specs.values()]
     default_display_name = model_specs[default_model_constant]["display_name"]
 
-
     model_dropdown = gr.Dropdown(
         choices=display_names,
-        label="模型选择",
+        label=get_text("model_selector_label", initial_lang),
         value=default_display_name,
         interactive=True
     )
 
-    def get_model_description(model_display_name):
+    def get_model_description(model_display_name, lang):
+        """Fetches the description for a given model in the specified language."""
         for model_spec in model_specs.values():
             if model_spec["display_name"] == model_display_name:
-                return model_spec["description"]
-        return ""
+                # Safely access the description dictionary
+                description_dict = model_spec.get("description", {})
+                return description_dict.get(lang, "Description not available.")
+        return "Model not found."
+
+    model_description_markdown = gr.Markdown(
+        get_model_description(default_display_name, initial_lang),
+        container=True
+    )
 
-    model_description_markdown = gr.Markdown(get_model_description(default_display_name),
-                                             container=True)
+    # Handler to update the description based on dropdown and language state
+    def update_description(model_name, lang):
+        return get_model_description(model_name, lang)
 
+    # Event listener for when the model selection changes
     model_dropdown.change(
-        fn=get_model_description,
-        inputs=[model_dropdown],
-        outputs=[model_description_markdown]
+        fn=update_description,
+        inputs=[model_dropdown, lang_state],
+        outputs=[model_description_markdown],
+        show_progress="hidden"
+    )
+
+    # Event listener for when the language changes
+    lang_state.change(
+        fn=update_description,
+        inputs=[model_dropdown, lang_state],
+        outputs=[model_description_markdown],
+        show_progress="hidden"
+    )
+    
+    # Also need to update the label on language change
+    lang_state.change(
+        fn=lambda lang: gr.update(label=get_text("model_selector_label", lang)),
+        inputs=[lang_state],
+        outputs=[model_dropdown],
+        show_progress="hidden"
     )
 
-    return model_dropdown, model_description_markdown
+    return model_dropdown, model_description_markdown