Upload 3 files

app.py

@@ -0,0 +1,1046 @@
+import os
+import uuid
+import json
+import gradio as gr
+import modelscope_studio.components.antd as antd
+import modelscope_studio.components.antdx as antdx
+import modelscope_studio.components.base as ms
+from openai import OpenAI
+import requests
+from typing import Generator, Dict, Any
+import logging
+import time
+
+# =========== Configuration
+# MODEL NAME
+model = os.getenv("MODEL_NAME")
+# 代理服务器配置
+PROXY_BASE_URL = os.getenv("PROXY_API_BASE", "http://localhost:8000")
+PROXY_TIMEOUT = int(os.getenv("PROXY_TIMEOUT", 30))
+MAX_RETRIES = int(os.getenv("MAX_RETRIES", 5))
+# 保存历史
+save_history = True
+
+# =========== Configuration
+
+# 配置日志
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class DeltaObject:
+    """模拟OpenAI Delta对象"""
+    def __init__(self, data: dict):
+        self.content = data.get('content')
+        self.role = data.get('role')
+
+class ChoiceObject:
+    """模拟OpenAI Choice对象"""
+    def __init__(self, choice_data: dict):
+        delta_data = choice_data.get('delta', {})
+        self.delta = DeltaObject(delta_data)
+        self.finish_reason = choice_data.get('finish_reason')
+        self.index = choice_data.get('index', 0)
+
+class ChunkObject:
+    """模拟OpenAI Chunk对象"""
+    def __init__(self, chunk_data: dict):
+        choices_data = chunk_data.get('choices', [])
+        self.choices = [ChoiceObject(choice) for choice in choices_data]
+        self.id = chunk_data.get('id', '')
+        self.object = chunk_data.get('object', 'chat.completion.chunk')
+        self.created = chunk_data.get('created', 0)
+        self.model = chunk_data.get('model', '')
+
+class ProxyClient:
+    """代理客户端，用于与中间服务通信"""
+    
+    def __init__(self, base_url: str, timeout: int = 30):
+        self.base_url = base_url.rstrip('/')
+        self.timeout = timeout
+        self.session = requests.Session()
+    
+    def chat_completions_create(self, model: str, messages: list, stream: bool = True, **kwargs):
+        """创建聊天完成请求"""
+        url = f"{self.base_url}/chat/completions"
+        
+        payload = {
+            "model": model,
+            "messages": messages,
+            "stream": stream,
+            **kwargs
+        }
+        
+        try:
+            response = self.session.post(
+                url, 
+                json=payload, 
+                stream=stream,
+                timeout=self.timeout,
+                headers={"Content-Type": "application/json"}
+            )
+            response.raise_for_status()
+            
+            if stream:
+                return self._parse_stream_response(response)
+            else:
+                return response.json()
+                
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Request failed: {str(e)}")
+            raise Exception(f"Failed to connect to proxy server: {str(e)}")
+    
+    def _parse_stream_response(self, response) -> Generator[ChunkObject, None, None]:
+        """解析流式响应"""
+        try:
+            # 确保响应编码正确
+            response.encoding = 'utf-8'
+            
+            for line in response.iter_lines(decode_unicode=True):
+                if not line:
+                    continue
+                    
+                line = line.strip()
+                if line.startswith('data: '):
+                    data = line[6:]  # 移除 'data: ' 前缀
+                    
+                    if data == '[DONE]':
+                        break
+                    
+                    try:
+                        chunk_data = json.loads(data)
+                        
+                        # 检查是否是错误响应
+                        if 'error' in chunk_data:
+                            raise Exception(f"Stream error: {chunk_data.get('detail', chunk_data['error'])}")
+                        
+                        # 创建与OpenAI客户端兼容的响应对象
+                        yield ChunkObject(chunk_data)
+                        
+                    except json.JSONDecodeError as e:
+                        logger.warning(f"Failed to parse JSON: {data}, error: {str(e)}")
+                        continue
+                        
+        except Exception as e:
+            logger.error(f"Error parsing stream response: {str(e)}")
+            raise
+    
+    def health_check(self) -> dict:
+        """健康检查"""
+        try:
+            url = f"{self.base_url}/health"
+            response = self.session.get(url, timeout=self.timeout)
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            logger.error(f"Health check failed: {str(e)}")
+            return {"status": "unhealthy", "error": str(e)}
+
+# 初始化代理客户端
+client = ProxyClient(PROXY_BASE_URL, PROXY_TIMEOUT)
+
+def chat_with_retry(history_messages, max_retries=MAX_RETRIES):
+    """带重试机制的聊天函数"""
+    last_exception = None
+    
+    for attempt in range(max_retries):
+        try:
+            logger.info(f"Chat attempt {attempt + 1}/{max_retries}")
+            
+            # 检查代理服务健康状态
+            health = client.health_check()
+            if health.get("status") != "healthy":
+                raise Exception(f"Proxy service unhealthy: {health}")
+            
+            response = client.chat_completions_create(
+                model=model,
+                messages=history_messages,
+                stream=True,
+                temperature = 0.7, top_p = 0.8
+            )
+            
+            return response
+            
+        except Exception as e:
+            last_exception = e
+            logger.warning(f"Attempt {attempt + 1} failed: {str(e)}")
+            
+            if attempt < max_retries - 1:
+                # 指数退避
+                wait_time = min(2 ** attempt, 4)
+                logger.info(f"Retrying in {wait_time} seconds...")
+                time.sleep(wait_time)
+            else:
+                logger.error(f"All {max_retries} attempts failed")
+    
+    raise last_exception
+
+
+is_modelscope_studio = os.getenv('MODELSCOPE_ENVIRONMENT') == 'studio'
+def get_text(text: str, cn_text: str):
+    if is_modelscope_studio:
+        return cn_text
+    return text
+
+logo_img = os.path.join(os.path.dirname(__file__), "rednote_hilab.png")
+
+DEFAULT_PROMPTS = [{
+    "category":
+    "🖋 Make a plan",
+    "prompts": [
+        "Help me with a plan to start a business",
+        "Help me with a plan to achieve my goals",
+        "Help me with a plan for a successful interview"
+    ]
+}, {
+    "category":
+    "📅 Help me write",
+    "prompts": [
+        "Help me write a story with a twist ending",
+        "Help me write a blog post on mental health",
+        "Help me write a letter to my future self"
+    ]
+}]
+
+DEFAULT_SUGGESTIONS = [{
+    "label":
+    'Make a plan',
+    "value":
+    "Make a plan",
+    "children": [{
+        "label": "Start a business",
+        "value": "Help me with a plan to start a business"
+    }, {
+        "label": "Achieve my goals",
+        "value": "Help me with a plan to achieve my goals"
+    }, {
+        "label": "Successful interview",
+        "value": "Help me with a plan for a successful interview"
+    }]
+}, {
+    "label":
+    'Help me write',
+    "value":
+    "Help me write",
+    "children": [{
+        "label": "Story with a twist ending",
+        "value": "Help me write a story with a twist ending"
+    }, {
+        "label": "Blog post on mental health",
+        "value": "Help me write a blog post on mental health"
+    }, {
+        "label": "Letter to my future self",
+        "value": "Help me write a letter to my future self"
+    }]
+}]
+
+DEFAULT_CONVERSATIONS_HISTORY = [{"role": "placeholder"}]
+
+DEFAULT_LOCALE = 'zh_CN' if is_modelscope_studio else 'en_US'
+
+DEFAULT_THEME = {
+    "token": {
+        "colorPrimary": "#6A57FF",
+    }
+}
+
+
+def format_history(history):
+    messages = [{
+        "role": "system",
+        "content": "You are a helpful assistant.",
+    }]
+    for item in history:
+        if item["role"] == "user":
+            messages.append({"role": "user", "content": item["content"]})
+        elif item["role"] == "assistant":
+            messages.append({"role": "assistant", "content": item["content"]})
+    return messages
+
+
+class Gradio_Events:
+
+    @staticmethod
+    def _submit(state_value):
+        history = state_value["conversations_history"][
+            state_value["conversation_id"]]
+        # submit 
+        history_messages = format_history(history)
+
+        history.append({
+            "role": "assistant",
+            "content": "",
+            "key": str(uuid.uuid4()),
+            "meta": {
+                "reason_content": ""
+            },
+            "loading": True,
+        })
+
+        yield {
+            chatbot: gr.update(items=history),
+            state: gr.update(value=state_value),
+        }
+        try:
+            response = chat_with_retry(history_messages)
+
+            thought_done = False
+            for chunk in response:
+                # 安全地访问chunk属性
+                if chunk.choices and len(chunk.choices) > 0:
+                    content = chunk.choices[0].delta.content
+                else:
+                    content = None
+                    raise ValueError('Content is None')
+                    
+                history[-1]["loading"] = False
+
+                if content and not thought_done:
+                    thought_done = True                    
+                    history[-1]["content"] = ""
+                
+                if content:
+                    history[-1]["content"] += content
+
+                yield {
+                    chatbot: gr.update(items=history),
+                    state: gr.update(value=state_value)
+                }
+            
+            history[-1]["meta"]["end"] = True
+            print("Answer: ", history[-1]["content"])
+
+        except Exception as e:
+            history[-1]["loading"] = False
+            history[-1]["meta"]["end"] = True
+            history[-1]["meta"]["error"] = True
+            history[-1]["content"] = "Failed to respond, please try again."
+            yield {
+                chatbot: gr.update(items=history),
+                state: gr.update(value=state_value)
+            }
+            print('Error: ',e)
+            raise e
+   
+
+    @staticmethod
+    def submit(sender_value, state_value):
+        if not state_value["conversation_id"]:
+            random_id = str(uuid.uuid4())
+            history = []
+            state_value["conversation_id"] = random_id
+            state_value["conversations_history"][random_id] = history
+            state_value["conversations"].append({
+                "label": sender_value,
+                "key": random_id
+            })
+
+        history = state_value["conversations_history"][
+            state_value["conversation_id"]]
+        history.append({
+            "role": "user",
+            "meta": {},
+            "key": str(uuid.uuid4()),
+            "content": sender_value
+        })
+
+        # preprocess submit
+        yield Gradio_Events.preprocess_submit()(state_value)
+        try:
+          for chunk in Gradio_Events._submit(state_value):
+                yield chunk
+        except Exception as e:
+            raise e
+        finally:
+          # postprocess submit
+          yield Gradio_Events.postprocess_submit(state_value)
+
+    @staticmethod
+    def regenerate_message(state_value, e: gr.EventData):
+        conversation_key = e._data["component"]["conversationKey"]
+        history = state_value["conversations_history"][
+            state_value["conversation_id"]]
+        index = -1
+        for i, conversation in enumerate(history):
+            if conversation["key"] == conversation_key:
+                index = i
+                break
+        if index == -1:
+            yield gr.skip()
+        history = history[:index]
+        state_value["conversations_history"][
+            state_value["conversation_id"]] = history
+
+        yield {
+            chatbot:gr.update(items=history),
+            state: gr.update(value=state_value)
+        }
+
+        # preprocess submit
+        yield Gradio_Events.preprocess_submit(clear_input=False)(state_value)
+        try:
+          for chunk in Gradio_Events._submit(state_value):
+                yield chunk
+        except Exception as e:
+            raise e
+        finally:
+          # postprocess submit
+          yield Gradio_Events.postprocess_submit(state_value)
+
+
+    @staticmethod
+    def preprocess_submit(clear_input=True):
+
+        def preprocess_submit_handler(state_value):
+            history = state_value["conversations_history"][
+                state_value["conversation_id"]]
+            for conversation in history:
+                if "meta" in conversation:
+                    conversation["meta"]["disabled"] = True
+            return {
+                sender: gr.update(value=None, loading=True) if clear_input else gr.update(loading=True),
+                conversations:
+                gr.update(active_key=state_value["conversation_id"],
+                          items=list(
+                              map(
+                                  lambda item: {
+                                      **item,
+                                      "disabled":
+                                      True if item["key"] != state_value[
+                                          "conversation_id"] else False,
+                                  }, state_value["conversations"]))),
+                add_conversation_btn:
+                gr.update(disabled=True),
+                clear_btn:
+                gr.update(disabled=True),
+                conversation_delete_menu_item:
+                gr.update(disabled=True),
+                chatbot:
+                gr.update(items=history),
+                state:
+                gr.update(value=state_value),
+            }
+
+        return preprocess_submit_handler
+
+    @staticmethod
+    def postprocess_submit(state_value):
+        history = state_value["conversations_history"][
+            state_value["conversation_id"]]
+        for conversation in history:
+            if "meta" in conversation:
+                conversation["meta"]["disabled"] = False
+        return {
+            sender: gr.update(loading=False),
+            conversation_delete_menu_item: gr.update(disabled=False),
+            clear_btn: gr.update(disabled=False),
+            conversations: gr.update(items=state_value["conversations"]),
+            add_conversation_btn: gr.update(disabled=False),
+            chatbot: gr.update(items=history),
+            state: gr.update(value=state_value),
+        }
+
+    @staticmethod
+    def cancel(state_value):
+        history = state_value["conversations_history"][
+            state_value["conversation_id"]]
+        history[-1]["loading"] = False
+        history[-1]["meta"]["end"] = True
+        history[-1]["meta"]["canceled"] = True
+        return Gradio_Events.postprocess_submit(state_value)
+
+    @staticmethod
+    def delete_message(state_value, e: gr.EventData):
+        conversation_key = e._data["component"]["conversationKey"]
+        history = state_value["conversations_history"][
+            state_value["conversation_id"]]
+        history = [item for item in history if item["key"] != conversation_key]
+        state_value["conversations_history"][
+            state_value["conversation_id"]] = history
+
+        return gr.update(items=history if len(history) >
+                         0 else DEFAULT_CONVERSATIONS_HISTORY), gr.update(
+                             value=state_value)
+
+
+
+    @staticmethod
+    def edit_message(state_value, e: gr.EventData):
+        conversation_key = e._data["component"]["conversationKey"]
+        history = state_value["conversations_history"][
+            state_value["conversation_id"]]
+        index = -1
+        for i, conversation in enumerate(history):
+            if conversation["key"] == conversation_key:
+                index = i
+                break
+        if index == -1:
+            return gr.skip()
+        state_value["editing_message_index"] = index
+        text = ''
+        if isinstance(history[index]["content"], str):
+            text = history[index]["content"]
+        else:
+            text = history[index]["content"]["text"]
+        return gr.update(value=text), gr.update(value=state_value)
+
+    @staticmethod
+    def confirm_edit_message(edit_textarea_value, state_value):
+        history = state_value["conversations_history"][
+            state_value["conversation_id"]]
+        message = history[state_value["editing_message_index"]]
+        if isinstance(message["content"], str):
+            message["content"] = edit_textarea_value
+        else:
+            message["content"]["text"] = edit_textarea_value
+        return gr.update(items=history), gr.update(value=state_value)
+
+    @staticmethod
+    def select_suggestion(sender_value, e: gr.EventData):
+        return gr.update(value=sender_value[:-1] + e._data["payload"][0])
+
+    @staticmethod
+    def apply_prompt(e: gr.EventData):
+        return gr.update(value=e._data["payload"][0]["data"]["description"])
+
+    @staticmethod
+    def new_chat(state_value):
+        if not state_value["conversation_id"]:
+            return gr.skip()
+        state_value["conversation_id"] = ""
+        return gr.update(active_key=state_value["conversation_id"]), gr.update(
+            items=DEFAULT_CONVERSATIONS_HISTORY), gr.update(value=state_value)
+
+    @staticmethod
+    def select_conversation(state_value, e: gr.EventData):
+        active_key = e._data["payload"][0]
+        if state_value["conversation_id"] == active_key or (
+                active_key not in state_value["conversations_history"]):
+            return gr.skip()
+        state_value["conversation_id"] = active_key
+        return gr.update(active_key=active_key), gr.update(
+            items=state_value["conversations_history"][active_key]), gr.update(
+                value=state_value)
+
+    @staticmethod
+    def click_conversation_menu(state_value, e: gr.EventData):
+        conversation_id = e._data["payload"][0]["key"]
+        operation = e._data["payload"][1]["key"]
+        if operation == "delete":
+            del state_value["conversations_history"][conversation_id]
+
+            state_value["conversations"] = [
+                item for item in state_value["conversations"]
+                if item["key"] != conversation_id
+            ]
+
+            if state_value["conversation_id"] == conversation_id:
+                state_value["conversation_id"] = ""
+                return gr.update(
+                    items=state_value["conversations"],
+                    active_key=state_value["conversation_id"]), gr.update(
+                        items=DEFAULT_CONVERSATIONS_HISTORY), gr.update(
+                            value=state_value)
+            else:
+                return gr.update(
+                    items=state_value["conversations"]), gr.skip(), gr.update(
+                        value=state_value)
+        return gr.skip()
+
+    @staticmethod
+    def clear_conversation_history(state_value):
+        if not state_value["conversation_id"]:
+            return gr.skip()
+        state_value["conversations_history"][
+            state_value["conversation_id"]] = []
+        return gr.update(items=DEFAULT_CONVERSATIONS_HISTORY), gr.update(
+            value=state_value)
+
+    @staticmethod
+    def close_modal():
+        return gr.update(open=False)
+
+    @staticmethod
+    def open_modal():
+        return gr.update(open=True)
+
+    @staticmethod
+    def update_browser_state(state_value):
+
+        return gr.update(value=dict(
+            conversations=state_value["conversations"],
+            conversations_history=state_value["conversations_history"]))
+
+    @staticmethod
+    def apply_browser_state(browser_state_value, state_value):
+        state_value["conversations"] = browser_state_value["conversations"]
+        state_value["conversations_history"] = browser_state_value[
+            "conversations_history"]
+        return gr.update(
+            items=browser_state_value["conversations"]), gr.update(
+                value=state_value)
+
+
+css = """
+.gradio-container {
+  padding: 0 !important;
+}
+.gradio-container > main.fillable {
+  padding: 0 !important;
+}
+#chatbot {
+  height: calc(100vh - 21px - 16px);
+}
+#chatbot .chatbot-conversations {
+  height: 100%;
+  background-color: var(--ms-gr-ant-color-bg-layout);
+}
+#chatbot .chatbot-conversations .chatbot-conversations-list {
+  padding-left: 0;
+  padding-right: 0;
+}
+#chatbot .chatbot-chat {
+  padding: 32px;
+  height: 100%;
+}
+@media (max-width: 768px) {
+  #chatbot .chatbot-chat {
+      padding: 0;
+  }
+}
+#chatbot .chatbot-chat .chatbot-chat-messages {
+  flex: 1;
+}
+#chatbot .chatbot-chat .chatbot-chat-messages .chatbot-chat-message .chatbot-chat-message-footer {
+  visibility: hidden;
+  opacity: 0;
+  transition: opacity 0.2s;
+}
+#chatbot .chatbot-chat .chatbot-chat-messages .chatbot-chat-message:last-child .chatbot-chat-message-footer {
+  visibility: visible;
+  opacity: 1;
+}
+#chatbot .chatbot-chat .chatbot-chat-messages .chatbot-chat-message:hover .chatbot-chat-message-footer {
+  visibility: visible;
+  opacity: 1;
+}
+"""
+
+
+def logo():
+    with antd.Typography.Title(level=1,
+                               elem_style=dict(fontSize=24,
+                                               padding=8,
+                                               margin=0)):
+        with antd.Flex(align="center", gap="small", justify="center"):
+            antd.Image(logo_img,
+                       preview=False,
+                       alt="logo",
+                       width=24,
+                       height=24)
+            ms.Span("dots.llm1.inst")
+
+
+with gr.Blocks(css=css, fill_width=True) as demo:
+    state = gr.State({
+        "conversations_history": {},
+        "conversations": [],
+        "conversation_id": "",
+        "editing_message_index": -1,
+    })
+
+    with ms.Application(), antdx.XProvider(
+            theme=DEFAULT_THEME, locale=DEFAULT_LOCALE), ms.AutoLoading():
+        with antd.Row(gutter=[20, 20], wrap=False, elem_id="chatbot"):
+            # Left Column
+            with antd.Col(md=dict(flex="0 0 260px", span=24, order=0),
+                          span=0,
+                          order=1,
+                          elem_classes="chatbot-conversations", 
+                        elem_style=dict(
+                        maxWidth="260px",
+                        minWidth="260px",
+                        overflow="hidden")):
+                with antd.Flex(vertical=True,
+                               gap="small",
+                               elem_style=dict(height="100%", width="100%", minWidth="0")):
+                    # Logo
+                    logo()
+
+                    # New Conversation Button
+                    with antd.Button(value=None,
+                                     color="primary",
+                                     variant="filled",
+                                     block=True, elem_style=dict(maxWidth="100%")) as add_conversation_btn:
+                        ms.Text(get_text("New Conversation", "新建对话"))
+                        with ms.Slot("icon"):
+                            antd.Icon("PlusOutlined")
+
+                    # Conversations List
+                    with antdx.Conversations(
+                            elem_classes="chatbot-conversations-list",
+                            elem_style=dict(
+                                width="100%",
+                                minWidth="0",
+                                overflow="hidden",
+                                flex="1"
+                            )
+                    ) as conversations:
+                        with ms.Slot('menu.items'):
+                            with antd.Menu.Item(
+                                    label="Delete", key="delete", danger=True
+                            ) as conversation_delete_menu_item:
+                                with ms.Slot("icon"):
+                                    antd.Icon("DeleteOutlined")
+            # Right Column
+            with antd.Col(flex=1, elem_style=dict(height="100%")):
+                with antd.Flex(vertical=True,
+                               gap="middle",
+                               elem_classes="chatbot-chat"):
+                    # Chatbot
+                    with antdx.Bubble.List(
+                            items=DEFAULT_CONVERSATIONS_HISTORY,
+                            elem_classes="chatbot-chat-messages") as chatbot:
+                        # Define Chatbot Roles
+                        with ms.Slot("roles"):
+                            # Placeholder Role
+                            with antdx.Bubble.List.Role(
+                                    role="placeholder",
+                                    styles=dict(content=dict(width="100%")),
+                                    variant="borderless"):
+                                with ms.Slot("messageRender"):
+                                    with antd.Space(
+                                            direction="vertical",
+                                            size=16,
+                                            elem_style=dict(width="100%")):
+                                        with antdx.Welcome(
+                                                styles=dict(icon=dict(
+                                                    flexShrink=0)),
+                                                variant="borderless",
+                                                title=get_text(
+                                                    "Hello, I'm dots.",
+                                                    "你好，我是 dots."),
+                                                description=get_text(
+                                                    "You can type text to get started.",
+                                                    "你可以输入文本开始对话。"),
+                                        ):
+                                            with ms.Slot("icon"):
+                                                antd.Image(logo_img,
+                                                           preview=False)
+                                        with antdx.Prompts(title=get_text(
+                                                "How can I help you today?",
+                                                "有什么我能帮助你的吗?"),
+                                                           styles={
+                                                               "list": {
+                                                                   "width":
+                                                                   '100%',
+                                                               },
+                                                               "item": {
+                                                                   "flex": 1,
+                                                               },
+                                                           }) as prompts:
+                                            for item in DEFAULT_PROMPTS:
+                                                with antdx.Prompts.Item(
+                                                        label=item["category"]
+                                                ):
+                                                    for prompt in item[
+                                                            "prompts"]:
+                                                        antdx.Prompts.Item(
+                                                            description=prompt,
+                                                        )
+
+                            # User Role
+                            with antdx.Bubble.List.Role(
+                                    role="user",
+                                    placement="end",
+                                    elem_classes="chatbot-chat-message",
+                                    class_names=dict(
+                                        footer="chatbot-chat-message-footer"),
+                                    styles=dict(content=dict(
+                                        maxWidth="100%",
+                                        overflow='auto',
+                                    ))):
+                                with ms.Slot(
+                                        "messageRender",
+                                        params_mapping="(content) => content"):
+
+                                    ms.Markdown()
+                                with ms.Slot("footer",
+                                             params_mapping="""(bubble) => {
+                                                    return {
+                                                      copy_btn: {
+                                                        copyable: { text: typeof bubble.content === 'string' ? bubble.content : bubble.content?.text, tooltips: false },
+                                                      },
+                                                      edit_btn: { conversationKey: bubble.key, disabled: bubble.meta.disabled },
+                                                      delete_btn: { conversationKey: bubble.key, disabled: bubble.meta.disabled },
+                                                    };
+                                             }"""):
+                                    with antd.Typography.Text(
+                                            copyable=dict(tooltips=False),
+                                            as_item="copy_btn"):
+                                        with ms.Slot("copyable.icon"):
+                                            with antd.Button(value=None,
+                                                             size="small",
+                                                             color="default",
+                                                             variant="text"):
+                                                with ms.Slot("icon"):
+                                                    antd.Icon("CopyOutlined")
+                                            with antd.Button(value=None,
+                                                             size="small",
+                                                             color="default",
+                                                             variant="text"):
+                                                with ms.Slot("icon"):
+                                                    antd.Icon("CheckOutlined")
+                                    with antd.Button(value=None,
+                                                     size="small",
+                                                     color="default",
+                                                     variant="text",
+                                                     as_item="edit_btn"
+                                                     ) as user_edit_btn:
+                                        with ms.Slot("icon"):
+                                            antd.Icon("EditOutlined")
+                                    with antd.Popconfirm(
+                                            title="Delete the message",
+                                            description=
+                                            "Are you sure to delete this message?",
+                                            ok_button_props=dict(danger=True),
+                                            as_item="delete_btn"
+                                    ) as user_delete_popconfirm:
+                                        with antd.Button(value=None,
+                                                         size="small",
+                                                         color="default",
+                                                         variant="text",
+                                                         as_item="delete_btn"):
+                                            with ms.Slot("icon"):
+                                                antd.Icon("DeleteOutlined")
+
+                            # Chatbot Role
+                            with antdx.Bubble.List.Role(
+                                    role="assistant",
+                                    placement="start",
+                                    elem_classes="chatbot-chat-message",
+                                    class_names=dict(
+                                        footer="chatbot-chat-message-footer"),
+                                    styles=dict(content=dict(
+                                        maxWidth="100%", overflow='auto'))):
+                                with ms.Slot("avatar"):
+                                    antd.Avatar(
+                                        os.path.join(os.path.dirname(__file__),
+                                                    "rednote_hilab.png"))
+                                with ms.Slot(
+                                        "messageRender",
+                                        params_mapping="""(content, bubble) => {
+                                            const has_error = bubble?.meta?.error
+                                            return {
+                                                answer: {
+                                                    value: content
+                                                },
+                                                canceled: bubble.meta?.canceled ? undefined : { style: { display: 'none' } }
+                                            }
+                                        }"""):
+                                    # 直接显示答案内容，不再有thinking相关的组件
+                                    ms.Markdown(
+                                        as_item="answer",
+                                        elem_classes="answer-content")
+
+                                    antd.Divider(as_item="canceled")
+                                    antd.Typography.Text(get_text(
+                                        "Chat completion paused.", "聊天已暂停。"),
+                                                        as_item="canceled",
+                                                        type="warning")
+
+                                with ms.Slot("footer",
+                                            params_mapping="""(bubble) => {
+                                                if (bubble?.meta?.end) {
+                                                    return {
+                                                    copy_btn: {
+                                                        copyable: { text: bubble.content, tooltips: false },
+                                                    },
+                                                    regenerate_btn: { conversationKey: bubble.key, disabled: bubble.meta.disabled },
+                                                    delete_btn: { conversationKey: bubble.key, disabled: bubble.meta.disabled },
+                                                    edit_btn: { conversationKey: bubble.key, disabled: bubble.meta.disabled },
+                                                    };
+                                                }
+                                                return { actions_container: { style: { display: 'none' } } };
+                                }"""):
+                                    with ms.Div(as_item="actions_container"):
+                                        with antd.Typography.Text(
+                                                copyable=dict(tooltips=False),
+                                                as_item="copy_btn"):
+                                            with ms.Slot("copyable.icon"):
+                                                with antd.Button(
+                                                        value=None,
+                                                        size="small",
+                                                        color="default",
+                                                        variant="text"):
+                                                    with ms.Slot("icon"):
+                                                        antd.Icon(
+                                                            "CopyOutlined")
+                                                with antd.Button(
+                                                        value=None,
+                                                        size="small",
+                                                        color="default",
+                                                        variant="text"):
+                                                    with ms.Slot("icon"):
+                                                        antd.Icon(
+                                                            "CheckOutlined")
+
+                                        with antd.Popconfirm(
+                                                title=get_text(
+                                                    "Regenerate the message",
+                                                    "重新生成消息"),
+                                                description=get_text(
+                                                    "Regenerate the message will also delete all subsequent messages.",
+                                                    "重新生成消息将会删除所有的后续消息。"),
+                                                ok_button_props=dict(
+                                                    danger=True),
+                                                as_item="regenerate_btn"
+                                        ) as chatbot_regenerate_popconfirm:
+                                            with antd.Button(
+                                                    value=None,
+                                                    size="small",
+                                                    color="default",
+                                                    variant="text",
+                                                    as_item="regenerate_btn",
+                                            ):
+                                                with ms.Slot("icon"):
+                                                    antd.Icon("SyncOutlined")
+                                        with antd.Button(value=None,
+                                                        size="small",
+                                                        color="default",
+                                                        variant="text",
+                                                        as_item="edit_btn"
+                                                        ) as chatbot_edit_btn:
+                                            with ms.Slot("icon"):
+                                                antd.Icon("EditOutlined")
+                                        with antd.Popconfirm(
+                                                title=get_text("Delete the message", "删除消息"),
+                                                description=get_text(
+                                                    "Are you sure to delete this message?",
+                                                    "确定要删除这条消息吗?"),
+                                                ok_button_props=dict(
+                                                    danger=True),
+                                                as_item="delete_btn"
+                                        ) as chatbot_delete_popconfirm:
+                                            with antd.Button(
+                                                    value=None,
+                                                    size="small",
+                                                    color="default",
+                                                    variant="text",
+                                                    as_item="delete_btn"):
+                                                with ms.Slot("icon"):
+                                                    antd.Icon("DeleteOutlined")
+
+
+                    # Sender
+                    with antdx.Suggestion(
+                            items=DEFAULT_SUGGESTIONS,
+                            # onKeyDown Handler in Javascript
+                            should_trigger="""(e, { onTrigger, onKeyDown }) => {
+                      switch(e.key) {
+                        case '/':
+                          onTrigger()
+                          break
+                        case 'ArrowRight':
+                        case 'ArrowLeft':
+                        case 'ArrowUp':
+                        case 'ArrowDown':
+                          break;
+                        default:
+                          onTrigger(false)
+                      }
+                      onKeyDown(e)
+                    }""") as suggestion:
+                        with ms.Slot("children"):
+                            with antdx.Sender(placeholder=get_text(
+                                    "Enter / to get suggestions",
+                                    "输入 / 获取建议"), ) as sender:
+                                with ms.Slot("prefix"):
+                                    # Clear Button
+                                    with antd.Tooltip(title=get_text(
+                                            "Clear Conversation History",
+                                            "清空对话历史"), ):
+                                        with antd.Button(
+                                                value=None,
+                                                type="text") as clear_btn:
+                                            with ms.Slot("icon"):
+                                                antd.Icon("ClearOutlined")
+
+        # Modals
+        with antd.Modal(title=get_text("Edit Message", "编辑消息"),
+                        open=False,
+                        centered=True,
+                        width="60%") as edit_modal:
+            edit_textarea = antd.Input.Textarea(auto_size=dict(minRows=2,
+                                                               maxRows=6),
+                                                elem_style=dict(width="100%"))
+    # Events Handler
+    if save_history:
+        browser_state = gr.BrowserState(
+            {
+                "conversations_history": {},
+                "conversations": [],
+            },
+            storage_key="dots_chatbot_storage")
+        state.change(fn=Gradio_Events.update_browser_state,
+                     inputs=[state],
+                     outputs=[browser_state])
+
+        demo.load(fn=Gradio_Events.apply_browser_state,
+                  inputs=[browser_state, state],
+                  outputs=[conversations, state])
+
+    add_conversation_btn.click(fn=Gradio_Events.new_chat,
+                               inputs=[state],
+                               outputs=[conversations, chatbot, state])
+    conversations.active_change(fn=Gradio_Events.select_conversation,
+                                inputs=[state],
+                                outputs=[conversations, chatbot, state])
+    conversations.menu_click(fn=Gradio_Events.click_conversation_menu,
+                             inputs=[state],
+                             outputs=[conversations, chatbot, state])
+    prompts.item_click(fn=Gradio_Events.apply_prompt, outputs=[sender])
+
+    clear_btn.click(fn=Gradio_Events.clear_conversation_history,
+                    inputs=[state],
+                    outputs=[chatbot, state])
+
+    suggestion.select(fn=Gradio_Events.select_suggestion,
+                      inputs=[sender],
+                      outputs=[sender])
+
+    gr.on(triggers=[user_edit_btn.click, chatbot_edit_btn.click],
+          fn=Gradio_Events.edit_message,
+          inputs=[state],
+          outputs=[edit_textarea, state]).then(fn=Gradio_Events.open_modal,
+                                               outputs=[edit_modal])
+    edit_modal.ok(fn=Gradio_Events.confirm_edit_message,
+                  inputs=[edit_textarea, state],
+                  outputs=[chatbot, state]).then(fn=Gradio_Events.close_modal,
+                                                 outputs=[edit_modal])
+    edit_modal.cancel(fn=Gradio_Events.close_modal, outputs=[edit_modal])
+    gr.on(triggers=[
+        chatbot_delete_popconfirm.confirm, user_delete_popconfirm.confirm
+    ],
+          fn=Gradio_Events.delete_message,
+          inputs=[state],
+          outputs=[chatbot, state])
+
+    regenerating_event = chatbot_regenerate_popconfirm.confirm(
+        fn=Gradio_Events.regenerate_message,
+        inputs=[state],
+        outputs=[sender, clear_btn, conversation_delete_menu_item, add_conversation_btn, conversations, chatbot, state])
+
+    submit_event = sender.submit(fn=Gradio_Events.submit,
+                                 inputs=[sender, state],
+                                 outputs=[sender, clear_btn, conversation_delete_menu_item,
+                             add_conversation_btn, conversations,chatbot, state])
+    sender.cancel(fn=None, cancels=[submit_event, regenerating_event])
+    sender.cancel(fn=Gradio_Events.cancel,
+                  inputs=[state],
+                  outputs=[
+                      sender, conversation_delete_menu_item, clear_btn,
+                      conversations, add_conversation_btn, chatbot, state
+                  ])
+
+if __name__ == "__main__":
+    demo.queue(default_concurrency_limit=200).launch(ssr_mode=False, max_threads=200)

gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

requirements.txt

@@ -0,0 +1,4 @@
+gradio
+modelscope_studio
+openai
+langfuse