log user name during chat

2025-12-06 14:36:48 +00:00 · 2024-11-10 16:50:24 +00:00
--- a/.github/workflows/conda-pack-windows.yml
+++ b/.github/workflows/conda-pack-windows.yml
@@ -1,56 +0,0 @@
-name: Create Conda Environment Package
-
-on:
-  workflow_dispatch:
-
-jobs:
-  build:
-    runs-on: windows-latest
-    
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-      
-    - name: Setup Miniconda
-      uses: conda-incubator/setup-miniconda@v3
-      with:
-        auto-activate-base: true
-        activate-environment: ""
-        
-    - name: Create new Conda environment
-      shell: bash -l {0}
-      run: |
-        conda create -n gpt python=3.11 -y
-        conda activate gpt
-        
-    - name: Install requirements
-      shell: bash -l {0}
-      run: |
-        conda activate gpt
-        pip install -r requirements.txt
-        
-    - name: Install conda-pack
-      shell: bash -l {0}
-      run: |
-        conda activate gpt
-        conda install conda-pack -y
-        
-    - name: Pack conda environment
-      shell: bash -l {0}
-      run: |
-        conda activate gpt
-        conda pack -n gpt -o gpt.tar.gz
-      
-    - name: Create workspace zip
-      shell: pwsh
-      run: |
-        mkdir workspace
-        Get-ChildItem -Exclude "workspace" | Copy-Item -Destination workspace -Recurse
-        Remove-Item -Path workspace/.git* -Recurse -Force -ErrorAction SilentlyContinue
-        Copy-Item gpt.tar.gz workspace/ -Force
-    
-    - name: Upload packed files
-      uses: actions/upload-artifact@v4
-      with:
-        name: gpt-academic-package
-        path: workspace
--- a/README.md
+++ b/README.md
@@ -1,7 +1,4 @@
 > [!IMPORTANT]
-> `frontier开发分支`最新动态(2024.12.9): 更新对话时间线功能，优化xelatex论文翻译  
-> `wiki文档`最新动态(2024.12.5): 更新ollama接入指南  
->
 > 2024.10.10: 突发停电，紧急恢复了提供[whl包](https://drive.google.com/file/d/19U_hsLoMrjOlQSzYS3pzWX9fTzyusArP/view?usp=sharing)的文件服务器  
 > 2024.10.8: 版本3.90加入对llama-index的初步支持，版本3.80加入插件二级菜单功能（详见wiki）  
 > 2024.5.1: 加入Doc2x翻译PDF论文的功能，[查看详情](https://github.com/binary-husky/gpt_academic/wiki/Doc2x)  
@@ -173,32 +170,26 @@ flowchart TD
    ```


-<details><summary>如果需要支持清华ChatGLM系列/复旦MOSS/RWKV作为后端，请点击展开此处</summary>
+<details><summary>如果需要支持清华ChatGLM2/复旦MOSS/RWKV作为后端，请点击展开此处</summary>
 <p>

-【可选步骤】如果需要支持清华ChatGLM系列/复旦MOSS作为后端，需要额外安装更多依赖（前提条件：熟悉Python + 用过Pytorch + 电脑配置够强）：
+【可选步骤】如果需要支持清华ChatGLM3/复旦MOSS作为后端，需要额外安装更多依赖（前提条件：熟悉Python + 用过Pytorch + 电脑配置够强）：

 ```sh
 # 【可选步骤I】支持清华ChatGLM3。清华ChatGLM备注：如果遇到"Call ChatGLM fail 不能正常加载ChatGLM的参数" 错误，参考如下： 1：以上默认安装的为torch+cpu版，使用cuda需要卸载torch重新安装torch+cuda； 2：如因本机配置不够无法加载模型，可以修改request_llm/bridge_chatglm.py中的模型精度, 将 AutoTokenizer.from_pretrained("THUDM/chatglm-6b", trust_remote_code=True) 都修改为 AutoTokenizer.from_pretrained("THUDM/chatglm-6b-int4", trust_remote_code=True)
 python -m pip install -r request_llms/requirements_chatglm.txt

-# 【可选步骤II】支持清华ChatGLM4 注意：此模型至少需要24G显存
-python -m pip install -r request_llms/requirements_chatglm4.txt
-# 可使用modelscope下载ChatGLM4模型
-# pip install modelscope
-# modelscope download --model ZhipuAI/glm-4-9b-chat --local_dir ./THUDM/glm-4-9b-chat
-
-# 【可选步骤III】支持复旦MOSS
+# 【可选步骤II】支持复旦MOSS
 python -m pip install -r request_llms/requirements_moss.txt
 git clone --depth=1 https://github.com/OpenLMLab/MOSS.git request_llms/moss  # 注意执行此行代码时，必须处于项目根路径

-# 【可选步骤IV】支持RWKV Runner
+# 【可选步骤III】支持RWKV Runner
 参考wiki：https://github.com/binary-husky/gpt_academic/wiki/%E9%80%82%E9%85%8DRWKV-Runner

-# 【可选步骤V】确保config.py配置文件的AVAIL_LLM_MODELS包含了期望的模型，目前支持的全部模型如下(jittorllms系列目前仅支持docker方案)：
+# 【可选步骤IV】确保config.py配置文件的AVAIL_LLM_MODELS包含了期望的模型，目前支持的全部模型如下(jittorllms系列目前仅支持docker方案)：
 AVAIL_LLM_MODELS = ["gpt-3.5-turbo", "api2d-gpt-3.5-turbo", "gpt-4", "api2d-gpt-4", "chatglm", "moss"] # + ["jittorllms_rwkv", "jittorllms_pangualpha", "jittorllms_llama"]

-# 【可选步骤VI】支持本地模型INT8,INT4量化（这里所指的模型本身不是量化版本，目前deepseek-coder支持，后面测试后会加入更多模型量化选择）
+# 【可选步骤V】支持本地模型INT8,INT4量化（这里所指的模型本身不是量化版本，目前deepseek-coder支持，后面测试后会加入更多模型量化选择）
 pip install bitsandbyte
 # windows用户安装bitsandbytes需要使用下面bitsandbytes-windows-webui
 python -m pip install bitsandbytes --prefer-binary --extra-index-url=https://jllllll.github.io/bitsandbytes-windows-webui
--- a/config.py
+++ b/config.py
@@ -36,7 +36,7 @@ AVAIL_LLM_MODELS = ["gpt-4-1106-preview", "gpt-4-turbo-preview", "gpt-4-vision-p
                    "gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-4-turbo-2024-04-09",
                    "gpt-3.5-turbo-1106", "gpt-3.5-turbo-16k", "gpt-3.5-turbo", "azure-gpt-3.5",
                    "gpt-4", "gpt-4-32k", "azure-gpt-4", "glm-4", "glm-4v", "glm-3-turbo",
-                    "gemini-1.5-pro", "chatglm3", "chatglm4"
+                    "gemini-1.5-pro", "chatglm3"
                    ]

 EMBEDDING_MODEL = "text-embedding-3-small"
@@ -55,7 +55,6 @@ EMBEDDING_MODEL = "text-embedding-3-small"
 #   "deepseek-chat" ,"deepseek-coder",
 #   "gemini-1.5-flash",
 #   "yi-34b-chat-0205","yi-34b-chat-200k","yi-large","yi-medium","yi-spark","yi-large-turbo","yi-large-preview",
-#   "grok-beta",
 # ]
 # --- --- --- ---
 # 此外，您还可以在接入one-api/vllm/ollama/Openroute时，
@@ -143,9 +142,6 @@ BAIDU_CLOUD_SECRET_KEY = ''
 BAIDU_CLOUD_QIANFAN_MODEL = 'ERNIE-Bot'    # 可选 "ERNIE-Bot-4"(文心大模型4.0), "ERNIE-Bot"(文心一言), "ERNIE-Bot-turbo", "BLOOMZ-7B", "Llama-2-70B-Chat", "Llama-2-13B-Chat", "Llama-2-7B-Chat", "ERNIE-Speed-128K", "ERNIE-Speed-8K", "ERNIE-Lite-8K"


-# 如果使用ChatGLM3或ChatGLM4本地模型，请把 LLM_MODEL="chatglm3" 或LLM_MODEL="chatglm4"，并在此处指定模型路径
-CHATGLM_LOCAL_MODEL_PATH = "THUDM/glm-4-9b-chat" # 例如"/home/hmp/ChatGLM3-6B/"
-
 # 如果使用ChatGLM2微调模型，请把 LLM_MODEL="chatglmft"，并在此处指定模型路径
 CHATGLM_PTUNING_CHECKPOINT = "" # 例如"/home/hmp/ChatGLM2-6B/ptuning/output/6b-pt-128-1e-2/checkpoint-100"

@@ -238,6 +234,7 @@ MOONSHOT_API_KEY = ""
 # 零一万物(Yi Model) API KEY
 YIMODEL_API_KEY = ""

+
 # 深度求索(DeepSeek) API KEY，默认请求地址为"https://api.deepseek.com/v1/chat/completions"
 DEEPSEEK_API_KEY = ""

@@ -245,8 +242,6 @@ DEEPSEEK_API_KEY = ""
 # 紫东太初大模型 https://ai-maas.wair.ac.cn
 TAICHU_API_KEY = ""

-# Grok API KEY
-GROK_API_KEY = ""

 # Mathpix 拥有执行PDF的OCR功能，但是需要注册账号
 MATHPIX_APPID = ""
@@ -278,8 +273,8 @@ GROBID_URLS = [
 ]


-# Searxng互联网检索服务（这是一个huggingface空间，请前往huggingface复制该空间，然后把自己新的空间地址填在这里）
-SEARXNG_URLS = [ f"https://kaletianlre-beardvs{i}dd.hf.space/" for i in range(1,5) ]
+# Searxng互联网检索服务
+SEARXNG_URL = "https://cloud-1.agent-matrix.com/"


 # 是否允许通过自然语言描述修改本页的配置，该功能具有一定的危险性，默认关闭
@@ -315,10 +310,6 @@ PLUGIN_HOT_RELOAD = False
 NUM_CUSTOM_BASIC_BTN = 4


-# 媒体智能体的服务地址（这是一个huggingface空间，请前往huggingface复制该空间，然后把自己新的空间地址填在这里）
-DAAS_SERVER_URLS = [ f"https://niuziniu-biligpt{i}.hf.space/stream" for i in range(1,5) ]
-
-

 """
 --------------- 配置关联关系说明 ---------------
@@ -378,7 +369,6 @@ DAAS_SERVER_URLS = [ f"https://niuziniu-biligpt{i}.hf.space/stream" for i in ran

 本地大模型示意图
 │
-├── "chatglm4"
 ├── "chatglm3"
 ├── "chatglm"
 ├── "chatglm_onnx"
@@ -409,7 +399,7 @@ DAAS_SERVER_URLS = [ f"https://niuziniu-biligpt{i}.hf.space/stream" for i in ran
 插件在线服务配置依赖关系示意图
 │
 ├── 互联网检索
-│   └── SEARXNG_URLS
+│   └── SEARXNG_URL
 │
 ├── 语音功能
 │   ├── ENABLE_AUDIO
--- a/crazy_functional.py
+++ b/crazy_functional.py
@@ -2,6 +2,7 @@ from toolbox import HotReload  # HotReload 的意思是热更新，修改函数
 from toolbox import trimmed_format_exc
 from loguru import logger

+
 def get_crazy_functions():
    from crazy_functions.读文章写摘要 import 读文章写摘要
    from crazy_functions.生成函数注释 import 批量生成函数注释
@@ -16,7 +17,7 @@ def get_crazy_functions():
    from crazy_functions.SourceCode_Analyse import 解析一个前端项目
    from crazy_functions.高级功能函数模板 import 高阶功能模板函数
    from crazy_functions.高级功能函数模板 import Demo_Wrap
-    from crazy_functions.Latex_Project_Polish import Latex英文润色
+    from crazy_functions.Latex全文润色 import Latex英文润色
    from crazy_functions.询问多个大语言模型 import 同时问询
    from crazy_functions.SourceCode_Analyse import 解析一个Lua项目
    from crazy_functions.SourceCode_Analyse import 解析一个CSharp项目
@@ -32,8 +33,8 @@ def get_crazy_functions():
    from crazy_functions.PDF_Translate import 批量翻译PDF文档
    from crazy_functions.谷歌检索小助手 import 谷歌检索小助手
    from crazy_functions.理解PDF文档内容 import 理解PDF文档内容标准文件输入
-    from crazy_functions.Latex_Project_Polish import Latex中文润色
-    from crazy_functions.Latex_Project_Polish import Latex英文纠错
+    from crazy_functions.Latex全文润色 import Latex中文润色
+    from crazy_functions.Latex全文润色 import Latex英文纠错
    from crazy_functions.Markdown_Translate import Markdown中译英
    from crazy_functions.虚空终端 import 虚空终端
    from crazy_functions.生成多种Mermaid图表 import Mermaid_Gen
@@ -49,16 +50,8 @@ def get_crazy_functions():
    from crazy_functions.Image_Generate_Wrap import ImageGen_Wrap
    from crazy_functions.SourceCode_Comment import 注释Python项目
    from crazy_functions.SourceCode_Comment_Wrap import SourceCodeComment_Wrap
-    from crazy_functions.VideoResource_GPT import 多媒体任务

    function_plugins = {
-        "多媒体智能体": {
-            "Group": "智能体",
-            "Color": "stop",
-            "AsButton": False,
-            "Info": "【仅测试】多媒体任务",
-            "Function": HotReload(多媒体任务),
-        },
        "虚空终端": {
            "Group": "对话|编程|学术|智能体",
            "Color": "stop",
@@ -727,6 +720,12 @@ def get_crazy_functions():
        logger.error("Load function plugin failed")


+    
+
+
+
+
+
    # try:
    #     from crazy_functions.高级功能函数模板 import 测试图表渲染
    #     function_plugins.update({
@@ -741,6 +740,19 @@ def get_crazy_functions():
    #     logger.error(trimmed_format_exc())
    #     print('Load function plugin failed')

+    # try:
+    #     from crazy_functions.chatglm微调工具 import 微调数据集生成
+    #     function_plugins.update({
+    #         "黑盒模型学习: 微调数据集生成 (先上传数据集)": {
+    #             "Color": "stop",
+    #             "AsButton": False,
+    #             "AdvancedArgs": True,
+    #             "ArgsReminder": "针对数据集输入（如 绿帽子*深蓝色衬衫*黑色运动裤）给出指令，例如您可以将以下命令复制到下方: --llm_to_learn=azure-gpt-3.5 --prompt_prefix='根据下面的服装类型提示，想象一个穿着者，对这个人外貌、身处的环境、内心世界、过去经历进行描写。要求：100字以内，用第二人称。' --system_prompt=''",
+    #             "Function": HotReload(微调数据集生成)
+    #         }
+    #     })
+    # except:
+    #     print('Load function plugin failed')

    """
    设置默认值:
@@ -760,23 +772,3 @@ def get_crazy_functions():
            function_plugins[name]["Color"] = "secondary"

    return function_plugins
-
-
-
-
-def get_multiplex_button_functions():
-    """多路复用主提交按钮的功能映射
-    """
-    return {
-        "常规对话":
-            "",
-
-        "多模型对话": 
-            "询问多个GPT模型", # 映射到上面的 `询问多个GPT模型` 插件
-
-        "智能召回 RAG": 
-            "Rag智能召回", # 映射到上面的 `Rag智能召回` 插件
-
-        "多媒体查询": 
-            "多媒体智能体", # 映射到上面的 `多媒体智能体` 插件
-    }
--- a/crazy_functions/Internet_GPT.py
+++ b/crazy_functions/Internet_GPT.py
@@ -7,7 +7,7 @@ from bs4 import BeautifulSoup
 from functools import lru_cache
 from itertools import zip_longest
 from check_proxy import check_proxy
-from toolbox import CatchException, update_ui, get_conf, update_ui_lastest_msg
+from toolbox import CatchException, update_ui, get_conf
 from crazy_functions.crazy_utils import request_gpt_model_in_new_thread_with_ui_alive, input_clipping
 from request_llms.bridge_all import model_info
 from request_llms.bridge_all import predict_no_ui_long_connection
@@ -115,8 +115,7 @@ def get_auth_ip():

 def searxng_request(query, proxies, categories='general', searxng_url=None, engines=None):
    if searxng_url is None:
-        urls = get_conf("SEARXNG_URLS")
-        url = random.choice(urls)
+        url = get_conf("SEARXNG_URL")
    else:
        url = searxng_url

@@ -193,38 +192,6 @@ def scrape_text(url, proxies) -> str:
    text = "\n".join(chunk for chunk in chunks if chunk)
    return text

-def internet_search_with_analysis_prompt(prompt, analysis_prompt, llm_kwargs, chatbot):
-    from toolbox import get_conf
-    proxies = get_conf('proxies')
-    categories = 'general'
-    searxng_url = None  # 使用默认的searxng_url
-    engines = None  # 使用默认的搜索引擎
-    yield from update_ui_lastest_msg(lastmsg=f"检索中: {prompt} ...", chatbot=chatbot, history=[], delay=1)
-    urls = searxng_request(prompt, proxies, categories, searxng_url, engines=engines)
-    yield from update_ui_lastest_msg(lastmsg=f"依次访问搜索到的网站 ...", chatbot=chatbot, history=[], delay=1)
-    if len(urls) == 0:
-        return None
-    max_search_result = 5   # 最多收纳多少个网页的结果
-    history = []
-    for index, url in enumerate(urls[:max_search_result]):
-        yield from update_ui_lastest_msg(lastmsg=f"依次访问搜索到的网站: {url['link']} ...", chatbot=chatbot, history=[], delay=1)
-        res = scrape_text(url['link'], proxies)
-        prefix = f"第{index}份搜索结果 [源自{url['source'][0]}搜索] （{url['title'][:25]}）："
-        history.extend([prefix, res])
-    i_say = f"从以上搜索结果中抽取信息，然后回答问题：{prompt} {analysis_prompt}"
-    i_say, history = input_clipping( # 裁剪输入，从最长的条目开始裁剪，防止爆token
-        inputs=i_say,
-        history=history,
-        max_token_limit=8192
-    )
-    gpt_say = predict_no_ui_long_connection(
-        inputs=i_say,
-        llm_kwargs=llm_kwargs,
-        history=history,
-        sys_prompt="请从搜索结果中抽取信息，对最相关的两个搜索结果进行总结，然后回答问题。",
-        console_slience=False,
-    )
-    return gpt_say

@CatchException
 def 连接网络回答问题(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
--- a/crazy_functions/Internet_GPT_Wrap.py
+++ b/crazy_functions/Internet_GPT_Wrap.py
@@ -1,4 +1,4 @@
-import random
+
 from toolbox import get_conf
 from crazy_functions.Internet_GPT import 连接网络回答问题
 from crazy_functions.plugin_template.plugin_class_template import GptAcademicPluginTemplate, ArgProperty
@@ -20,9 +20,6 @@ class NetworkGPT_Wrap(GptAcademicPluginTemplate):
        第三个参数，名称`allow_cache`，参数`type`声明这是一个下拉菜单，下拉菜单上方显示`title`+`description`，下拉菜单的选项为`options`，`default_value`为下拉菜单默认值；

        """
-        urls = get_conf("SEARXNG_URLS")
-        url = random.choice(urls)
-
        gui_definition = {
            "main_input":
                ArgProperty(title="输入问题", description="待通过互联网检索的问题，会自动读取输入框内容", default_value="", type="string").model_dump_json(), # 主输入，自动从输入框同步
@@ -33,7 +30,7 @@ class NetworkGPT_Wrap(GptAcademicPluginTemplate):
            "optimizer":
                ArgProperty(title="搜索优化", options=["关闭", "开启", "开启(增强)"], default_value="关闭", description="是否使用搜索增强。注意这可能会消耗较多token", type="dropdown").model_dump_json(),
            "searxng_url":
-                ArgProperty(title="Searxng服务地址", description="输入Searxng的地址", default_value=url, type="string").model_dump_json(), # 主输入，自动从输入框同步
+                ArgProperty(title="Searxng服务地址", description="输入Searxng的地址", default_value=get_conf("SEARXNG_URL"), type="string").model_dump_json(), # 主输入，自动从输入框同步

        }
        return gui_definition
--- a/crazy_functions/Latex_Function.py
+++ b/crazy_functions/Latex_Function.py
@@ -559,7 +559,7 @@ def PDF翻译中文并重新编译PDF(txt, llm_kwargs, plugin_kwargs, chatbot, h
    project_folder = move_project(project_folder)

    # <-------------- set a hash tag for repeat-checking ------------->
-    with open(pj(project_folder, hash_tag + '.tag'), 'w', encoding='utf8') as f:
+    with open(pj(project_folder, hash_tag + '.tag'), 'w') as f:
        f.write(hash_tag)
        f.close()

--- a/crazy_functions/Latex_Project_Polish.py
+++ b/crazy_functions/Latex_Project_Polish.py
--- a/crazy_functions/Latex_Project_Translate_Legacy.py
+++ b/crazy_functions/Latex_Project_Translate_Legacy.py
--- a/crazy_functions/PDF_Translate.py
+++ b/crazy_functions/PDF_Translate.py
@@ -47,7 +47,7 @@ def 批量翻译PDF文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, syst
                yield from 解析PDF_基于DOC2X(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, DOC2X_API_KEY, user_request)
                return
            except:
-                chatbot.append([None, f"DOC2X服务不可用，请检查报错详细。{trimmed_format_exc_markdown()}"])
+                chatbot.append([None, f"DOC2X服务不可用，现在将执行效果稍差的旧版代码。{trimmed_format_exc_markdown()}"])
                yield from update_ui(chatbot=chatbot, history=history)

    if method == "GROBID":
--- a/crazy_functions/Rag_Interface.py
+++ b/crazy_functions/Rag_Interface.py
@@ -1,11 +1,4 @@
-import os,glob
-from typing import List
-
-from shared_utils.fastapi_server import validate_path_safety
-
-from toolbox import report_exception
 from toolbox import CatchException, update_ui, get_conf, get_log_folder, update_ui_lastest_msg
-from shared_utils.fastapi_server import validate_path_safety
 from crazy_functions.crazy_utils import input_clipping
 from crazy_functions.crazy_utils import request_gpt_model_in_new_thread_with_ui_alive

@@ -14,37 +7,6 @@ MAX_HISTORY_ROUND = 5
 MAX_CONTEXT_TOKEN_LIMIT = 4096
 REMEMBER_PREVIEW = 1000

-@CatchException
-def handle_document_upload(files: List[str], llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request, rag_worker):
-    """
-    Handles document uploads by extracting text and adding it to the vector store.
-    """
-    from llama_index.core import Document
-    from crazy_functions.rag_fns.rag_file_support import extract_text, supports_format
-    user_name = chatbot.get_user()
-    checkpoint_dir = get_log_folder(user_name, plugin_name='experimental_rag')
-
-    for file_path in files:
-        try:
-            validate_path_safety(file_path, user_name)
-            text = extract_text(file_path)
-            if text is None:
-                chatbot.append(
-                    [f"上传文件: {os.path.basename(file_path)}", f"文件解析失败，无法提取文本内容，请更换文件。失败原因可能为：1.文档格式过于复杂；2. 不支持的文件格式，支持的文件格式后缀有:" + ", ".join(supports_format)])
-            else:
-                chatbot.append(
-                    [f"上传文件: {os.path.basename(file_path)}", f"上传文件前50个字符为:{text[:50]}。"])
-                document = Document(text=text, metadata={"source": file_path})
-                rag_worker.add_documents_to_vector_store([document])
-                chatbot.append([f"上传文件: {os.path.basename(file_path)}", "文件已成功添加到知识库。"])
-        except Exception as e:
-            report_exception(chatbot, history, a=f"处理文件: {file_path}", b=str(e))
-
-    yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
-
-
-
-# Main Q&A function with document upload support
@CatchException
 def Rag问答(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):

@@ -61,45 +23,28 @@ def Rag问答(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, u
    # 1. we retrieve rag worker from global context
    user_name = chatbot.get_user()
    checkpoint_dir = get_log_folder(user_name, plugin_name='experimental_rag')
-
    if user_name in RAG_WORKER_REGISTER:
        rag_worker = RAG_WORKER_REGISTER[user_name]
    else:
        rag_worker = RAG_WORKER_REGISTER[user_name] = LlamaIndexRagWorker(
-            user_name,
-            llm_kwargs,
-            checkpoint_dir=checkpoint_dir,
-            auto_load_checkpoint=True
-        )
-
+            user_name, 
+            llm_kwargs, 
+            checkpoint_dir=checkpoint_dir, 
+            auto_load_checkpoint=True)
    current_context = f"{VECTOR_STORE_TYPE} @ {checkpoint_dir}"
    tip = "提示：输入“清空向量数据库”可以清空RAG向量数据库"
-
-    # 2. Handle special commands
-    if os.path.exists(txt) and os.path.isdir(txt):
-        project_folder = txt
-        validate_path_safety(project_folder, chatbot.get_user())
-        # Extract file paths from the user input
-        # Assuming the user inputs file paths separated by commas after the command
-        file_paths =  [f for f in glob.glob(f'{project_folder}/**/*', recursive=True)]
-        chatbot.append([txt, f'正在处理上传的文档 ({current_context}) ...'])
-        yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
-
-        yield from handle_document_upload(file_paths, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request, rag_worker)
-        return
-
-    elif txt == "清空向量数据库":
+    if txt == "清空向量数据库":
        chatbot.append([txt, f'正在清空 ({current_context}) ...'])
-        yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
-        rag_worker.purge_vector_store()
-        yield from update_ui_lastest_msg('已清空', chatbot, history, delay=0)  # 刷新界面
+        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
+        rag_worker.purge()
+        yield from update_ui_lastest_msg('已清空', chatbot, history, delay=0) # 刷新界面
        return

-    # 3. Normal Q&A processing
    chatbot.append([txt, f'正在召回知识 ({current_context}) ...'])
-    yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面

-    # 4. Clip history to reduce token consumption
+    # 2. clip history to reduce token consumption
+    #   2-1. reduce chat round
    txt_origin = txt

    if len(history) > MAX_HISTORY_ROUND * 2:
@@ -107,47 +52,41 @@ def Rag问答(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, u
    txt_clip, history, flags = input_clipping(txt, history, max_token_limit=MAX_CONTEXT_TOKEN_LIMIT, return_clip_flags=True)
    input_is_clipped_flag = (flags["original_input_len"] != flags["clipped_input_len"])

-    # 5. If input is clipped, add input to vector store before retrieve
+    #   2-2. if input is clipped, add input to vector store before retrieve
    if input_is_clipped_flag:
-        yield from update_ui_lastest_msg('检测到长输入, 正在向量化 ...', chatbot, history, delay=0)  # 刷新界面
-        # Save input to vector store
+        yield from update_ui_lastest_msg('检测到长输入, 正在向量化 ...', chatbot, history, delay=0) # 刷新界面
+        # save input to vector store
        rag_worker.add_text_to_vector_store(txt_origin)
-        yield from update_ui_lastest_msg('向量化完成 ...', chatbot, history, delay=0)  # 刷新界面
-
+        yield from update_ui_lastest_msg('向量化完成 ...', chatbot, history, delay=0) # 刷新界面
        if len(txt_origin) > REMEMBER_PREVIEW:
-            HALF = REMEMBER_PREVIEW // 2
+            HALF = REMEMBER_PREVIEW//2
            i_say_to_remember = txt[:HALF] + f" ...\n...(省略{len(txt_origin)-REMEMBER_PREVIEW}字)...\n... " + txt[-HALF:]
            if (flags["original_input_len"] - flags["clipped_input_len"]) > HALF:
-                txt_clip = txt_clip + f" ...\n...(省略{len(txt_origin)-len(txt_clip)-HALF}字)...\n... " + txt[-HALF:]
+                txt_clip = txt_clip  + f" ...\n...(省略{len(txt_origin)-len(txt_clip)-HALF}字)...\n... " + txt[-HALF:]
+            else:
+                pass
+            i_say = txt_clip
        else:
            i_say_to_remember = i_say = txt_clip
    else:
        i_say_to_remember = i_say = txt_clip

-    # 6. Search vector store and build prompts
+    # 3. we search vector store and build prompts
    nodes = rag_worker.retrieve_from_store_with_query(i_say)
    prompt = rag_worker.build_prompt(query=i_say, nodes=nodes)
-    # 7. Query language model
-    if len(chatbot) != 0:
-        chatbot.pop(-1)  # Pop temp chat, because we are going to add them again inside `request_gpt_model_in_new_thread_with_ui_alive`

+    # 4. it is time to query llms
+    if len(chatbot) != 0: chatbot.pop(-1) # pop temp chat, because we are going to add them again inside `request_gpt_model_in_new_thread_with_ui_alive`
    model_say = yield from request_gpt_model_in_new_thread_with_ui_alive(
-        inputs=prompt,
-        inputs_show_user=i_say,
-        llm_kwargs=llm_kwargs,
-        chatbot=chatbot,
-        history=history,
+        inputs=prompt, inputs_show_user=i_say,
+        llm_kwargs=llm_kwargs, chatbot=chatbot, history=history,
        sys_prompt=system_prompt,
        retry_times_at_unknown_error=0
    )

-    # 8. Remember Q&A
-    yield from update_ui_lastest_msg(
-        model_say + '</br></br>' + f'对话记忆中, 请稍等 ({current_context}) ...',
-        chatbot, history, delay=0.5
-    )
+    # 5. remember what has been asked / answered
+    yield from update_ui_lastest_msg(model_say + '</br></br>' + f'对话记忆中, 请稍等 ({current_context}) ...', chatbot, history, delay=0.5) # 刷新界面
    rag_worker.remember_qa(i_say_to_remember, model_say)
    history.extend([i_say, model_say])

-    # 9. Final UI Update
-    yield from update_ui_lastest_msg(model_say, chatbot, history, delay=0, msg=tip)
+    yield from update_ui_lastest_msg(model_say, chatbot, history, delay=0, msg=tip) # 刷新界面
--- a/crazy_functions/VideoResource_GPT.py
+++ b/crazy_functions/VideoResource_GPT.py
@@ -1,204 +0,0 @@
-import requests
-import random
-import time
-import re
-import json
-from bs4 import BeautifulSoup
-from functools import lru_cache
-from itertools import zip_longest
-from check_proxy import check_proxy
-from toolbox import CatchException, update_ui, get_conf, promote_file_to_downloadzone, update_ui_lastest_msg, generate_file_link
-from crazy_functions.crazy_utils import request_gpt_model_in_new_thread_with_ui_alive, input_clipping
-from request_llms.bridge_all import model_info
-from request_llms.bridge_all import predict_no_ui_long_connection
-from crazy_functions.prompts.internet import SearchOptimizerPrompt, SearchAcademicOptimizerPrompt
-from crazy_functions.json_fns.pydantic_io import GptJsonIO, JsonStringError
-from textwrap import dedent
-from loguru import logger
-from pydantic import BaseModel, Field
-
-class Query(BaseModel):
-    search_keyword: str = Field(description="search query for video resource")
-
-
-class VideoResource(BaseModel):
-    thought: str = Field(description="analysis of the search results based on the user's query")
-    title: str = Field(description="title of the video")
-    author: str = Field(description="author/uploader of the video") 
-    bvid: str = Field(description="unique ID of the video")
-    another_failsafe_bvid: str = Field(description="provide another bvid, the other one is not working")
-
-
-def get_video_resource(search_keyword):
-    from crazy_functions.media_fns.get_media import search_videos
-
-    # Search for videos and return the first result
-    videos = search_videos(
-        search_keyword
-    )
-
-    # Return the first video if results exist, otherwise return None
-    return videos
-
-def download_video(bvid, user_name, chatbot, history):
-    # from experimental_mods.get_bilibili_resource import download_bilibili
-    from crazy_functions.media_fns.get_media import download_video
-    # pause a while
-    tic_time = 8
-    for i in range(tic_time):
-        yield from update_ui_lastest_msg(
-            lastmsg=f"即将下载音频。等待{tic_time-i}秒后自动继续, 点击“停止”键取消此操作。", 
-            chatbot=chatbot, history=[], delay=1)
-
-    # download audio
-    chatbot.append((None, "下载音频, 请稍等...")); yield from update_ui(chatbot=chatbot, history=history)
-    downloaded_files = yield from download_video(bvid, only_audio=True, user_name=user_name, chatbot=chatbot, history=history)
-
-    if len(downloaded_files) == 0:
-        # failed to download audio
-        return []
-
-    # preview
-    preview_list = [promote_file_to_downloadzone(fp) for fp in downloaded_files]
-    file_links = generate_file_link(preview_list)
-    yield from update_ui_lastest_msg(f"已完成的文件: <br/>" + file_links, chatbot=chatbot, history=history, delay=0)
-    chatbot.append((None, f"即将下载视频。"))
-
-    # pause a while
-    tic_time = 16
-    for i in range(tic_time):
-        yield from update_ui_lastest_msg(
-            lastmsg=f"即将下载视频。等待{tic_time-i}秒后自动继续, 点击“停止”键取消此操作。", 
-            chatbot=chatbot, history=[], delay=1)
-
-    # download video
-    chatbot.append((None, "下载视频, 请稍等...")); yield from update_ui(chatbot=chatbot, history=history)
-    downloaded_files_part2 = yield from download_video(bvid, only_audio=False, user_name=user_name, chatbot=chatbot, history=history)
-
-    # preview
-    preview_list = [promote_file_to_downloadzone(fp) for fp in downloaded_files_part2]
-    file_links = generate_file_link(preview_list)
-    yield from update_ui_lastest_msg(f"已完成的文件: <br/>" + file_links, chatbot=chatbot, history=history, delay=0)
-
-    # return
-    return downloaded_files + downloaded_files_part2
-
-
-class Strategy(BaseModel):
-    thought: str = Field(description="analysis of the user's wish, for example, can you recall the name of the resource?")
-    which_methods: str = Field(description="Which method to use to find the necessary information? choose from 'method_1' and 'method_2'.")
-    method_1_search_keywords: str = Field(description="Generate keywords to search the internet if you choose method 1, otherwise empty.")
-    method_2_generate_keywords: str = Field(description="Generate keywords for video download engine if you choose method 2, otherwise empty.")
-
-
-@CatchException
-def 多媒体任务(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
-    user_wish: str = txt
-    # query demos: 
-    #   - "我想找一首歌，里面有句歌词是“turn your face towards the sun”"
-    #   - "一首歌，第一句是红豆生南国"
-    #   - "一首音乐，中国航天任务专用的那首"
-    #   - "戴森球计划在熔岩星球的音乐"
-    #   - "hanser的百变什么精"
-    #   - "打大圣残躯时的bgm"
-    #   - "渊下宫战斗音乐"
-
-    # 搜索
-    chatbot.append((txt, "检索中, 请稍等..."))
-    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-    if "跳过联网搜索" not in user_wish:
-        # 结构化生成
-        internet_search_keyword = user_wish
-
-        yield from update_ui_lastest_msg(lastmsg=f"发起互联网检索: {internet_search_keyword} ...", chatbot=chatbot, history=[], delay=1)
-        from crazy_functions.Internet_GPT import internet_search_with_analysis_prompt
-        result = yield from internet_search_with_analysis_prompt(
-            prompt=internet_search_keyword,
-            analysis_prompt="请根据搜索结果分析，获取用户需要找的资源的名称、作者、出处等信息。",
-            llm_kwargs=llm_kwargs,
-            chatbot=chatbot
-        )
-
-        yield from update_ui_lastest_msg(lastmsg=f"互联网检索结论: {result} \n\n 正在生成进一步检索方案 ...", chatbot=chatbot, history=[], delay=1)
-        rf_req = dedent(f"""
-        The user wish to get the following resource:
-            {user_wish}
-        Meanwhile, you can access another expert's opinion on the user's wish:
-            {result}
-        Generate search keywords (less than 5 keywords) for video download engine accordingly.
-        """)
-    else:
-        user_wish = user_wish.replace("跳过联网搜索", "").strip()
-        rf_req = dedent(f"""
-        The user wish to get the following resource:
-            {user_wish}
-        Generate reseach keywords (less than 5 keywords) accordingly.
-        """)
-    gpt_json_io = GptJsonIO(Query)
-    inputs = rf_req + gpt_json_io.format_instructions
-    run_gpt_fn = lambda inputs, sys_prompt: predict_no_ui_long_connection(inputs=inputs, llm_kwargs=llm_kwargs, history=[], sys_prompt=sys_prompt, observe_window=[])
-    analyze_res = run_gpt_fn(inputs, "")
-    logger.info(analyze_res)
-    query: Query = gpt_json_io.generate_output_auto_repair(analyze_res, run_gpt_fn)
-    video_engine_keywords = query.search_keyword
-    # 关键词展示
-    chatbot.append((None, f"检索关键词已确认: {video_engine_keywords}。筛选中, 请稍等..."))
-    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-
-    # 获取候选资源
-    candadate_dictionary: dict =  get_video_resource(video_engine_keywords)
-    candadate_dictionary_as_str = json.dumps(candadate_dictionary, ensure_ascii=False, indent=4)
-
-    # 展示候选资源
-    candadate_display = "\n".join([f"{i+1}. {it['title']}" for i, it in enumerate(candadate_dictionary)])
-    chatbot.append((None, f"候选:\n\n{candadate_display}"))
-    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-
-    # 结构化生成
-    rf_req_2 = dedent(f"""
-    The user wish to get the following resource:
-        {user_wish}
-
-    Select the most relevant and suitable video resource from the following search results:
-        {candadate_dictionary_as_str}
-
-    Note:
-        1. The first several search video results are more likely to satisfy the user's wish.
-        2. The time duration of the video should be less than 10 minutes.
-        3. You should analyze the search results first, before giving your answer.
-        4. Use Chinese if possible.
-        5. Beside the primary video selection, give a backup video resource `bvid`.
-    """)
-    gpt_json_io = GptJsonIO(VideoResource)
-    inputs = rf_req_2 + gpt_json_io.format_instructions
-    run_gpt_fn = lambda inputs, sys_prompt: predict_no_ui_long_connection(inputs=inputs, llm_kwargs=llm_kwargs, history=[], sys_prompt=sys_prompt, observe_window=[])
-    analyze_res = run_gpt_fn(inputs, "")
-    logger.info(analyze_res)
-    video_resource: VideoResource = gpt_json_io.generate_output_auto_repair(analyze_res, run_gpt_fn)
-
-    # Display
-    chatbot.append(
-        (None, 
-            f"分析：{video_resource.thought}" "<br/>"
-            f"选择: `{video_resource.title}`。" "<br/>" 
-            f"作者：{video_resource.author}"
-        )
-    )
-    chatbot.append((None, f"下载中, 请稍等..."))
-    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-
-    if video_resource and video_resource.bvid:
-        logger.info(video_resource)
-        downloaded = yield from download_video(video_resource.bvid, chatbot.get_user(), chatbot, history)
-        if not downloaded:
-            chatbot.append((None, f"下载失败, 尝试备选 ..."))
-            yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-            downloaded = yield from download_video(video_resource.another_failsafe_bvid, chatbot.get_user(), chatbot, history)
-
-
-
-
-        
-@CatchException
-def debug(bvid, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
-    yield from download_video(bvid, chatbot.get_user(), chatbot, history)
--- a/crazy_functions/chatglm微调工具.py
+++ b/crazy_functions/chatglm微调工具.py
@@ -0,0 +1,141 @@
+from toolbox import CatchException, update_ui, promote_file_to_downloadzone
+from crazy_functions.crazy_utils import request_gpt_model_multi_threads_with_very_awesome_ui_and_high_efficiency
+import datetime, json
+
+def fetch_items(list_of_items, batch_size):
+    for i in range(0, len(list_of_items), batch_size):
+        yield list_of_items[i:i + batch_size]
+
+def string_to_options(arguments):
+    import argparse
+    import shlex
+
+    # Create an argparse.ArgumentParser instance
+    parser = argparse.ArgumentParser()
+
+    # Add command-line arguments
+    parser.add_argument("--llm_to_learn", type=str, help="LLM model to learn", default="gpt-3.5-turbo")
+    parser.add_argument("--prompt_prefix", type=str, help="Prompt prefix", default='')
+    parser.add_argument("--system_prompt", type=str, help="System prompt", default='')
+    parser.add_argument("--batch", type=int, help="System prompt", default=50)
+    parser.add_argument("--pre_seq_len", type=int, help="pre_seq_len", default=50)
+    parser.add_argument("--learning_rate", type=float, help="learning_rate", default=2e-2)
+    parser.add_argument("--num_gpus", type=int, help="num_gpus", default=1)
+    parser.add_argument("--json_dataset", type=str, help="json_dataset", default="")
+    parser.add_argument("--ptuning_directory", type=str, help="ptuning_directory", default="")
+
+
+
+    # Parse the arguments
+    args = parser.parse_args(shlex.split(arguments))
+
+    return args
+
+@CatchException
+def 微调数据集生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
+    """
+    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
+    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
+    plugin_kwargs   插件模型的参数
+    chatbot         聊天显示框的句柄，用于显示给用户
+    history         聊天历史，前情提要
+    system_prompt   给gpt的静默提醒
+    user_request    当前用户的请求信息（IP地址等）
+    """
+    history = []    # 清空历史，以免输入溢出
+    chatbot.append(("这是什么功能？", "[Local Message] 微调数据集生成"))
+    if ("advanced_arg" in plugin_kwargs) and (plugin_kwargs["advanced_arg"] == ""): plugin_kwargs.pop("advanced_arg")
+    args = plugin_kwargs.get("advanced_arg", None)
+    if args is None:
+        chatbot.append(("没给定指令", "退出"))
+        yield from update_ui(chatbot=chatbot, history=history); return
+    else:
+        arguments = string_to_options(arguments=args)
+
+    dat = []
+    with open(txt, 'r', encoding='utf8') as f:
+        for line in f.readlines():
+            json_dat = json.loads(line)
+            dat.append(json_dat["content"])
+
+    llm_kwargs['llm_model'] = arguments.llm_to_learn
+    for batch in fetch_items(dat, arguments.batch):
+        res = yield from request_gpt_model_multi_threads_with_very_awesome_ui_and_high_efficiency(
+            inputs_array=[f"{arguments.prompt_prefix}\n\n{b}" for b in (batch)],
+            inputs_show_user_array=[f"Show Nothing" for _ in (batch)],
+            llm_kwargs=llm_kwargs,
+            chatbot=chatbot,
+            history_array=[[] for _ in (batch)],
+            sys_prompt_array=[arguments.system_prompt for _ in (batch)],
+            max_workers=10  # OpenAI所允许的最大并行过载
+        )
+
+        with open(txt+'.generated.json', 'a+', encoding='utf8') as f:
+            for b, r in zip(batch, res[1::2]):
+                f.write(json.dumps({"content":b, "summary":r}, ensure_ascii=False)+'\n')
+
+    promote_file_to_downloadzone(txt+'.generated.json', rename_file='generated.json', chatbot=chatbot)
+    return
+
+
+
+@CatchException
+def 启动微调(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
+    """
+    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
+    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
+    plugin_kwargs   插件模型的参数
+    chatbot         聊天显示框的句柄，用于显示给用户
+    history         聊天历史，前情提要
+    system_prompt   给gpt的静默提醒
+    user_request    当前用户的请求信息（IP地址等）
+    """
+    import subprocess
+    history = []    # 清空历史，以免输入溢出
+    chatbot.append(("这是什么功能？", "[Local Message] 微调数据集生成"))
+    if ("advanced_arg" in plugin_kwargs) and (plugin_kwargs["advanced_arg"] == ""): plugin_kwargs.pop("advanced_arg")
+    args = plugin_kwargs.get("advanced_arg", None)
+    if args is None:
+        chatbot.append(("没给定指令", "退出"))
+        yield from update_ui(chatbot=chatbot, history=history); return
+    else:
+        arguments = string_to_options(arguments=args)
+
+
+
+    pre_seq_len = arguments.pre_seq_len             # 128
+    learning_rate = arguments.learning_rate                               # 2e-2
+    num_gpus = arguments.num_gpus                   # 1
+    json_dataset = arguments.json_dataset                 # 't_code.json'
+    ptuning_directory = arguments.ptuning_directory       # '/home/hmp/ChatGLM2-6B/ptuning'
+
+    command = f"torchrun --standalone --nnodes=1 --nproc-per-node={num_gpus} main.py \
+        --do_train \
+        --train_file AdvertiseGen/{json_dataset} \
+        --validation_file AdvertiseGen/{json_dataset} \
+        --preprocessing_num_workers 20 \
+        --prompt_column content \
+        --response_column summary \
+        --overwrite_cache \
+        --model_name_or_path THUDM/chatglm2-6b \
+        --output_dir output/clothgen-chatglm2-6b-pt-{pre_seq_len}-{learning_rate} \
+        --overwrite_output_dir \
+        --max_source_length 256 \
+        --max_target_length 256 \
+        --per_device_train_batch_size 1 \
+        --per_device_eval_batch_size 1 \
+        --gradient_accumulation_steps 16 \
+        --predict_with_generate \
+        --max_steps 100 \
+        --logging_steps 10 \
+        --save_steps 20 \
+        --learning_rate {learning_rate} \
+        --pre_seq_len {pre_seq_len} \
+        --quantization_bit 4"
+
+    process = subprocess.Popen(command, shell=True, cwd=ptuning_directory)
+    try:
+        process.communicate(timeout=3600*24)
+    except subprocess.TimeoutExpired:
+        process.kill()
+    return
--- a/crazy_functions/crazy_utils.py
+++ b/crazy_functions/crazy_utils.py
@@ -169,7 +169,6 @@ def can_multi_process(llm) -> bool:
    def default_condition(llm) -> bool:
        # legacy condition
        if llm.startswith('gpt-'): return True
-        if llm.startswith('chatgpt-'): return True
        if llm.startswith('api2d-'): return True
        if llm.startswith('azure-'): return True
        if llm.startswith('spark'): return True
--- a/crazy_functions/latex_fns/latex_actions.py
+++ b/crazy_functions/latex_fns/latex_actions.py
@@ -300,8 +300,7 @@ def Latex精细分解与转化(file_manifest, project_folder, llm_kwargs, plugin
    write_html(pfg.sp_file_contents, pfg.sp_file_result, chatbot=chatbot, project_folder=project_folder)

    #  <-------- 写出文件 ---------->
-    model_name = llm_kwargs['llm_model'].replace('_', '\\_')  # 替换LLM模型名称中的下划线为转义字符
-    msg = f"当前大语言模型: {model_name}，当前语言模型温度设定: {llm_kwargs['temperature']}。"
+    msg = f"当前大语言模型: {llm_kwargs['llm_model']}，当前语言模型温度设定: {llm_kwargs['temperature']}。"
    final_tex = lps.merge_result(pfg.file_result, mode, msg)
    objdump((lps, pfg.file_result, mode, msg), file=pj(project_folder,'merge_result.pkl'))

@@ -352,41 +351,6 @@ def 编译Latex(chatbot, history, main_file_original, main_file_modified, work_f
    chatbot.append([f"正在编译PDF文档", f'编译已经开始。当前工作路径为{work_folder}，如果程序停顿5分钟以上，请直接去该路径下取回翻译结果，或者重启之后再度尝试 ...']); yield from update_ui(chatbot=chatbot, history=history)
    chatbot.append([f"正在编译PDF文档", '...']); yield from update_ui(chatbot=chatbot, history=history); time.sleep(1); chatbot[-1] = list(chatbot[-1]) # 刷新界面
    yield from update_ui_lastest_msg('编译已经开始...', chatbot, history)   # 刷新Gradio前端界面
-    # 检查是否需要使用xelatex
-    def check_if_need_xelatex(tex_path):
-        try:
-            with open(tex_path, 'r', encoding='utf-8', errors='replace') as f:
-                content = f.read(5000)
-                # 检查是否有使用xelatex的宏包
-                need_xelatex = any(
-                    pkg in content 
-                    for pkg in ['fontspec', 'xeCJK', 'xetex', 'unicode-math', 'xltxtra', 'xunicode']
-                )
-                if need_xelatex:
-                    logger.info(f"检测到宏包需要xelatex编译, 切换至xelatex编译")
-                else:
-                    logger.info(f"未检测到宏包需要xelatex编译, 使用pdflatex编译")
-                return need_xelatex
-        except Exception:
-            return False
-
-    # 根据编译器类型返回编译命令
-    def get_compile_command(compiler, filename):
-        compile_command = f'{compiler} -interaction=batchmode -file-line-error {filename}.tex'
-        logger.info('Latex 编译指令: ', compile_command)
-        return compile_command
-
-    # 确定使用的编译器
-    compiler = 'pdflatex'
-    if check_if_need_xelatex(pj(work_folder_modified, f'{main_file_modified}.tex')):
-        logger.info("检测到宏包需要xelatex编译，切换至xelatex编译")
-        # Check if xelatex is installed
-        try:
-            import subprocess
-            subprocess.run(['xelatex', '--version'], capture_output=True, check=True)
-            compiler = 'xelatex'
-        except (subprocess.CalledProcessError, FileNotFoundError):
-            raise RuntimeError("检测到需要使用xelatex编译，但系统中未安装xelatex。请先安装texlive或其他提供xelatex的LaTeX发行版。")

    while True:
        import os
@@ -397,10 +361,10 @@ def 编译Latex(chatbot, history, main_file_original, main_file_modified, work_f

        # https://stackoverflow.com/questions/738755/dont-make-me-manually-abort-a-latex-compile-when-theres-an-error
        yield from update_ui_lastest_msg(f'尝试第 {n_fix}/{max_try} 次编译, 编译原始PDF ...', chatbot, history)   # 刷新Gradio前端界面
-        ok = compile_latex_with_timeout(get_compile_command(compiler, main_file_original), work_folder_original)
+        ok = compile_latex_with_timeout(f'pdflatex -interaction=batchmode -file-line-error {main_file_original}.tex', work_folder_original)

        yield from update_ui_lastest_msg(f'尝试第 {n_fix}/{max_try} 次编译, 编译转化后的PDF ...', chatbot, history)   # 刷新Gradio前端界面
-        ok = compile_latex_with_timeout(get_compile_command(compiler, main_file_modified), work_folder_modified)
+        ok = compile_latex_with_timeout(f'pdflatex -interaction=batchmode -file-line-error {main_file_modified}.tex', work_folder_modified)

        if ok and os.path.exists(pj(work_folder_modified, f'{main_file_modified}.pdf')):
            # 只有第二步成功，才能继续下面的步骤
@@ -411,10 +375,10 @@ def 编译Latex(chatbot, history, main_file_original, main_file_modified, work_f
                ok = compile_latex_with_timeout(f'bibtex  {main_file_modified}.aux', work_folder_modified)

            yield from update_ui_lastest_msg(f'尝试第 {n_fix}/{max_try} 次编译, 编译文献交叉引用 ...', chatbot, history)  # 刷新Gradio前端界面
-            ok = compile_latex_with_timeout(get_compile_command(compiler, main_file_original), work_folder_original)
-            ok = compile_latex_with_timeout(get_compile_command(compiler, main_file_modified), work_folder_modified)
-            ok = compile_latex_with_timeout(get_compile_command(compiler, main_file_original), work_folder_original)
-            ok = compile_latex_with_timeout(get_compile_command(compiler, main_file_modified), work_folder_modified)
+            ok = compile_latex_with_timeout(f'pdflatex -interaction=batchmode -file-line-error {main_file_original}.tex', work_folder_original)
+            ok = compile_latex_with_timeout(f'pdflatex -interaction=batchmode -file-line-error {main_file_modified}.tex', work_folder_modified)
+            ok = compile_latex_with_timeout(f'pdflatex -interaction=batchmode -file-line-error {main_file_original}.tex', work_folder_original)
+            ok = compile_latex_with_timeout(f'pdflatex -interaction=batchmode -file-line-error {main_file_modified}.tex', work_folder_modified)

            if mode!='translate_zh':
                yield from update_ui_lastest_msg(f'尝试第 {n_fix}/{max_try} 次编译, 使用latexdiff生成论文转化前后对比 ...', chatbot, history) # 刷新Gradio前端界面
@@ -422,10 +386,10 @@ def 编译Latex(chatbot, history, main_file_original, main_file_modified, work_f
                ok = compile_latex_with_timeout(f'latexdiff --encoding=utf8 --append-safecmd=subfile {work_folder_original}/{main_file_original}.tex  {work_folder_modified}/{main_file_modified}.tex --flatten > {work_folder}/merge_diff.tex', os.getcwd())

                yield from update_ui_lastest_msg(f'尝试第 {n_fix}/{max_try} 次编译, 正在编译对比PDF ...', chatbot, history)   # 刷新Gradio前端界面
-                ok = compile_latex_with_timeout(get_compile_command(compiler, 'merge_diff'), work_folder)
+                ok = compile_latex_with_timeout(f'pdflatex  -interaction=batchmode -file-line-error merge_diff.tex', work_folder)
                ok = compile_latex_with_timeout(f'bibtex    merge_diff.aux', work_folder)
-                ok = compile_latex_with_timeout(get_compile_command(compiler, 'merge_diff'), work_folder)
-                ok = compile_latex_with_timeout(get_compile_command(compiler, 'merge_diff'), work_folder)
+                ok = compile_latex_with_timeout(f'pdflatex  -interaction=batchmode -file-line-error merge_diff.tex', work_folder)
+                ok = compile_latex_with_timeout(f'pdflatex  -interaction=batchmode -file-line-error merge_diff.tex', work_folder)

        # <---------- 检查结果 ----------->
        results_ = ""
--- a/crazy_functions/media_fns/get_media.py
+++ b/crazy_functions/media_fns/get_media.py
@@ -1,43 +0,0 @@
-from toolbox import update_ui, get_conf, promote_file_to_downloadzone, update_ui_lastest_msg, generate_file_link
-from shared_utils.docker_as_service_api import stream_daas
-from shared_utils.docker_as_service_api import DockerServiceApiComModel
-import random
-
-def download_video(video_id, only_audio, user_name, chatbot, history):
-    from toolbox import get_log_folder
-    chatbot.append([None, "Processing..."])
-    yield from update_ui(chatbot, history)
-    client_command = f'{video_id} --audio-only' if only_audio else video_id
-    server_urls = get_conf('DAAS_SERVER_URLS')
-    server_url = random.choice(server_urls)
-    docker_service_api_com_model = DockerServiceApiComModel(client_command=client_command)
-    save_file_dir = get_log_folder(user_name, plugin_name='media_downloader')
-    for output_manifest in stream_daas(docker_service_api_com_model, server_url, save_file_dir):
-        status_buf = ""
-        status_buf += "DaaS message: \n\n"
-        status_buf += output_manifest['server_message'].replace('\n', '<br/>')
-        status_buf += "\n\n"
-        status_buf += "DaaS standard error: \n\n"
-        status_buf += output_manifest['server_std_err'].replace('\n', '<br/>')
-        status_buf += "\n\n"
-        status_buf += "DaaS standard output: \n\n"
-        status_buf += output_manifest['server_std_out'].replace('\n', '<br/>')
-        status_buf += "\n\n"
-        status_buf += "DaaS file attach: \n\n"
-        status_buf += str(output_manifest['server_file_attach'])
-        yield from update_ui_lastest_msg(status_buf, chatbot, history)
-
-    return output_manifest['server_file_attach']
-
-
-def search_videos(keywords):
-    from toolbox import get_log_folder
-    client_command = keywords
-    server_urls = get_conf('DAAS_SERVER_URLS')
-    server_url = random.choice(server_urls)
-    server_url = server_url.replace('stream', 'search')
-    docker_service_api_com_model = DockerServiceApiComModel(client_command=client_command)
-    save_file_dir = get_log_folder("default_user", plugin_name='media_downloader')
-    for output_manifest in stream_daas(docker_service_api_com_model, server_url, save_file_dir):
-        return output_manifest['server_message']
-
--- a/crazy_functions/pdf_fns/parse_pdf_via_doc2x.py
+++ b/crazy_functions/pdf_fns/parse_pdf_via_doc2x.py
@@ -6,128 +6,75 @@ from crazy_functions.crazy_utils import get_files_from_everything
 from shared_utils.colorful import *
 from loguru import logger
 import os
-import requests
 import time

+def refresh_key(doc2x_api_key):
+    import requests, json
+    url = "https://api.doc2x.noedgeai.com/api/token/refresh"
+    res = requests.post(
+        url,
+        headers={"Authorization": "Bearer " + doc2x_api_key}
+    )
+    res_json = []
+    if res.status_code == 200:
+        decoded = res.content.decode("utf-8")
+        res_json = json.loads(decoded)
+        doc2x_api_key = res_json['data']['token']
+    else:
+        raise RuntimeError(format("[ERROR] status code: %d, body: %s" % (res.status_code, res.text)))
+    return doc2x_api_key

-def retry_request(max_retries=3, delay=3):
-    """
-    Decorator for retrying HTTP requests
-    Args:
-        max_retries: Maximum number of retry attempts
-        delay: Delay between retries in seconds
-    """
-
-    def decorator(func):
-        def wrapper(*args, **kwargs):
-            for attempt in range(max_retries):
-                try:
-                    return func(*args, **kwargs)
-                except Exception as e:
-                    if attempt < max_retries - 1:
-                        logger.error(
-                            f"Request failed, retrying... ({attempt + 1}/{max_retries}) Error: {e}"
-                        )
-                        time.sleep(delay)
-                        continue
-                    raise e
-            return None
-
-        return wrapper
-
-    return decorator
-
-
-@retry_request()
-def make_request(method, url, **kwargs):
-    """
-    Make HTTP request with retry mechanism
-    """
-    return requests.request(method, url, **kwargs)
-
-
-def doc2x_api_response_status(response, uid=""):
-    """
-    Check the status of Doc2x API response
-    Args:
-        response_data: Response object from Doc2x API
-    """
-    response_json = response.json()
-    response_data = response_json.get("data", {})
-    code = response_json.get("code", "Unknown")
-    meg = response_data.get("message", response_json)
-    trace_id = response.headers.get("trace-id", "Failed to get trace-id")
-    if response.status_code != 200:
-        raise RuntimeError(
-            f"Doc2x return an error:\nTrace ID: {trace_id} {uid}\n{response.status_code} - {response_json}"
-        )
-    if code in ["parse_page_limit_exceeded", "parse_concurrency_limit"]:
-        raise RuntimeError(
-            f"Reached the limit of Doc2x:\nTrace ID: {trace_id} {uid}\n{code} - {meg}"
-        )
-    if code not in ["ok", "success"]:
-        raise RuntimeError(
-            f"Doc2x return an error:\nTrace ID: {trace_id} {uid}\n{code} - {meg}"
-        )
-    return response_data


 def 解析PDF_DOC2X_转Latex(pdf_file_path):
-    zip_file_path, unzipped_folder = 解析PDF_DOC2X(pdf_file_path, format="tex")
+    zip_file_path, unzipped_folder = 解析PDF_DOC2X(pdf_file_path, format='tex')
    return unzipped_folder


-def 解析PDF_DOC2X(pdf_file_path, format="tex"):
+def 解析PDF_DOC2X(pdf_file_path, format='tex'):
    """
-    format: 'tex', 'md', 'docx'
+        format: 'tex', 'md', 'docx'
    """
-
-    DOC2X_API_KEY = get_conf("DOC2X_API_KEY")
+    import requests, json, os
+    DOC2X_API_KEY = get_conf('DOC2X_API_KEY')
    latex_dir = get_log_folder(plugin_name="pdf_ocr_latex")
    markdown_dir = get_log_folder(plugin_name="pdf_ocr")
    doc2x_api_key = DOC2X_API_KEY

-    # < ------ 第1步：预上传获取URL，然后上传文件 ------ >
-    logger.info("Doc2x 上传文件：预上传获取URL")
-    res = make_request(
-        "POST",
-        "https://v2.doc2x.noedgeai.com/api/v2/parse/preupload",
-        headers={"Authorization": "Bearer " + doc2x_api_key},
-        timeout=15,
-    )
-    res_data = doc2x_api_response_status(res)
-    upload_url = res_data["url"]
-    uuid = res_data["uid"]

-    logger.info("Doc2x 上传文件：上传文件")
-    with open(pdf_file_path, "rb") as file:
-        res = make_request("PUT", upload_url, data=file, timeout=60)
-    res.raise_for_status()
+    # < ------ 第1步：上传 ------ >
+    logger.info("Doc2x 第1步：上传")
+    with open(pdf_file_path, 'rb') as file:
+        res = requests.post(
+            "https://v2.doc2x.noedgeai.com/api/v2/parse/pdf",
+            headers={"Authorization": "Bearer " + doc2x_api_key},
+            data=file
+        )
+    # res_json = []
+    if res.status_code == 200:
+        res_json = res.json()
+    else:
+        raise RuntimeError(f"Doc2x return an error: {res.json()}")
+    uuid = res_json['data']['uid']

    # < ------ 第2步：轮询等待 ------ >
-    logger.info("Doc2x 处理文件中：轮询等待")
-    params = {"uid": uuid}
-    max_attempts = 60
-    attempt = 0
-    while attempt < max_attempts:
-        res = make_request(
-            "GET",
-            "https://v2.doc2x.noedgeai.com/api/v2/parse/status",
+    logger.info("Doc2x 第2步：轮询等待")
+    params = {'uid': uuid}
+    while True:
+        res = requests.get(
+            'https://v2.doc2x.noedgeai.com/api/v2/parse/status',
            headers={"Authorization": "Bearer " + doc2x_api_key},
-            params=params,
-            timeout=15,
+            params=params
        )
-        res_data = doc2x_api_response_status(res)
-        if res_data["status"] == "success":
+        res_json = res.json()
+        if res_json['data']['status'] == "success":
            break
-        elif res_data["status"] == "processing":
-            time.sleep(5)
-            logger.info(f"Doc2x is processing at {res_data['progress']}%")
-            attempt += 1
-        else:
-            raise RuntimeError(f"Doc2x return an error: {res_data}")
-    if attempt >= max_attempts:
-        raise RuntimeError("Doc2x processing timeout after maximum attempts")
+        elif res_json['data']['status'] == "processing":
+            time.sleep(3)
+            logger.info(f"Doc2x is processing at {res_json['data']['progress']}%")
+        elif res_json['data']['status'] == "failed":
+            raise RuntimeError(f"Doc2x return an error: {res_json}")
+

    # < ------ 第3步：提交转化 ------ >
    logger.info("Doc2x 第3步：提交转化")
@@ -137,44 +84,42 @@ def 解析PDF_DOC2X(pdf_file_path, format="tex"):
        "formula_mode": "dollar",
        "filename": "output"
    }
-    res = make_request(
-        "POST",
-        "https://v2.doc2x.noedgeai.com/api/v2/convert/parse",
+    res = requests.post(
+        'https://v2.doc2x.noedgeai.com/api/v2/convert/parse',
        headers={"Authorization": "Bearer " + doc2x_api_key},
-        json=data,
-        timeout=15,
+        json=data
    )
-    doc2x_api_response_status(res, uid=f"uid: {uuid}")
+    if res.status_code == 200:
+        res_json = res.json()
+    else:
+        raise RuntimeError(f"Doc2x return an error: {res.json()}")
+

    # < ------ 第4步：等待结果 ------ >
    logger.info("Doc2x 第4步：等待结果")
-    params = {"uid": uuid}
-    max_attempts = 36
-    attempt = 0
-    while attempt < max_attempts:
-        res = make_request(
-            "GET",
-            "https://v2.doc2x.noedgeai.com/api/v2/convert/parse/result",
+    params = {'uid': uuid}
+    while True:
+        res = requests.get(
+            'https://v2.doc2x.noedgeai.com/api/v2/convert/parse/result',
            headers={"Authorization": "Bearer " + doc2x_api_key},
-            params=params,
-            timeout=15,
+            params=params
        )
-        res_data = doc2x_api_response_status(res, uid=f"uid: {uuid}")
-        if res_data["status"] == "success":
+        res_json = res.json()
+        if res_json['data']['status'] == "success":
            break
-        elif res_data["status"] == "processing":
+        elif res_json['data']['status'] == "processing":
            time.sleep(3)
-            logger.info("Doc2x still processing to convert file")
-            attempt += 1
-    if attempt >= max_attempts:
-        raise RuntimeError("Doc2x conversion timeout after maximum attempts")
+            logger.info(f"Doc2x still processing")
+        elif res_json['data']['status'] == "failed":
+            raise RuntimeError(f"Doc2x return an error: {res_json}")
+

    # < ------ 第5步：最后的处理 ------ >
-    logger.info("Doc2x 第5步：下载转换后的文件")
+    logger.info("Doc2x 第5步：最后的处理")

-    if format == "tex":
+    if format=='tex':
        target_path = latex_dir
-    if format == "md":
+    if format=='md':
        target_path = markdown_dir
    os.makedirs(target_path, exist_ok=True)

@@ -182,18 +127,17 @@ def 解析PDF_DOC2X(pdf_file_path, format="tex"):
    # < ------ 下载 ------ >
    for attempt in range(max_attempt):
        try:
-            result_url = res_data["url"]
-            res = make_request("GET", result_url, timeout=60)
-            zip_path = os.path.join(target_path, gen_time_str() + ".zip")
+            result_url = res_json['data']['url']
+            res = requests.get(result_url)
+            zip_path = os.path.join(target_path, gen_time_str() + '.zip')
            unzip_path = os.path.join(target_path, gen_time_str())
            if res.status_code == 200:
-                with open(zip_path, "wb") as f:
-                    f.write(res.content)
+                with open(zip_path, "wb") as f: f.write(res.content)
            else:
                raise RuntimeError(f"Doc2x return an error: {res.json()}")
        except Exception as e:
            if attempt < max_attempt - 1:
-                logger.error(f"Failed to download uid = {uuid} file, retrying... {e}")
+                logger.error(f"Failed to download latex file, retrying... {e}")
                time.sleep(3)
                continue
            else:
@@ -201,31 +145,22 @@ def 解析PDF_DOC2X(pdf_file_path, format="tex"):

    # < ------ 解压 ------ >
    import zipfile
-    with zipfile.ZipFile(zip_path, "r") as zip_ref:
+    with zipfile.ZipFile(zip_path, 'r') as zip_ref:
        zip_ref.extractall(unzip_path)
    return zip_path, unzip_path


-def 解析PDF_DOC2X_单文件(
-    fp,
-    project_folder,
-    llm_kwargs,
-    plugin_kwargs,
-    chatbot,
-    history,
-    system_prompt,
-    DOC2X_API_KEY,
-    user_request,
-):
+def 解析PDF_DOC2X_单文件(fp, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, DOC2X_API_KEY, user_request):
+
    def pdf2markdown(filepath):
        chatbot.append((None, f"Doc2x 解析中"))
-        yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面

-        md_zip_path, unzipped_folder = 解析PDF_DOC2X(filepath, format="md")
+        md_zip_path, unzipped_folder = 解析PDF_DOC2X(filepath, format='md')

        promote_file_to_downloadzone(md_zip_path, chatbot=chatbot)
        chatbot.append((None, f"完成解析 {md_zip_path} ..."))
-        yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
        return md_zip_path

    def deliver_to_markdown_plugin(md_zip_path, user_request):
@@ -239,97 +174,77 @@ def 解析PDF_DOC2X_单文件(
        os.makedirs(target_path_base, exist_ok=True)
        shutil.copyfile(md_zip_path, this_file_path)
        ex_folder = this_file_path + ".extract"
-        extract_archive(file_path=this_file_path, dest_dir=ex_folder)
+        extract_archive(
+            file_path=this_file_path, dest_dir=ex_folder
+        )

        # edit markdown files
-        success, file_manifest, project_folder = get_files_from_everything(
-            ex_folder, type=".md"
-        )
+        success, file_manifest, project_folder = get_files_from_everything(ex_folder, type='.md')
        for generated_fp in file_manifest:
            # 修正一些公式问题
-            with open(generated_fp, "r", encoding="utf8") as f:
+            with open(generated_fp, 'r', encoding='utf8') as f:
                content = f.read()
            # 将公式中的\[ \]替换成$$
-            content = content.replace(r"\[", r"$$").replace(r"\]", r"$$")
+            content = content.replace(r'\[', r'$$').replace(r'\]', r'$$')
            # 将公式中的\( \)替换成$
-            content = content.replace(r"\(", r"$").replace(r"\)", r"$")
-            content = content.replace("```markdown", "\n").replace("```", "\n")
-            with open(generated_fp, "w", encoding="utf8") as f:
+            content = content.replace(r'\(', r'$').replace(r'\)', r'$')
+            content = content.replace('```markdown', '\n').replace('```', '\n')
+            with open(generated_fp, 'w', encoding='utf8') as f:
                f.write(content)
            promote_file_to_downloadzone(generated_fp, chatbot=chatbot)
-            yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+            yield from update_ui(chatbot=chatbot, history=history) # 刷新界面

            # 生成在线预览html
-            file_name = "在线预览翻译（原文）" + gen_time_str() + ".html"
+            file_name = '在线预览翻译（原文）' + gen_time_str() + '.html'
            preview_fp = os.path.join(ex_folder, file_name)
-            from shared_utils.advanced_markdown_format import (
-                markdown_convertion_for_file,
-            )
-
+            from shared_utils.advanced_markdown_format import markdown_convertion_for_file
            with open(generated_fp, "r", encoding="utf-8") as f:
                md = f.read()
            #     # Markdown中使用不标准的表格，需要在表格前加上一个emoji，以便公式渲染
            #     md = re.sub(r'^<table>', r'.<table>', md, flags=re.MULTILINE)
            html = markdown_convertion_for_file(md)
-            with open(preview_fp, "w", encoding="utf-8") as f:
-                f.write(html)
+            with open(preview_fp, "w", encoding="utf-8") as f: f.write(html)
            chatbot.append([None, f"生成在线预览：{generate_file_link([preview_fp])}"])
            promote_file_to_downloadzone(preview_fp, chatbot=chatbot)

-        chatbot.append((None, f"调用Markdown插件 {ex_folder} ..."))
-        plugin_kwargs["markdown_expected_output_dir"] = ex_folder

-        translated_f_name = "translated_markdown.md"
-        generated_fp = plugin_kwargs["markdown_expected_output_path"] = os.path.join(
-            ex_folder, translated_f_name
-        )
-        yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
-        yield from Markdown英译中(
-            ex_folder,
-            llm_kwargs,
-            plugin_kwargs,
-            chatbot,
-            history,
-            system_prompt,
-            user_request,
-        )
+
+        chatbot.append((None, f"调用Markdown插件 {ex_folder} ..."))
+        plugin_kwargs['markdown_expected_output_dir'] = ex_folder
+
+        translated_f_name = 'translated_markdown.md'
+        generated_fp = plugin_kwargs['markdown_expected_output_path'] = os.path.join(ex_folder, translated_f_name)
+        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
+        yield from Markdown英译中(ex_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request)
        if os.path.exists(generated_fp):
            # 修正一些公式问题
-            with open(generated_fp, "r", encoding="utf8") as f:
-                content = f.read()
-            content = content.replace("```markdown", "\n").replace("```", "\n")
+            with open(generated_fp, 'r', encoding='utf8') as f: content = f.read()
+            content = content.replace('```markdown', '\n').replace('```', '\n')
            # Markdown中使用不标准的表格，需要在表格前加上一个emoji，以便公式渲染
            # content = re.sub(r'^<table>', r'.<table>', content, flags=re.MULTILINE)
-            with open(generated_fp, "w", encoding="utf8") as f:
-                f.write(content)
+            with open(generated_fp, 'w', encoding='utf8') as f: f.write(content)
            # 生成在线预览html
-            file_name = "在线预览翻译" + gen_time_str() + ".html"
+            file_name = '在线预览翻译' + gen_time_str() + '.html'
            preview_fp = os.path.join(ex_folder, file_name)
-            from shared_utils.advanced_markdown_format import (
-                markdown_convertion_for_file,
-            )
-
+            from shared_utils.advanced_markdown_format import markdown_convertion_for_file
            with open(generated_fp, "r", encoding="utf-8") as f:
                md = f.read()
            html = markdown_convertion_for_file(md)
-            with open(preview_fp, "w", encoding="utf-8") as f:
-                f.write(html)
+            with open(preview_fp, "w", encoding="utf-8") as f: f.write(html)
            promote_file_to_downloadzone(preview_fp, chatbot=chatbot)
            # 生成包含图片的压缩包
            dest_folder = get_log_folder(chatbot.get_user())
-            zip_name = "翻译后的带图文档.zip"
-            zip_folder(
-                source_folder=ex_folder, dest_folder=dest_folder, zip_name=zip_name
-            )
+            zip_name = '翻译后的带图文档.zip'
+            zip_folder(source_folder=ex_folder, dest_folder=dest_folder, zip_name=zip_name)
            zip_fp = os.path.join(dest_folder, zip_name)
            promote_file_to_downloadzone(zip_fp, chatbot=chatbot)
-            yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
-
+            yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
    md_zip_path = yield from pdf2markdown(fp)
    yield from deliver_to_markdown_plugin(md_zip_path, user_request)

-
 def 解析PDF_基于DOC2X(file_manifest, *args):
    for index, fp in enumerate(file_manifest):
        yield from 解析PDF_DOC2X_单文件(fp, *args)
    return
+
+
--- a/crazy_functions/rag_fns/llama_index_worker.py
+++ b/crazy_functions/rag_fns/llama_index_worker.py
@@ -1,13 +1,17 @@
+import llama_index
+import os
 import atexit
 from loguru import logger
 from typing import List
-
 from llama_index.core import Document
-from llama_index.core.ingestion import run_transformations
 from llama_index.core.schema import TextNode
-
-from crazy_functions.rag_fns.vector_store_index import GptacVectorStoreIndex
 from request_llms.embed_models.openai_embed import OpenAiEmbeddingModel
+from shared_utils.connect_void_terminal import get_chat_default_kwargs
+from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
+from crazy_functions.rag_fns.vector_store_index import GptacVectorStoreIndex
+from llama_index.core.ingestion import run_transformations
+from llama_index.core import PromptTemplate
+from llama_index.core.response_synthesizers import TreeSummarize

 DEFAULT_QUERY_GENERATION_PROMPT = """\
 Now, you have context information as below:
@@ -59,7 +63,7 @@ class SaveLoad():
    def purge(self):
        import shutil
        shutil.rmtree(self.checkpoint_dir, ignore_errors=True)
-        self.vs_index = self.create_new_vs(self.checkpoint_dir)
+        self.vs_index = self.create_new_vs()


 class LlamaIndexRagWorker(SaveLoad):
@@ -71,7 +75,7 @@ class LlamaIndexRagWorker(SaveLoad):
        if auto_load_checkpoint:
            self.vs_index = self.load_from_checkpoint(checkpoint_dir)
        else:
-            self.vs_index = self.create_new_vs()
+            self.vs_index = self.create_new_vs(checkpoint_dir)
        atexit.register(lambda: self.save_to_checkpoint(checkpoint_dir))

    def assign_embedding_model(self):
@@ -87,52 +91,40 @@ class LlamaIndexRagWorker(SaveLoad):
        logger.info('oo --------inspect_vector_store end--------')
        return vector_store_preview

-    def add_documents_to_vector_store(self, document_list: List[Document]):
-        """
-        Adds a list of Document objects to the vector store after processing.
-        """
-        documents = document_list
+    def add_documents_to_vector_store(self, document_list):
+        documents = [Document(text=t) for t in document_list]
        documents_nodes = run_transformations(
-            documents,  # type: ignore
-            self.vs_index._transformations,
-            show_progress=True
-        )
+                        documents,  # type: ignore
+                        self.vs_index._transformations,
+                        show_progress=True
+                    )
        self.vs_index.insert_nodes(documents_nodes)
-        if self.debug_mode:
-            self.inspect_vector_store()
+        if self.debug_mode: self.inspect_vector_store()

-    def add_text_to_vector_store(self, text: str):
+    def add_text_to_vector_store(self, text):
        node = TextNode(text=text)
        documents_nodes = run_transformations(
-            [node],
-            self.vs_index._transformations,
-            show_progress=True
-        )
+                        [node],
+                        self.vs_index._transformations,
+                        show_progress=True
+                    )
        self.vs_index.insert_nodes(documents_nodes)
-        if self.debug_mode:
-            self.inspect_vector_store()
+        if self.debug_mode: self.inspect_vector_store()

    def remember_qa(self, question, answer):
        formatted_str = QUESTION_ANSWER_RECORD.format(question=question, answer=answer)
        self.add_text_to_vector_store(formatted_str)

    def retrieve_from_store_with_query(self, query):
-        if self.debug_mode:
-            self.inspect_vector_store()
+        if self.debug_mode: self.inspect_vector_store()
        retriever = self.vs_index.as_retriever()
        return retriever.retrieve(query)

    def build_prompt(self, query, nodes):
        context_str = self.generate_node_array_preview(nodes)
        return DEFAULT_QUERY_GENERATION_PROMPT.format(context_str=context_str, query_str=query)
-
+        
    def generate_node_array_preview(self, nodes):
        buf = "\n".join(([f"(No.{i+1} | score {n.score:.3f}): {n.text}" for i, n in enumerate(nodes)]))
        if self.debug_mode: logger.info(buf)
        return buf
-
-    def purge_vector_store(self):
-        """
-        Purges the current vector store and creates a new one.
-        """
-        self.purge()
--- a/crazy_functions/rag_fns/rag_file_support.py
+++ b/crazy_functions/rag_fns/rag_file_support.py
@@ -1,22 +0,0 @@
-import os
-from llama_index.core import SimpleDirectoryReader
-
-supports_format = ['.csv', '.docx', '.epub', '.ipynb',  '.mbox', '.md', '.pdf',  '.txt', '.ppt',
-                   '.pptm', '.pptx']
-
-
-# 修改后的 extract_text 函数，结合 SimpleDirectoryReader 和自定义解析逻辑
-def extract_text(file_path):
-    _, ext = os.path.splitext(file_path.lower())
-
-    # 使用 SimpleDirectoryReader 处理它支持的文件格式
-    if ext in supports_format:
-        try:
-            reader = SimpleDirectoryReader(input_files=[file_path])
-            documents = reader.load_data()
-            if len(documents) > 0:
-                return documents[0].text
-        except Exception as e:
-            pass
-
-    return None
--- a/crazy_functions/word_dfa/dfa_algo.py
+++ b/crazy_functions/word_dfa/dfa_algo.py
--- a/docs/WindowsRun.bat
+++ b/docs/WindowsRun.bat
@@ -1,26 +0,0 @@
-@echo off
-setlocal
-
-:: 设置环境变量
-set ENV_NAME=gpt
-set ENV_PATH=%~dp0%ENV_NAME%
-set SCRIPT_PATH=%~dp0main.py
-
-:: 判断环境是否已解压
-if not exist "%ENV_PATH%" (
-    echo Extracting environment...
-    mkdir "%ENV_PATH%"
-    tar -xzf gpt.tar.gz -C "%ENV_PATH%"
-    
-    :: 运行conda环境激活脚本
-    call "%ENV_PATH%\Scripts\activate.bat"
-) else (
-    :: 如果环境已存在,直接激活
-    call "%ENV_PATH%\Scripts\activate.bat"
-)
-echo Start to run program:
-:: 运行Python脚本
-python "%SCRIPT_PATH%"
-
-endlocal
-pause
--- a/main.py
+++ b/main.py
@@ -34,9 +34,9 @@ def encode_plugin_info(k, plugin)->str:

 def main():
    import gradio as gr
-    if gr.__version__ not in ['3.32.12']:
+    if gr.__version__ not in ['3.32.9', '3.32.10', '3.32.11']:
        raise ModuleNotFoundError("使用项目内置Gradio获取最优体验! 请运行 `pip install -r requirements.txt` 指令安装内置Gradio及其他依赖, 详情信息见requirements.txt.")
-
+    
    # 一些基础工具
    from toolbox import format_io, find_free_port, on_file_uploaded, on_report_generated, get_conf, ArgsGeneralWrapper, DummyWith

@@ -57,8 +57,8 @@ def main():
    # 如果WEB_PORT是-1, 则随机选取WEB端口
    PORT = find_free_port() if WEB_PORT <= 0 else WEB_PORT
    from check_proxy import get_current_version
-    from themes.theme import adjust_theme, advanced_css, theme_declaration, js_code_clear, js_code_show_or_hide, js_code_show_or_hide_group2
-    from themes.theme import js_code_for_toggle_darkmode
+    from themes.theme import adjust_theme, advanced_css, theme_declaration, js_code_clear, js_code_reset, js_code_show_or_hide, js_code_show_or_hide_group2
+    from themes.theme import js_code_for_toggle_darkmode, js_code_for_persistent_cookie_init
    from themes.theme import load_dynamic_theme, to_cookie_str, from_cookie_str, assign_user_uuid
    title_html = f"<h1 align=\"center\">GPT 学术优化 {get_current_version()}</h1>{theme_declaration}"

@@ -68,7 +68,7 @@ def main():
    functional = get_core_functions()

    # 高级函数插件
-    from crazy_functional import get_crazy_functions, get_multiplex_button_functions
+    from crazy_functional import get_crazy_functions
    DEFAULT_FN_GROUPS = get_conf('DEFAULT_FN_GROUPS')
    plugins = get_crazy_functions()
    all_plugin_groups = list(set([g for _, plugin in plugins.items() for g in plugin['Group'].split('|')]))
@@ -106,7 +106,7 @@ def main():
            with gr_L2(scale=2, elem_id="gpt-chat"):
                chatbot = gr.Chatbot(label=f"当前模型：{LLM_MODEL}", elem_id="gpt-chatbot")
                if LAYOUT == "TOP-DOWN":  chatbot.style(height=CHATBOT_HEIGHT)
-                history, _, _ = make_history_cache() # 定义 后端state（history）、前端（history_cache）、后端setter（history_cache_update）三兄弟
+                history, history_cache, history_cache_update = make_history_cache() # 定义 后端state（history）、前端（history_cache）、后端setter（history_cache_update）三兄弟
            with gr_L2(scale=1, elem_id="gpt-panel"):
                with gr.Accordion("输入区", open=True, elem_id="input-panel") as area_input_primary:
                    with gr.Row():
@@ -114,7 +114,12 @@ def main():
                    with gr.Row(elem_id="gpt-submit-row"):
                        multiplex_submit_btn = gr.Button("提交", elem_id="elem_submit_visible", variant="primary")
                        multiplex_sel = gr.Dropdown(
-                            choices=get_multiplex_button_functions().keys(), value="常规对话",
+                            choices=[
+                                "常规对话", 
+                                "多模型对话", 
+                                "智能召回 RAG",
+                                # "智能上下文", 
+                            ], value="常规对话",
                            interactive=True, label='', show_label=False,
                            elem_classes='normal_mut_select', elem_id="gpt-submit-dropdown").style(container=False)
                        submit_btn = gr.Button("提交", elem_id="elem_submit", variant="primary", visible=False)
@@ -174,7 +179,6 @@ def main():
                        with gr.Accordion("点击展开“文件下载区”。", open=False) as area_file_up:
                            file_upload = gr.Files(label="任何文件, 推荐上传压缩文件(zip, tar)", file_count="multiple", elem_id="elem_upload")

-
        # 左上角工具栏定义
        from themes.gui_toolbar import define_gui_toolbar
        checkboxes, checkboxes_2, max_length_sl, theme_dropdown, system_prompt, file_upload_2, md_dropdown, top_p, temperature = \
@@ -184,9 +188,6 @@ def main():
        from themes.gui_floating_menu import define_gui_floating_menu
        area_input_secondary, txt2, area_customize, _, resetBtn2, clearBtn2, stopBtn2 = \
            define_gui_floating_menu(customize_btns, functional, predefined_btns, cookies, web_cookie_cache)
-        
-        # 浮动时间线定义
-        gr.Spark()

        # 插件二级菜单的实现
        from themes.gui_advanced_plugin_class import define_gui_advanced_plugin_class
@@ -226,11 +227,11 @@ def main():
        multiplex_sel.select(
            None, [multiplex_sel], None, _js=f"""(multiplex_sel)=>run_multiplex_shift(multiplex_sel)""")
        cancel_handles.append(submit_btn.click(**predict_args))
-        resetBtn.click(None, None, [chatbot, history, status], _js="""(a,b,c)=>clear_conversation(a,b,c)""")   # 先在前端快速清除chatbot&status
-        resetBtn2.click(None, None, [chatbot, history, status], _js="""(a,b,c)=>clear_conversation(a,b,c)""")  # 先在前端快速清除chatbot&status
-        # reset_server_side_args = (lambda history: ([], [], "已重置"), [history], [chatbot, history, status])
-        # resetBtn.click(*reset_server_side_args)    # 再在后端清除history
-        # resetBtn2.click(*reset_server_side_args)   # 再在后端清除history
+        resetBtn.click(None, None, [chatbot, history, status], _js=js_code_reset)   # 先在前端快速清除chatbot&status
+        resetBtn2.click(None, None, [chatbot, history, status], _js=js_code_reset)  # 先在前端快速清除chatbot&status
+        reset_server_side_args = (lambda history: ([], [], "已重置", json.dumps(history)), [history], [chatbot, history, status, history_cache])
+        resetBtn.click(*reset_server_side_args)    # 再在后端清除history，把history转存history_cache备用
+        resetBtn2.click(*reset_server_side_args)   # 再在后端清除history，把history转存history_cache备用
        clearBtn.click(None, None, [txt, txt2], _js=js_code_clear)
        clearBtn2.click(None, None, [txt, txt2], _js=js_code_clear)
        if AUTO_CLEAR_TXT:
@@ -330,7 +331,7 @@ def main():
        from shared_utils.cookie_manager import load_web_cookie_cache__fn_builder
        load_web_cookie_cache = load_web_cookie_cache__fn_builder(customize_btns, cookies, predefined_btns)
        app_block.load(load_web_cookie_cache, inputs = [web_cookie_cache, cookies],
-            outputs = [web_cookie_cache, cookies, *customize_btns.values(), *predefined_btns.values()], _js="""persistent_cookie_init""")
+            outputs = [web_cookie_cache, cookies, *customize_btns.values(), *predefined_btns.values()], _js=js_code_for_persistent_cookie_init)
        app_block.load(None, inputs=[], outputs=None, _js=f"""()=>GptAcademicJavaScriptInit("{DARK_MODE}","{INIT_SYS_PROMPT}","{ADD_WAIFU}","{LAYOUT}","{TTS_TYPE}")""")    # 配置暗色主题或亮色主题
        app_block.load(None, inputs=[], outputs=None, _js="""()=>{REP}""".replace("REP", register_advanced_plugin_init_arr))

--- a/request_llms/bridge_all.py
+++ b/request_llms/bridge_all.py
@@ -26,9 +26,6 @@ from .bridge_chatglm import predict as chatglm_ui
 from .bridge_chatglm3 import predict_no_ui_long_connection as chatglm3_noui
 from .bridge_chatglm3 import predict as chatglm3_ui

-from .bridge_chatglm4 import predict_no_ui_long_connection as chatglm4_noui
-from .bridge_chatglm4 import predict as chatglm4_ui
-
 from .bridge_qianfan import predict_no_ui_long_connection as qianfan_noui
 from .bridge_qianfan import predict as qianfan_ui

@@ -79,7 +76,6 @@ cohere_endpoint = "https://api.cohere.ai/v1/chat"
 ollama_endpoint = "http://localhost:11434/api/chat"
 yimodel_endpoint = "https://api.lingyiwanwu.com/v1/chat/completions"
 deepseekapi_endpoint = "https://api.deepseek.com/v1/chat/completions"
-grok_model_endpoint = "https://api.x.ai/v1/chat/completions"

 if not AZURE_ENDPOINT.endswith('/'): AZURE_ENDPOINT += '/'
 azure_endpoint = AZURE_ENDPOINT + f'openai/deployments/{AZURE_ENGINE}/chat/completions?api-version=2023-05-15'
@@ -101,7 +97,6 @@ if cohere_endpoint in API_URL_REDIRECT: cohere_endpoint = API_URL_REDIRECT[coher
 if ollama_endpoint in API_URL_REDIRECT: ollama_endpoint = API_URL_REDIRECT[ollama_endpoint]
 if yimodel_endpoint in API_URL_REDIRECT: yimodel_endpoint = API_URL_REDIRECT[yimodel_endpoint]
 if deepseekapi_endpoint in API_URL_REDIRECT: deepseekapi_endpoint = API_URL_REDIRECT[deepseekapi_endpoint]
-if grok_model_endpoint in API_URL_REDIRECT: grok_model_endpoint = API_URL_REDIRECT[grok_model_endpoint]

 # 获取tokenizer
 tokenizer_gpt35 = LazyloadTiktoken("gpt-3.5-turbo")
@@ -217,16 +212,6 @@ model_info = {
        "token_cnt": get_token_num_gpt4,
    },

-    "chatgpt-4o-latest": {
-        "fn_with_ui": chatgpt_ui,
-        "fn_without_ui": chatgpt_noui,
-        "endpoint": openai_endpoint,
-        "has_multimodal_capacity": True,
-        "max_token": 128000,
-        "tokenizer": tokenizer_gpt4,
-        "token_cnt": get_token_num_gpt4,
-    },
-
    "gpt-4o-2024-05-13": {
        "fn_with_ui": chatgpt_ui,
        "fn_without_ui": chatgpt_noui,
@@ -419,7 +404,6 @@ model_info = {
        "token_cnt": get_token_num_gpt4,
    },

-    # ChatGLM本地模型
    # 将 chatglm 直接对齐到 chatglm2
    "chatglm": {
        "fn_with_ui": chatglm_ui,
@@ -445,14 +429,6 @@ model_info = {
        "tokenizer": tokenizer_gpt35,
        "token_cnt": get_token_num_gpt35,
    },
-    "chatglm4": {
-        "fn_with_ui": chatglm4_ui,
-        "fn_without_ui": chatglm4_noui,
-        "endpoint": None,
-        "max_token": 8192,
-        "tokenizer": tokenizer_gpt35,
-        "token_cnt": get_token_num_gpt35,
-    },
    "qianfan": {
        "fn_with_ui": qianfan_ui,
        "fn_without_ui": qianfan_noui,
@@ -900,31 +876,6 @@ if any(item in yi_models for item in AVAIL_LLM_MODELS):
        })
    except:
        logger.error(trimmed_format_exc())
-
-
-# -=-=-=-=-=-=- Grok model from x.ai -=-=-=-=-=-=-
-grok_models = ["grok-beta"]
-if any(item in grok_models for item in AVAIL_LLM_MODELS):
-    try:
-        grok_beta_128k_noui, grok_beta_128k_ui = get_predict_function(
-            api_key_conf_name="GROK_API_KEY", max_output_token=8192, disable_proxy=False
-            )
-        
-        model_info.update({
-            "grok-beta": {
-                "fn_with_ui": grok_beta_128k_ui,
-                "fn_without_ui": grok_beta_128k_noui,
-                "can_multi_thread": True,  
-                "endpoint": grok_model_endpoint,
-                "max_token": 128000,
-                "tokenizer": tokenizer_gpt35,
-                "token_cnt": get_token_num_gpt35,
-            },
-            
-        })
-    except:
-        logger.error(trimmed_format_exc())
-
 # -=-=-=-=-=-=- 讯飞星火认知大模型 -=-=-=-=-=-=-
 if "spark" in AVAIL_LLM_MODELS:
    try:
--- a/request_llms/bridge_chatglm3.py
+++ b/request_llms/bridge_chatglm3.py
@@ -23,33 +23,39 @@ class GetGLM3Handle(LocalLLMHandle):
        import os
        import platform

-        LOCAL_MODEL_PATH, LOCAL_MODEL_QUANT, device = get_conf("CHATGLM_LOCAL_MODEL_PATH", "LOCAL_MODEL_QUANT", "LOCAL_MODEL_DEVICE")
-        model_path = LOCAL_MODEL_PATH
+        LOCAL_MODEL_QUANT, device = get_conf("LOCAL_MODEL_QUANT", "LOCAL_MODEL_DEVICE")
+        _model_name_ = "THUDM/chatglm3-6b"
+        # if LOCAL_MODEL_QUANT == "INT4":  # INT4
+        #     _model_name_ = "THUDM/chatglm3-6b-int4"
+        # elif LOCAL_MODEL_QUANT == "INT8":  # INT8
+        #     _model_name_ = "THUDM/chatglm3-6b-int8"
+        # else:
+        #     _model_name_ = "THUDM/chatglm3-6b"  # FP16
        with ProxyNetworkActivate("Download_LLM"):
            chatglm_tokenizer = AutoTokenizer.from_pretrained(
-                model_path, trust_remote_code=True
+                _model_name_, trust_remote_code=True
            )
            if device == "cpu":
                chatglm_model = AutoModel.from_pretrained(
-                    model_path,
+                    _model_name_,
                    trust_remote_code=True,
                    device="cpu",
                ).float()
            elif LOCAL_MODEL_QUANT == "INT4":  # INT4
                chatglm_model = AutoModel.from_pretrained(
-                    pretrained_model_name_or_path=model_path,
+                    pretrained_model_name_or_path=_model_name_,
                    trust_remote_code=True,
                    quantization_config=BitsAndBytesConfig(load_in_4bit=True),
                )
            elif LOCAL_MODEL_QUANT == "INT8":  # INT8
                chatglm_model = AutoModel.from_pretrained(
-                    pretrained_model_name_or_path=model_path,
+                    pretrained_model_name_or_path=_model_name_,
                    trust_remote_code=True,
                    quantization_config=BitsAndBytesConfig(load_in_8bit=True),
                )
            else:
                chatglm_model = AutoModel.from_pretrained(
-                    pretrained_model_name_or_path=model_path,
+                    pretrained_model_name_or_path=_model_name_,
                    trust_remote_code=True,
                    device="cuda",
                )
--- a/request_llms/bridge_chatglm4.py
+++ b/request_llms/bridge_chatglm4.py
@@ -1,81 +0,0 @@
-model_name = "ChatGLM4"
-cmd_to_install = """
-`pip install -r request_llms/requirements_chatglm4.txt`
-`pip install modelscope`
-`modelscope download --model ZhipuAI/glm-4-9b-chat --local_dir ./THUDM/glm-4-9b-chat`
-"""
-
-
-from toolbox import get_conf, ProxyNetworkActivate
-from .local_llm_class import LocalLLMHandle, get_local_llm_predict_fns
-
-
-# ------------------------------------------------------------------------------------------------------------------------
-# 🔌💻 Local Model
-# ------------------------------------------------------------------------------------------------------------------------
-class GetGLM4Handle(LocalLLMHandle):
-
-    def load_model_info(self):
-        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
-        self.model_name = model_name
-        self.cmd_to_install = cmd_to_install
-
-    def load_model_and_tokenizer(self):
-        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
-        import torch
-        from transformers import AutoModel, AutoModelForCausalLM, AutoTokenizer
-        import os
-
-        LOCAL_MODEL_PATH, device = get_conf("CHATGLM_LOCAL_MODEL_PATH", "LOCAL_MODEL_DEVICE")
-        model_path = LOCAL_MODEL_PATH
-        chatglm_tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
-        chatglm_model = AutoModelForCausalLM.from_pretrained(
-            model_path,
-            torch_dtype=torch.bfloat16,
-            low_cpu_mem_usage=True,
-            trust_remote_code=True,
-            device=device
-        ).eval().to(device)
-        self._model = chatglm_model
-        self._tokenizer = chatglm_tokenizer
-        return self._model, self._tokenizer
-
-
-    def llm_stream_generator(self, **kwargs):
-        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
-        def adaptor(kwargs):
-            query = kwargs["query"]
-            max_length = kwargs["max_length"]
-            top_p = kwargs["top_p"]
-            temperature = kwargs["temperature"]
-            history = kwargs["history"]
-            return query, max_length, top_p, temperature, history
-
-        query, max_length, top_p, temperature, history = adaptor(kwargs)
-        inputs = self._tokenizer.apply_chat_template([{"role": "user", "content": query}],
-                                       add_generation_prompt=True,
-                                       tokenize=True,
-                                       return_tensors="pt",
-                                       return_dict=True
-                                       ).to(self._model.device)
-        gen_kwargs = {"max_length": max_length, "do_sample": True, "top_k": top_p}
-
-        outputs = self._model.generate(**inputs, **gen_kwargs)
-        outputs = outputs[:, inputs['input_ids'].shape[1]:]
-        response = self._tokenizer.decode(outputs[0], skip_special_tokens=True)
-        yield response
-
-    def try_to_import_special_deps(self, **kwargs):
-        # import something that will raise error if the user does not install requirement_*.txt
-        # 🏃‍♂️🏃‍♂️🏃‍♂️ 主进程执行
-        import importlib
-
-        # importlib.import_module('modelscope')
-
-
-# ------------------------------------------------------------------------------------------------------------------------
-# 🔌💻 GPT-Academic Interface
-# ------------------------------------------------------------------------------------------------------------------------
-predict_no_ui_long_connection, predict = get_local_llm_predict_fns(
-    GetGLM4Handle, model_name, history_format="chatglm3"
-)
--- a/request_llms/bridge_chatgpt.py
+++ b/request_llms/bridge_chatgpt.py
@@ -341,7 +341,7 @@ def predict(inputs:str, llm_kwargs:dict, plugin_kwargs:dict, chatbot:ChatBotWith
                    # 前者是API2D的结束条件，后者是OPENAI的结束条件
                    if ('data: [DONE]' in chunk_decoded) or (len(chunkjson['choices'][0]["delta"]) == 0):
                        # 判定为数据流的结束，gpt_replying_buffer也写完了
-                        log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=gpt_replying_buffer)
+                        log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=gpt_replying_buffer, user_name=chatbot.get_user())
                        break
                    # 处理数据流的主体
                    status_text = f"finish_reason: {chunkjson['choices'][0].get('finish_reason', 'null')}"
@@ -375,7 +375,7 @@ def handle_o1_model_special(response, inputs, llm_kwargs, chatbot, history):
    try:
        chunkjson = json.loads(response.content.decode())
        gpt_replying_buffer = chunkjson['choices'][0]["message"]["content"]
-        log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=gpt_replying_buffer)
+        log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=gpt_replying_buffer, user_name=chatbot.get_user())
        history[-1] = gpt_replying_buffer
        chatbot[-1] = (history[-2], history[-1])
        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
--- a/request_llms/bridge_chatgpt_vision.py
+++ b/request_llms/bridge_chatgpt_vision.py
@@ -184,7 +184,7 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
                        # 判定为数据流的结束，gpt_replying_buffer也写完了
                        lastmsg = chatbot[-1][-1] + f"\n\n\n\n「{llm_kwargs['llm_model']}调用结束，该模型不具备上下文对话能力，如需追问，请及时切换模型。」"
                        yield from update_ui_lastest_msg(lastmsg, chatbot, history, delay=1)
-                        log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=gpt_replying_buffer)
+                        log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=gpt_replying_buffer, user_name=chatbot.get_user())
                        break
                    # 处理数据流的主体
                    status_text = f"finish_reason: {chunkjson['choices'][0].get('finish_reason', 'null')}"
--- a/request_llms/bridge_claude.py
+++ b/request_llms/bridge_claude.py
@@ -216,7 +216,7 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
                if need_to_pass:
                    pass
                elif is_last_chunk:
-                    log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=gpt_replying_buffer)
+                    log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=gpt_replying_buffer, user_name=chatbot.get_user())
                    # logger.info(f'[response] {gpt_replying_buffer}')
                    break
                else:
--- a/request_llms/bridge_cohere.py
+++ b/request_llms/bridge_cohere.py
@@ -223,7 +223,7 @@ def predict(inputs:str, llm_kwargs:dict, plugin_kwargs:dict, chatbot:ChatBotWith
                        chatbot[-1] = (history[-2], history[-1])
                        yield from update_ui(chatbot=chatbot, history=history, msg="正常") # 刷新界面
                    if chunkjson['event_type'] == 'stream-end':
-                        log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=gpt_replying_buffer)
+                        log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=gpt_replying_buffer, user_name=chatbot.get_user())
                        history[-1] = gpt_replying_buffer
                        chatbot[-1] = (history[-2], history[-1])
                        yield from update_ui(chatbot=chatbot, history=history, msg="正常") # 刷新界面
--- a/request_llms/bridge_google_gemini.py
+++ b/request_llms/bridge_google_gemini.py
@@ -109,7 +109,7 @@ def predict(inputs:str, llm_kwargs:dict, plugin_kwargs:dict, chatbot:ChatBotWith
            gpt_replying_buffer += paraphrase['text']    # 使用 json 解析库进行处理
            chatbot[-1] = (inputs, gpt_replying_buffer)
            history[-1] = gpt_replying_buffer
-            log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=gpt_replying_buffer)
+            log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=gpt_replying_buffer, user_name=chatbot.get_user())
            yield from update_ui(chatbot=chatbot, history=history)
        if error_match:
            history = history[-2]  # 错误的不纳入对话
--- a/request_llms/bridge_llama2.py
+++ b/request_llms/bridge_llama2.py
@@ -26,7 +26,7 @@ class GetLlamaHandle(LocalLLMHandle):
        import platform
        huggingface_token, device = get_conf('HUGGINGFACE_ACCESS_TOKEN', 'LOCAL_MODEL_DEVICE')
        assert len(huggingface_token) != 0, "没有填写 HUGGINGFACE_ACCESS_TOKEN"
-        with open(os.path.expanduser('~/.cache/huggingface/token'), 'w', encoding='utf8') as f:
+        with open(os.path.expanduser('~/.cache/huggingface/token'), 'w') as f:
            f.write(huggingface_token)
        model_id = 'meta-llama/Llama-2-7b-chat-hf'
        with ProxyNetworkActivate('Download_LLM'):
--- a/request_llms/bridge_moonshot.py
+++ b/request_llms/bridge_moonshot.py
@@ -31,7 +31,7 @@ class MoonShotInit:
                    files.append(f)
                for file in files:
                    if file.split('.')[-1] in ['pdf']:
-                        with open(file, 'r', encoding='utf8') as fp:
+                        with open(file, 'r') as fp:
                            from crazy_functions.crazy_utils import read_and_clean_pdf_text
                            file_content, _ = read_and_clean_pdf_text(fp)
                        what_ask.append({"role": "system", "content": file_content})
@@ -166,7 +166,7 @@ def predict(inputs:str, llm_kwargs:dict, plugin_kwargs:dict, chatbot:ChatBotWith
            history = history[:-2]
            yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
            break
-    log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=gpt_bro_result)
+    log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=gpt_bro_result, user_name=chatbot.get_user())

 def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="", observe_window=None,
                                  console_slience=False):
--- a/request_llms/bridge_ollama.py
+++ b/request_llms/bridge_ollama.py
@@ -75,7 +75,7 @@ def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="",
            # make a POST request to the API endpoint, stream=False
            from .bridge_all import model_info
            endpoint = model_info[llm_kwargs['llm_model']]['endpoint']
-            response = requests.post(endpoint, headers=headers, proxies=None,
+            response = requests.post(endpoint, headers=headers, proxies=proxies,
                                    json=payload, stream=True, timeout=TIMEOUT_SECONDS); break
        except requests.exceptions.ReadTimeout as e:
            retry += 1
@@ -152,12 +152,10 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
    history.append(inputs); history.append("")

    retry = 0
-    if proxies is not None:
-        logger.error("Ollama不会使用代理服务器, 忽略了proxies的设置。")
    while True:
        try:
            # make a POST request to the API endpoint, stream=True
-            response = requests.post(endpoint, headers=headers, proxies=None,
+            response = requests.post(endpoint, headers=headers, proxies=proxies,
                                    json=payload, stream=True, timeout=TIMEOUT_SECONDS);break
        except:
            retry += 1
--- a/request_llms/bridge_openrouter.py
+++ b/request_llms/bridge_openrouter.py
@@ -337,7 +337,7 @@ def predict(inputs:str, llm_kwargs:dict, plugin_kwargs:dict, chatbot:ChatBotWith
                    # 前者是API2D的结束条件，后者是OPENAI的结束条件
                    if ('data: [DONE]' in chunk_decoded) or (len(chunkjson['choices'][0]["delta"]) == 0):
                        # 判定为数据流的结束，gpt_replying_buffer也写完了
-                        log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=gpt_replying_buffer)
+                        log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=gpt_replying_buffer, user_name=chatbot.get_user())
                        break
                    # 处理数据流的主体
                    status_text = f"finish_reason: {chunkjson['choices'][0].get('finish_reason', 'null')}"
@@ -371,7 +371,7 @@ def handle_o1_model_special(response, inputs, llm_kwargs, chatbot, history):
    try:
        chunkjson = json.loads(response.content.decode())
        gpt_replying_buffer = chunkjson['choices'][0]["message"]["content"]
-        log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=gpt_replying_buffer)
+        log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=gpt_replying_buffer, user_name=chatbot.get_user())
        history[-1] = gpt_replying_buffer
        chatbot[-1] = (history[-2], history[-1])
        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
--- a/request_llms/bridge_qwen.py
+++ b/request_llms/bridge_qwen.py
@@ -59,7 +59,7 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
        chatbot[-1] = (inputs, response)
        yield from update_ui(chatbot=chatbot, history=history)

-    log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=response)
+    log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=response, user_name=chatbot.get_user())
    # 总结输出
    if response == f"[Local Message] 等待{model_name}响应中 ...":
        response = f"[Local Message] {model_name}响应异常 ..."
--- a/request_llms/bridge_taichu.py
+++ b/request_llms/bridge_taichu.py
@@ -68,5 +68,5 @@ def predict(inputs:str, llm_kwargs:dict, plugin_kwargs:dict, chatbot:ChatBotWith
        chatbot[-1] = [inputs, response]
        yield from update_ui(chatbot=chatbot, history=history)
    history.extend([inputs, response])
-    log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=response)
+    log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=response, user_name=chatbot.get_user())
    yield from update_ui(chatbot=chatbot, history=history)
--- a/request_llms/bridge_zhipu.py
+++ b/request_llms/bridge_zhipu.py
@@ -97,5 +97,5 @@ def predict(inputs:str, llm_kwargs:dict, plugin_kwargs:dict, chatbot:ChatBotWith
        chatbot[-1] = [inputs, response]
        yield from update_ui(chatbot=chatbot, history=history)
    history.extend([inputs, response])
-    log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=response)
+    log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=response, user_name=chatbot.get_user())
    yield from update_ui(chatbot=chatbot, history=history)
--- a/request_llms/requirements_chatglm4.txt
+++ b/request_llms/requirements_chatglm4.txt
@@ -1,7 +0,0 @@
-protobuf
-cpm_kernels
-torch>=1.10
-transformers>=4.44
-mdtex2html
-sentencepiece
-accelerate
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,4 @@
-https://public.agent-matrix.com/publish/gradio-3.32.12-py3-none-any.whl
+https://public.agent-matrix.com/publish/gradio-3.32.10-py3-none-any.whl
 fastapi==0.110
 gradio-client==0.8
 pypdf2==2.12.1
@@ -25,7 +25,7 @@ pyautogen
 colorama
 Markdown
 pygments
-edge-tts>=7.0.0
+edge-tts
 pymupdf
 openai
 rjsmin
--- a/shared_utils/cookie_manager.py
+++ b/shared_utils/cookie_manager.py
@@ -77,28 +77,16 @@ def make_history_cache():
    # 定义 后端state（history）、前端（history_cache）、后端setter（history_cache_update）三兄弟
    import gradio as gr
    # 定义history的后端state
-    # history = gr.State([])
-    history = gr.Textbox(visible=False, elem_id="history-ng")
-    # # 定义history的一个孪生的前端存储区（隐藏）
-    # history_cache = gr.Textbox(visible=False, elem_id="history_cache")
-    # # 定义history_cache->history的更新方法（隐藏）。在触发这个按钮时，会先执行js代码更新history_cache，然后再执行python代码更新history
-    # def process_history_cache(history_cache):
-    #     return json.loads(history_cache)
-    # # 另一种更简单的setter方法
-    # history_cache_update = gr.Button("", elem_id="elem_update_history", visible=False).click(
-    #     process_history_cache, inputs=[history_cache], outputs=[history])
-    # # save history to history_cache
-    # def process_history_cache(history_cache):
-    #     return json.dumps(history_cache)
-    # # 定义history->history_cache的更新方法（隐藏）
-    # def sync_history_cache(history):
-    #     print("sync_history_cache", history)
-    #     return json.dumps(history)
-    # # history.change(sync_history_cache, inputs=[history], outputs=[history_cache])
-
-    # # history_cache_sync = gr.Button("", elem_id="elem_sync_history", visible=False).click(
-    # #     lambda history: (json.dumps(history)), inputs=[history_cache], outputs=[history])
-    return history, None, None
+    history = gr.State([])
+    # 定义history的一个孪生的前端存储区（隐藏）
+    history_cache = gr.Textbox(visible=False, elem_id="history_cache")
+    # 定义history_cache->history的更新方法（隐藏）。在触发这个按钮时，会先执行js代码更新history_cache，然后再执行python代码更新history
+    def process_history_cache(history_cache):
+        return json.loads(history_cache)
+    # 另一种更简单的setter方法
+    history_cache_update = gr.Button("", elem_id="elem_update_history", visible=False).click(
+        process_history_cache, inputs=[history_cache], outputs=[history])
+    return history, history_cache, history_cache_update



--- a/shared_utils/docker_as_service_api.py
+++ b/shared_utils/docker_as_service_api.py
@@ -1,83 +0,0 @@
-import requests
-import pickle
-import io
-import os
-from pydantic import BaseModel, Field
-from typing import Optional, Dict, Any
-from loguru import logger
-
-class DockerServiceApiComModel(BaseModel):
-    client_command: Optional[str] = Field(default=None, title="Client command", description="The command to be executed on the client side")
-    client_file_attach: Optional[dict] = Field(default=None, title="Client file attach", description="The file to be attached to the client side")
-    server_message: Optional[Any] = Field(default=None, title="Server standard error", description="The standard error from the server side")
-    server_std_err: Optional[str] = Field(default=None, title="Server standard error", description="The standard error from the server side")
-    server_std_out: Optional[str] = Field(default=None, title="Server standard output", description="The standard output from the server side")
-    server_file_attach: Optional[dict] = Field(default=None, title="Server file attach", description="The file to be attached to the server side")
-
-def process_received(received: DockerServiceApiComModel, save_file_dir="./daas_output", output_manifest=None):
-    # Process the received data
-    if received.server_message:
-        try:
-            output_manifest['server_message'] += received.server_message
-        except:
-            output_manifest['server_message'] = received.server_message
-    if received.server_std_err:
-        output_manifest['server_std_err'] += received.server_std_err
-    if received.server_std_out:
-        output_manifest['server_std_out'] += received.server_std_out
-    if received.server_file_attach:
-        # print(f"Recv file attach: {received.server_file_attach}")
-        for file_name, file_content in received.server_file_attach.items():
-            new_fp = os.path.join(save_file_dir, file_name)
-            new_fp_dir = os.path.dirname(new_fp)
-            if not os.path.exists(new_fp_dir):
-                os.makedirs(new_fp_dir, exist_ok=True)
-            with open(new_fp, 'wb') as f:
-                f.write(file_content)
-            output_manifest['server_file_attach'].append(new_fp)
-    return output_manifest
-
-def stream_daas(docker_service_api_com_model, server_url, save_file_dir):
-    # Prepare the file
-    # Pickle the object
-    pickled_data = pickle.dumps(docker_service_api_com_model)
-
-    # Create a file-like object from the pickled data
-    file_obj = io.BytesIO(pickled_data)
-
-    # Prepare the file for sending
-    files = {'file': ('docker_service_api_com_model.pkl', file_obj, 'application/octet-stream')}
-
-    # Send the POST request
-    response = requests.post(server_url, files=files, stream=True)
-
-    max_full_package_size = 1024 * 1024 * 1024 * 1  # 1 GB
-
-    received_output_manifest = {}
-    received_output_manifest['server_message'] = ""
-    received_output_manifest['server_std_err'] = ""
-    received_output_manifest['server_std_out'] = ""
-    received_output_manifest['server_file_attach'] = []
-
-    # Check if the request was successful
-    if response.status_code == 200:
-        # Process the streaming response
-        chunk_buf = None
-        for chunk in response.iter_content(max_full_package_size):
-            if chunk:
-                if chunk_buf is None: chunk_buf = chunk
-                else: chunk_buf += chunk
-
-                try:
-                    received = pickle.loads(chunk_buf)
-                    chunk_buf = None
-                    received_output_manifest = process_received(received, save_file_dir, output_manifest = received_output_manifest)
-                    yield received_output_manifest
-                except Exception as e:
-                    # logger.error(f"pickle data was truncated, but don't worry, we will continue to receive the rest of the data.")
-                    continue
-
-    else:
-        logger.error(f"Error: Received status code {response.status_code}, response.text: {response.text}")
-
-    return received_output_manifest
--- a/shared_utils/key_pattern_manager.py
+++ b/shared_utils/key_pattern_manager.py
@@ -78,8 +78,7 @@ def select_api_key(keys, llm_model):
    avail_key_list = []
    key_list = keys.split(',')

-    if llm_model.startswith('gpt-') or llm_model.startswith('chatgpt-') or \
-       llm_model.startswith('one-api-') or llm_model.startswith('o1-'):
+    if llm_model.startswith('gpt-') or llm_model.startswith('one-api-') or llm_model.startswith('o1-'):
        for k in key_list:
            if is_openai_api_key(k): avail_key_list.append(k)

--- a/tests/test_bilibili_down.py
+++ b/tests/test_bilibili_down.py
@@ -1,15 +0,0 @@
-"""
-对项目中的各个插件进行测试。运行方法：直接运行 python tests/test_plugins.py
-"""
-
-import init_test
-import os, sys
-
-if __name__ == "__main__":
-    from experimental_mods.get_bilibili_resource import download_bilibili
-    download_bilibili("BV1LSSHYXEtv", only_audio=True, user_name="test")
-
-# if __name__ == "__main__":
-#     from test_utils import plugin_test
-
-#     plugin_test(plugin='crazy_functions.VideoResource_GPT->视频任务', main_input="帮我找到《天文馆的猫》，歌手泠鸢")
--- a/tests/test_latex_auto_correct.py
+++ b/tests/test_latex_auto_correct.py
@@ -19,8 +19,4 @@ if __name__ == "__main__":
    plugin_test = importlib.import_module('test_utils').plugin_test


-    # plugin_test(plugin='crazy_functions.Latex_Function->Latex翻译中文并重新编译PDF', main_input="2203.01927")
-    # plugin_test(plugin='crazy_functions.Latex_Function->Latex翻译中文并重新编译PDF', main_input="gpt_log/arxiv_cache/2203.01927/workfolder")
-    # plugin_test(plugin='crazy_functions.Latex_Function->Latex翻译中文并重新编译PDF', main_input="2410.05779")
-    plugin_test(plugin='crazy_functions.Latex_Function->Latex翻译中文并重新编译PDF', main_input="gpt_log/default_user/workfolder")
-
+    plugin_test(plugin='crazy_functions.Latex_Function->Latex翻译中文并重新编译PDF', main_input="2203.01927")
--- a/tests/test_markdown.py
+++ b/tests/test_markdown.py
@@ -29,18 +29,8 @@ graph TD
    E --> B
    D --> F[Save Image and Code]
    F --> B
-
-
-
 ```

-<details>
-<summary><b>My section header in bold</b></summary>
-
-Any folded content here. It requires an empty line just above it.
-
-</details>
-
 """
 def validate_path():
    import os, sys
@@ -54,8 +44,8 @@ def validate_path():
 validate_path()  # validate path so you can run from base directory
 from toolbox import markdown_convertion
 from shared_utils.advanced_markdown_format import markdown_convertion_for_file
-# with open("gpt_log/default_user/shared/2024-04-22-01-27-43.zip.extract/translated_markdown.md", "r", encoding="utf-8") as f:
-    # md = f.read()
+with open("gpt_log/default_user/shared/2024-04-22-01-27-43.zip.extract/translated_markdown.md", "r", encoding="utf-8") as f:
+    md = f.read()
 html = markdown_convertion_for_file(md)
 # print(html)
 with open("test.html", "w", encoding="utf-8") as f:
--- a/tests/test_media.py
+++ b/tests/test_media.py
@@ -1,67 +0,0 @@
-"""
-对项目中的各个插件进行测试。运行方法：直接运行 python tests/test_plugins.py
-"""
-
-import init_test
-import os, sys
-
-
-if __name__ == "__main__":
-    from test_utils import plugin_test
-
-    plugin_test(plugin='crazy_functions.VideoResource_GPT->多媒体任务', main_input="我想找一首歌，里面有句歌词是“turn your face towards the sun”")
-
-    # plugin_test(plugin='crazy_functions.Internet_GPT->连接网络回答问题', main_input="谁是应急食品？")
-
-    # plugin_test(plugin='crazy_functions.函数动态生成->函数动态生成', main_input='交换图像的蓝色通道和红色通道', advanced_arg={"file_path_arg": "./build/ants.jpg"})
-
-    # plugin_test(plugin='crazy_functions.Latex_Function->Latex翻译中文并重新编译PDF', main_input="2307.07522")
-
-    # plugin_test(plugin='crazy_functions.PDF_Translate->批量翻译PDF文档', main_input='build/pdf/t1.pdf')
-
-    # plugin_test(
-    #     plugin="crazy_functions.Latex_Function->Latex翻译中文并重新编译PDF",
-    #     main_input="G:/SEAFILE_LOCAL/50503047/我的资料库/学位/paperlatex/aaai/Fu_8368_with_appendix",
-    # )
-
-    # plugin_test(plugin='crazy_functions.虚空终端->虚空终端', main_input='修改api-key为sk-jhoejriotherjep')
-
-    # plugin_test(plugin='crazy_functions.批量翻译PDF文档_NOUGAT->批量翻译PDF文档', main_input='crazy_functions/test_project/pdf_and_word/aaai.pdf')
-
-    # plugin_test(plugin='crazy_functions.虚空终端->虚空终端', main_input='调用插件，对C:/Users/fuqingxu/Desktop/旧文件/gpt/chatgpt_academic/crazy_functions/latex_fns中的python文件进行解析')
-
-    # plugin_test(plugin='crazy_functions.命令行助手->命令行助手', main_input='查看当前的docker容器列表')
-
-    # plugin_test(plugin='crazy_functions.SourceCode_Analyse->解析一个Python项目', main_input="crazy_functions/test_project/python/dqn")
-
-    # plugin_test(plugin='crazy_functions.SourceCode_Analyse->解析一个C项目', main_input="crazy_functions/test_project/cpp/cppipc")
-
-    # plugin_test(plugin='crazy_functions.Latex_Project_Polish->Latex英文润色', main_input="crazy_functions/test_project/latex/attention")
-
-    # plugin_test(plugin='crazy_functions.Markdown_Translate->Markdown中译英', main_input="README.md")
-
-    # plugin_test(plugin='crazy_functions.PDF_Translate->批量翻译PDF文档', main_input='crazy_functions/test_project/pdf_and_word/aaai.pdf')
-
-    # plugin_test(plugin='crazy_functions.谷歌检索小助手->谷歌检索小助手', main_input="https://scholar.google.com/scholar?hl=en&as_sdt=0%2C5&q=auto+reinforcement+learning&btnG=")
-
-    # plugin_test(plugin='crazy_functions.总结word文档->总结word文档', main_input="crazy_functions/test_project/pdf_and_word")
-
-    # plugin_test(plugin='crazy_functions.下载arxiv论文翻译摘要->下载arxiv论文并翻译摘要', main_input="1812.10695")
-
-    # plugin_test(plugin='crazy_functions.联网的ChatGPT->连接网络回答问题', main_input="谁是应急食品？")
-
-    # plugin_test(plugin='crazy_functions.解析JupyterNotebook->解析ipynb文件', main_input="crazy_functions/test_samples")
-
-    # plugin_test(plugin='crazy_functions.数学动画生成manim->动画生成', main_input="A ball split into 2, and then split into 4, and finally split into 8.")
-
-    # for lang in ["English", "French", "Japanese", "Korean", "Russian", "Italian", "German", "Portuguese", "Arabic"]:
-    #     plugin_test(plugin='crazy_functions.Markdown_Translate->Markdown翻译指定语言', main_input="README.md", advanced_arg={"advanced_arg": lang})
-
-    # plugin_test(plugin='crazy_functions.知识库文件注入->知识库文件注入', main_input="./")
-
-    # plugin_test(plugin='crazy_functions.知识库文件注入->读取知识库作答', main_input="What is the installation method？")
-
-    # plugin_test(plugin='crazy_functions.知识库文件注入->读取知识库作答', main_input="远程云服务器部署？")
-
-    # plugin_test(plugin='crazy_functions.Latex_Function->Latex翻译中文并重新编译PDF', main_input="2210.03629")
-
--- a/tests/test_plugins.py
+++ b/tests/test_plugins.py
@@ -36,7 +36,7 @@ if __name__ == "__main__":

    # plugin_test(plugin='crazy_functions.SourceCode_Analyse->解析一个C项目', main_input="crazy_functions/test_project/cpp/cppipc")

-    # plugin_test(plugin='crazy_functions.Latex_Project_Polish->Latex英文润色', main_input="crazy_functions/test_project/latex/attention")
+    # plugin_test(plugin='crazy_functions.Latex全文润色->Latex英文润色', main_input="crazy_functions/test_project/latex/attention")

    # plugin_test(plugin='crazy_functions.Markdown_Translate->Markdown中译英', main_input="README.md")

@@ -65,3 +65,8 @@ if __name__ == "__main__":

    # plugin_test(plugin='crazy_functions.Latex_Function->Latex翻译中文并重新编译PDF', main_input="2210.03629")

+    # advanced_arg = {"advanced_arg":"--llm_to_learn=gpt-3.5-turbo --prompt_prefix='根据下面的服装类型提示，想象一个穿着者，对这个人外貌、身处的环境、内心世界、人设进行描写。要求：100字以内，用第二人称。' --system_prompt=''" }
+    # plugin_test(plugin='crazy_functions.chatglm微调工具->微调数据集生成', main_input='build/dev.json', advanced_arg=advanced_arg)
+
+    # advanced_arg = {"advanced_arg":"--pre_seq_len=128 --learning_rate=2e-2 --num_gpus=1 --json_dataset='t_code.json' --ptuning_directory='/home/hmp/ChatGLM2-6B/ptuning'     " }
+    # plugin_test(plugin='crazy_functions.chatglm微调工具->启动微调', main_input='build/dev.json', advanced_arg=advanced_arg)
--- a/tests/test_tts.py
+++ b/tests/test_tts.py
@@ -1,33 +0,0 @@
-import edge_tts
-import os
-import httpx
-from toolbox import get_conf
-
-
-async def test_tts():    
-    async with httpx.AsyncClient() as client:
-        try:
-            # Forward the request to the target service
-            import tempfile
-            import edge_tts
-            import wave
-            import uuid
-            from pydub import AudioSegment
-            voice = get_conf("EDGE_TTS_VOICE")
-            tts = edge_tts.Communicate(text="测试", voice=voice)
-            temp_folder = tempfile.gettempdir()
-            temp_file_name = str(uuid.uuid4().hex)
-            temp_file = os.path.join(temp_folder, f'{temp_file_name}.mp3')
-            await tts.save(temp_file)
-            try:
-                mp3_audio = AudioSegment.from_file(temp_file, format="mp3")
-                mp3_audio.export(temp_file, format="wav")
-                with open(temp_file, 'rb') as wav_file: t = wav_file.read()
-            except:
-                raise RuntimeError("ffmpeg未安装，无法处理EdgeTTS音频。安装方法见`https://github.com/jiaaro/pydub#getting-ffmpeg-set-up`")
-        except httpx.RequestError as e:
-            raise RuntimeError(f"请求失败: {e}")
-        
-if __name__ == "__main__":
-    import asyncio
-    asyncio.run(test_tts())
--- a/themes/common.css
+++ b/themes/common.css
@@ -270,9 +270,4 @@
 }
 #gpt-submit-row #gpt-submit-dropdown > *:hover {
    cursor: context-menu;
-}
-
-.tooltip.svelte-p2nen8.svelte-p2nen8 {
-    box-shadow: 10px 10px 15px rgba(0, 0, 0, 0.5);
-    left: 10px;
 }
--- a/themes/common.js
+++ b/themes/common.js
@@ -318,7 +318,7 @@ function addCopyButton(botElement, index, is_last_in_arr) {
        }
    });

-    if (enable_tts) {
+    if (enable_tts){
        var audioButton = document.createElement('button');
        audioButton.classList.add('audio-toggle-btn');
        audioButton.innerHTML = audioIcon;
@@ -346,7 +346,7 @@ function addCopyButton(botElement, index, is_last_in_arr) {
    var messageBtnColumn = document.createElement('div');
    messageBtnColumn.classList.add('message-btn-row');
    messageBtnColumn.appendChild(copyButton);
-    if (enable_tts) {
+    if (enable_tts){
        messageBtnColumn.appendChild(audioButton);
    }
    botElement.appendChild(messageBtnColumn);
@@ -391,8 +391,6 @@ function chatbotContentChanged(attempt = 1, force = false) {

                // Now pass both the message element and the is_last_in_arr boolean to addCopyButton
                addCopyButton(message, index, is_last_in_arr);
-
-                save_conversation_history();
            });
            // gradioApp().querySelectorAll('#gpt-chatbot .message-wrap .message.bot').forEach(addCopyButton);
        }, i === 0 ? 0 : 200);
@@ -856,7 +854,8 @@ function limit_scroll_position() {
 // -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

 function loadLive2D() {
-    if (document.querySelector(".waifu")) {
+    if (document.querySelector(".waifu") )
+    {
        $('.waifu').show();
    } else {
        try {
@@ -923,12 +922,12 @@ function gpt_academic_gradio_saveload(
    if (save_or_load === "load") {
        let value = getCookie(cookie_key);
        if (value) {
-            // console.log('加载cookie', elem_id, value)
+            console.log('加载cookie', elem_id, value)
            push_data_to_gradio_component(value, elem_id, load_type);
        }
        else {
            if (load_default) {
-                // console.log('加载cookie的默认值', elem_id, load_default_value)
+                console.log('加载cookie的默认值', elem_id, load_default_value)
                push_data_to_gradio_component(load_default_value, elem_id, load_type);
            }
        }
@@ -938,149 +937,113 @@ function gpt_academic_gradio_saveload(
    }
 }

-function update_conversation_metadata() {
-    // Create a conversation UUID and timestamp
-    const conversationId = crypto.randomUUID();
-    const timestamp = new Date().toISOString();
-    const conversationData = {
-        id: conversationId,
-        timestamp: timestamp
-    };
-    // Save to cookie
-    setCookie("conversation_metadata", JSON.stringify(conversationData), 2);
-    // read from cookie
-    let conversation_metadata = getCookie("conversation_metadata");
-    // console.log("conversation_metadata", conversation_metadata);
-}
-
-
-// Helper function to generate conversation preview
-function generatePreview(conversation, timestamp, maxLength = 100) {
-    if (!conversation || conversation.length === 0) return "";
-    // Join all messages with dash separator
-    let preview = conversation.join("\n");
-    const readableDate = new Date(timestamp).toLocaleString();
-    preview = readableDate + "\n" + preview;
-    if (preview.length <= maxLength) return preview;
-    return preview.substring(0, maxLength) + "...";
-}
-
-async function save_conversation_history() {
-    // 505030475
-    let chatbot = await get_data_from_gradio_component('gpt-chatbot');
-    let history = await get_data_from_gradio_component('history-ng');
-    let conversation_metadata = getCookie("conversation_metadata");
-    conversation_metadata = JSON.parse(conversation_metadata);
-    // console.log("conversation_metadata", conversation_metadata);
-    let conversation = {
-        timestamp: conversation_metadata.timestamp,
-        id: conversation_metadata.id,
-        metadata: conversation_metadata,
-        conversation: chatbot,
-        history: history,
-        preview: generatePreview(JSON.parse(history), conversation_metadata.timestamp)
-    };
-
-    // Get existing conversation history from local storage
-    let conversation_history = [];
-    try {
-        const stored = localStorage.getItem('conversation_history');
-        if (stored) {
-            conversation_history = JSON.parse(stored);
-        }
-    } catch (e) {
-        // console.error('Error reading conversation history from localStorage:', e);
-    }
-
-    // Find existing conversation with same ID
-    const existingIndex = conversation_history.findIndex(c => c.id === conversation.id);
-
-    if (existingIndex >= 0) {
-        // Update existing conversation
-        conversation_history[existingIndex] = conversation;
-    } else {
-        // Add new conversation
-        conversation_history.push(conversation);
-    }
-
-    // Sort conversations by timestamp, newest first
-    conversation_history.sort((a, b) => {
-        const timeA = new Date(a.timestamp).getTime();
-        const timeB = new Date(b.timestamp).getTime();
-        return timeB - timeA;
-    });
-
-    // Save back to local storage
-    try {
-        localStorage.setItem('conversation_history', JSON.stringify(conversation_history));
-        const LOCAL_STORAGE_UPDATED = "gptac_conversation_history_updated";
-        window.dispatchEvent(
-            new CustomEvent(LOCAL_STORAGE_UPDATED, {
-                detail: conversation_history
-            })
-        );
-    } catch (e) {
-        console.error('Error saving conversation history to localStorage:', e);
-    }
-}
-
-
-function restore_chat_from_local_storage(event) {
-    let conversation = event.detail;
-    push_data_to_gradio_component(conversation.conversation, "gpt-chatbot", "obj");
-    push_data_to_gradio_component(conversation.history, "history-ng", "obj");
-    // console.log("restore_chat_from_local_storage", conversation);
-
-    // Create a conversation UUID and timestamp
-    const conversationId = conversation.id;
-    const timestamp = conversation.timestamp;
-    const conversationData = {
-        id: conversationId,
-        timestamp: timestamp
-    };
-    // Save to cookie
-    setCookie("conversation_metadata", JSON.stringify(conversationData), 2);
-    // read from cookie
-    let conversation_metadata = getCookie("conversation_metadata");
-
-}
-
-
-function clear_conversation(a, b, c) {
-    update_conversation_metadata();
-    let stopButton = document.getElementById("elem_stop");
-    stopButton.click();
-    // console.log("clear_conversation");
-    return reset_conversation(a, b);
-}
-

 function reset_conversation(a, b) {
    // console.log("js_code_reset");
    a = btoa(unescape(encodeURIComponent(JSON.stringify(a))));
    setCookie("js_previous_chat_cookie", a, 1);
-    b = btoa(unescape(encodeURIComponent(JSON.stringify(b))));
-    setCookie("js_previous_history_cookie", b, 1);
-    // gen_restore_btn();
+    gen_restore_btn();
    return [[], [], "已重置"];
 }

-
 // clear -> 将 history 缓存至 history_cache -> 点击复原 -> restore_previous_chat() -> 触发elem_update_history -> 读取 history_cache
 function restore_previous_chat() {
-    // console.log("restore_previous_chat");
+    console.log("restore_previous_chat");
    let chat = getCookie("js_previous_chat_cookie");
    chat = JSON.parse(decodeURIComponent(escape(atob(chat))));
    push_data_to_gradio_component(chat, "gpt-chatbot", "obj");
-    let history = getCookie("js_previous_history_cookie");
-    history = JSON.parse(decodeURIComponent(escape(atob(history))));
-    push_data_to_gradio_component(history, "history-ng", "obj");
-    // document.querySelector("#elem_update_history").click(); // in order to call set_history_gr_state, and send history state to server
+    document.querySelector("#elem_update_history").click(); // in order to call set_history_gr_state, and send history state to server
 }

+function gen_restore_btn() {
+
+
+    // 创建按钮元素
+    const button = document.createElement('div');
+    // const recvIcon = '<span><svg stroke="currentColor" fill="none" stroke-width="2" viewBox="0 0 24 24" stroke-linecap="round" stroke-linejoin="round" height=".8em" width=".8em" xmlns="http://www.w3.org/2000/svg"><polyline points="20 6 9 17 4 12"></polyline></svg></span>';
+    const rec_svg = '<svg t="1714361184567" style="transform:translate(1px, 2.5px)" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="4389" width="35" height="35"><path d="M320 512h384v64H320zM320 384h384v64H320zM320 640h192v64H320z" p-id="4390" fill="#ffffff"></path><path d="M863.7 544c-1.9 44-11.4 86.8-28.5 127.2-18.5 43.8-45.1 83.2-78.9 117-33.8 33.8-73.2 60.4-117 78.9C593.9 886.3 545.7 896 496 896s-97.9-9.7-143.2-28.9c-43.8-18.5-83.2-45.1-117-78.9-33.8-33.8-60.4-73.2-78.9-117C137.7 625.9 128 577.7 128 528s9.7-97.9 28.9-143.2c18.5-43.8 45.1-83.2 78.9-117s73.2-60.4 117-78.9C398.1 169.7 446.3 160 496 160s97.9 9.7 143.2 28.9c23.5 9.9 45.8 22.2 66.5 36.7l-119.7 20 9.9 59.4 161.6-27 59.4-9.9-9.9-59.4-27-161.5-59.4 9.9 19 114.2C670.3 123.8 586.4 96 496 96 257.4 96 64 289.4 64 528s193.4 432 432 432c233.2 0 423.3-184.8 431.7-416h-64z" p-id="4391" fill="#ffffff"></path></svg>'
+    const recvIcon = '<span>' + rec_svg + '</span>';
+
+    // 设置按钮的样式和属性
+    button.id = 'floatingButton';
+    button.className = 'glow';
+    button.style.textAlign = 'center';
+    button.style.position = 'fixed';
+    button.style.bottom = '10px';
+    button.style.left = '10px';
+    button.style.width = '50px';
+    button.style.height = '50px';
+    button.style.borderRadius = '50%';
+    button.style.backgroundColor = '#007bff';
+    button.style.color = 'white';
+    button.style.display = 'flex';
+    button.style.alignItems = 'center';
+    button.style.justifyContent = 'center';
+    button.style.cursor = 'pointer';
+    button.style.transition = 'all 0.3s ease';
+    button.style.boxShadow = '0 0 10px rgba(0,0,0,0.2)';
+
+    button.innerHTML = recvIcon;
+
+    // 添加发光动画的关键帧
+    const styleSheet = document.createElement('style');
+    styleSheet.id = 'floatingButtonStyle';
+    styleSheet.innerText = `
+    @keyframes glow {
+        from {
+        box-shadow: 0 0 10px rgba(0,0,0,0.2);
+        }
+        to {
+        box-shadow: 0 0 13px rgba(0,0,0,0.5);
+        }
+    }
+    #floatingButton.glow {
+        animation: glow 1s infinite alternate;
+    }
+    #floatingButton:hover {
+        transform: scale(1.2);
+        box-shadow: 0 0 20px rgba(0,0,0,0.4);
+    }
+    #floatingButton.disappearing {
+        animation: shrinkAndDisappear 0.5s forwards;
+    }
+    `;
+
+    // only add when not exist
+    if (!document.getElementById('recvButtonStyle'))
+    {
+        document.head.appendChild(styleSheet);
+    }
+
+    // 鼠标悬停和移开的事件监听器
+    button.addEventListener('mouseover', function () {
+        this.textContent = "还原\n对话";
+    });
+
+    button.addEventListener('mouseout', function () {
+        this.innerHTML = recvIcon;
+    });
+
+    // 点击事件监听器
+    button.addEventListener('click', function () {
+        // 添加一个类来触发缩小和消失的动画
+        restore_previous_chat();
+        this.classList.add('disappearing');
+        // 在动画结束后移除按钮
+        document.body.removeChild(this);
+    });
+    // only add when not exist
+    if (!document.getElementById('recvButton'))
+    {
+        document.body.appendChild(button);
+    }
+
+    // 将按钮添加到页面中
+
+}

 async function on_plugin_exe_complete(fn_name) {
-    // console.log(fn_name);
+    console.log(fn_name);
    if (fn_name === "保存当前的对话") {
        // get chat profile path
        let chatbot = await get_data_from_gradio_component('gpt-chatbot');
@@ -1099,15 +1062,15 @@ async function on_plugin_exe_complete(fn_name) {
        }
        let href = get_href(may_have_chat_profile_info);
        if (href) {
-            const cleanedHref = href.replace('file=', ''); // gpt_log/default_user/chat_history/GPT-Academic对话存档2024-04-12-00-35-06.html
-            // console.log(cleanedHref);
+            const cleanedHref = href.replace('file=', ''); // /home/fuqingxu/chatgpt_academic/gpt_log/default_user/chat_history/GPT-Academic对话存档2024-04-12-00-35-06.html
+            console.log(cleanedHref);
        }

    }
 }


-async function generate_menu(guiBase64String, btnName) {
+async function generate_menu(guiBase64String, btnName){
    // assign the button and menu data
    push_data_to_gradio_component(guiBase64String, "invisible_current_pop_up_plugin_arg", "string");
    push_data_to_gradio_component(btnName, "invisible_callback_btn_for_plugin_exe", "string");
@@ -1141,22 +1104,22 @@ async function generate_menu(guiBase64String, btnName) {
            ///////////////////////////////////////////////////////////////////////////////////////////
            ////////////////////////////////////    Textbox   ////////////////////////////////////
            ///////////////////////////////////////////////////////////////////////////////////////////
-            if (gui_args[key].type == 'string') { // PLUGIN_ARG_MENU
+            if (gui_args[key].type=='string'){ // PLUGIN_ARG_MENU
                const component_name = "plugin_arg_txt_" + text_cnt;
                push_data_to_gradio_component({
                    visible: true,
-                    label: gui_args[key].title + "(" + gui_args[key].description + ")",
+                    label: gui_args[key].title + "(" + gui_args[key].description +  ")",
                    // label: gui_args[key].title,
                    placeholder: gui_args[key].description,
                    __type__: 'update'
                }, component_name, "obj");
-                if (key === "main_input") {
+                if (key === "main_input"){
                    // 为了与旧插件兼容，生成菜单时，自动加载输入栏的值
                    let current_main_input = await get_data_from_gradio_component('user_input_main');
                    let current_main_input_2 = await get_data_from_gradio_component('user_input_float');
                    push_data_to_gradio_component(current_main_input + current_main_input_2, component_name, "obj");
                }
-                else if (key === "advanced_arg") {
+                else if (key === "advanced_arg"){
                    // 为了与旧插件兼容，生成菜单时，自动加载旧高级参数输入区的值
                    let advance_arg_input_legacy = await get_data_from_gradio_component('advance_arg_input_legacy');
                    push_data_to_gradio_component(advance_arg_input_legacy, component_name, "obj");
@@ -1171,12 +1134,12 @@ async function generate_menu(guiBase64String, btnName) {
            ///////////////////////////////////////////////////////////////////////////////////////////
            ////////////////////////////////////    Dropdown   ////////////////////////////////////
            ///////////////////////////////////////////////////////////////////////////////////////////
-            if (gui_args[key].type == 'dropdown') { // PLUGIN_ARG_MENU
+            if (gui_args[key].type=='dropdown'){ // PLUGIN_ARG_MENU
                const component_name = "plugin_arg_drop_" + dropdown_cnt;
                push_data_to_gradio_component({
                    visible: true,
                    choices: gui_args[key].options,
-                    label: gui_args[key].title + "(" + gui_args[key].description + ")",
+                    label: gui_args[key].title + "(" + gui_args[key].description +  ")",
                    // label: gui_args[key].title,
                    placeholder: gui_args[key].description,
                    __type__: 'update'
@@ -1191,7 +1154,7 @@ async function generate_menu(guiBase64String, btnName) {
    }
 }

-async function execute_current_pop_up_plugin() {
+async function execute_current_pop_up_plugin(){
    let guiBase64String = await get_data_from_gradio_component('invisible_current_pop_up_plugin_arg');
    const stringData = atob(guiBase64String);
    let guiJsonData = JSON.parse(stringData);
@@ -1207,8 +1170,8 @@ async function execute_current_pop_up_plugin() {
    let text_cnt = 0;
    for (const key in gui_args) {
        if (gui_args.hasOwnProperty(key)) {
-            if (gui_args[key].type == 'string') { // PLUGIN_ARG_MENU
-                corrisponding_elem_id = "plugin_arg_txt_" + text_cnt
+            if (gui_args[key].type=='string'){ // PLUGIN_ARG_MENU
+                corrisponding_elem_id = "plugin_arg_txt_"+text_cnt
                gui_args[key].user_confirmed_value = await get_data_from_gradio_component(corrisponding_elem_id);
                text_cnt += 1;
            }
@@ -1217,8 +1180,8 @@ async function execute_current_pop_up_plugin() {
    let dropdown_cnt = 0;
    for (const key in gui_args) {
        if (gui_args.hasOwnProperty(key)) {
-            if (gui_args[key].type == 'dropdown') { // PLUGIN_ARG_MENU
-                corrisponding_elem_id = "plugin_arg_drop_" + dropdown_cnt
+            if (gui_args[key].type=='dropdown'){ // PLUGIN_ARG_MENU
+                corrisponding_elem_id = "plugin_arg_drop_"+dropdown_cnt
                gui_args[key].user_confirmed_value = await get_data_from_gradio_component(corrisponding_elem_id);
                dropdown_cnt += 1;
            }
@@ -1237,29 +1200,29 @@ async function execute_current_pop_up_plugin() {

 }

-function hide_all_elem() {
-    // PLUGIN_ARG_MENU
-    for (text_cnt = 0; text_cnt < 8; text_cnt++) {
+function hide_all_elem(){
+     // PLUGIN_ARG_MENU
+    for (text_cnt = 0; text_cnt < 8; text_cnt++){
        push_data_to_gradio_component({
            visible: false,
            label: "",
            __type__: 'update'
-        }, "plugin_arg_txt_" + text_cnt, "obj");
-        document.getElementById("plugin_arg_txt_" + text_cnt).parentNode.parentNode.style.display = 'none';
+        }, "plugin_arg_txt_"+text_cnt, "obj");
+        document.getElementById("plugin_arg_txt_"+text_cnt).parentNode.parentNode.style.display = 'none';
    }
-    for (dropdown_cnt = 0; dropdown_cnt < 8; dropdown_cnt++) {
+    for (dropdown_cnt = 0; dropdown_cnt < 8; dropdown_cnt++){
        push_data_to_gradio_component({
            visible: false,
            choices: [],
            label: "",
            __type__: 'update'
-        }, "plugin_arg_drop_" + dropdown_cnt, "obj");
-        document.getElementById("plugin_arg_drop_" + dropdown_cnt).parentNode.style.display = 'none';
+        }, "plugin_arg_drop_"+dropdown_cnt, "obj");
+        document.getElementById("plugin_arg_drop_"+dropdown_cnt).parentNode.style.display = 'none';
    }
 }

-function close_current_pop_up_plugin() {
-    // PLUGIN_ARG_MENU
+function close_current_pop_up_plugin(){
+     // PLUGIN_ARG_MENU
    push_data_to_gradio_component({
        visible: false,
        __type__: 'update'
@@ -1270,13 +1233,15 @@ function close_current_pop_up_plugin() {

 // 生成高级插件的选择菜单
 plugin_init_info_lib = {}
-function register_plugin_init(key, base64String) {
+function register_plugin_init(key, base64String){
    // console.log('x')
    const stringData = atob(base64String);
    let guiJsonData = JSON.parse(stringData);
-    if (key in plugin_init_info_lib) {
+    if (key in plugin_init_info_lib)
+    {
    }
-    else {
+    else
+    {
        plugin_init_info_lib[key] = {};
    }
    plugin_init_info_lib[key].info = guiJsonData.Info;
@@ -1286,26 +1251,28 @@ function register_plugin_init(key, base64String) {
    plugin_init_info_lib[key].enable_advanced_arg = guiJsonData.AdvancedArgs;
    plugin_init_info_lib[key].arg_reminder = guiJsonData.ArgsReminder;
 }
-function register_advanced_plugin_init_code(key, code) {
-    if (key in plugin_init_info_lib) {
+function register_advanced_plugin_init_code(key, code){
+    if (key in plugin_init_info_lib)
+    {
    }
-    else {
+    else
+    {
        plugin_init_info_lib[key] = {};
    }
    plugin_init_info_lib[key].secondary_menu_code = code;
 }
-function run_advanced_plugin_launch_code(key) {
+function run_advanced_plugin_launch_code(key){
    // convert js code string to function
    generate_menu(plugin_init_info_lib[key].secondary_menu_code, key);
 }
-function on_flex_button_click(key) {
-    if (plugin_init_info_lib.hasOwnProperty(key) && plugin_init_info_lib[key].hasOwnProperty('secondary_menu_code')) {
+function on_flex_button_click(key){
+    if (plugin_init_info_lib.hasOwnProperty(key) && plugin_init_info_lib[key].hasOwnProperty('secondary_menu_code')){
        run_advanced_plugin_launch_code(key);
-    } else {
+    }else{
        document.getElementById("old_callback_btn_for_plugin_exe").click();
    }
 }
-async function run_dropdown_shift(dropdown) {
+async function run_dropdown_shift(dropdown){
    let key = dropdown;
    push_data_to_gradio_component({
        value: key,
@@ -1314,7 +1281,7 @@ async function run_dropdown_shift(dropdown) {
        __type__: 'update'
    }, "elem_switchy_bt", "obj");

-    if (plugin_init_info_lib[key].enable_advanced_arg) {
+    if (plugin_init_info_lib[key].enable_advanced_arg){
        push_data_to_gradio_component({
            visible: true,
            label: plugin_init_info_lib[key].label,
@@ -1336,9 +1303,9 @@ async function duplicate_in_new_window() {
    window.open(url, '_blank');
 }

-async function run_classic_plugin_via_id(plugin_elem_id) {
-    for (key in plugin_init_info_lib) {
-        if (plugin_init_info_lib[key].elem_id == plugin_elem_id) {
+async function run_classic_plugin_via_id(plugin_elem_id){
+    for (key in plugin_init_info_lib){
+        if (plugin_init_info_lib[key].elem_id == plugin_elem_id){
            // 获取按钮名称
            let current_btn_name = await get_data_from_gradio_component(plugin_elem_id);
            // 执行
@@ -1359,7 +1326,7 @@ async function call_plugin_via_name(current_btn_name) {
    hide_all_elem();
    // 为了与旧插件兼容，生成菜单时，自动加载旧高级参数输入区的值
    let advance_arg_input_legacy = await get_data_from_gradio_component('advance_arg_input_legacy');
-    if (advance_arg_input_legacy.length != 0) {
+    if (advance_arg_input_legacy.length != 0){
        gui_args["advanced_arg"] = {};
        gui_args["advanced_arg"].user_confirmed_value = advance_arg_input_legacy;
    }
@@ -1382,11 +1349,18 @@ async function multiplex_function_begin(multiplex_sel) {
        click_real_submit_btn();
        return;
    }
-
-    // do not delete `REPLACE_EXTENDED_MULTIPLEX_FUNCTIONS_HERE`! It will be read and replaced by Python code.
-    // REPLACE_EXTENDED_MULTIPLEX_FUNCTIONS_HERE
+    if (multiplex_sel === "多模型对话") {
+        let _align_name_in_crazy_function_py = "询问多个GPT模型";
+        call_plugin_via_name(_align_name_in_crazy_function_py);
+        return;
+    }
+    if (multiplex_sel === "智能召回 RAG") {
+        let _align_name_in_crazy_function_py = "Rag智能召回";
+        call_plugin_via_name(_align_name_in_crazy_function_py);
+        return;
+    }
 }
-async function run_multiplex_shift(multiplex_sel) {
+async function run_multiplex_shift(multiplex_sel){
    let key = multiplex_sel;
    if (multiplex_sel === "常规对话") {
        key = "提交";
@@ -1398,8 +1372,3 @@ async function run_multiplex_shift(multiplex_sel) {
        __type__: 'update'
    }, "elem_submit_visible", "obj");
 }
-
-
-async function persistent_cookie_init(web_cookie_cache, cookie) {
-    return [localStorage.getItem('web_cookie_cache'), cookie];
-}
--- a/themes/common.py
+++ b/themes/common.py
@@ -2,25 +2,6 @@ from functools import lru_cache
 from toolbox import get_conf
 CODE_HIGHLIGHT, ADD_WAIFU, LAYOUT = get_conf("CODE_HIGHLIGHT", "ADD_WAIFU", "LAYOUT")

-def inject_mutex_button_code(js_content):
-    from crazy_functional import get_multiplex_button_functions
-    fns = get_multiplex_button_functions()
-
-    template = """
-    if (multiplex_sel === "{x}") {
-        let _align_name_in_crazy_function_py = "{y}";
-        call_plugin_via_name(_align_name_in_crazy_function_py);
-        return;
-    }
-    """
-
-    replacement = ""
-    for fn in fns.keys():
-        if fn == "常规对话": continue
-        replacement += template.replace("{x}", fn).replace("{y}", fns[fn])
-    js_content = js_content.replace("// REPLACE_EXTENDED_MULTIPLEX_FUNCTIONS_HERE", replacement)
-    return js_content
-
 def minimize_js(common_js_path):
    try:
        import rjsmin, hashlib, glob, os
@@ -29,16 +10,14 @@ def minimize_js(common_js_path):
            os.remove(old_min_js)
        # use rjsmin to minimize `common_js_path`
        c_jsmin = rjsmin.jsmin
-        with open(common_js_path, "r", encoding='utf-8') as f:
+        with open(common_js_path, "r") as f:
            js_content = f.read()
-        if common_js_path == "themes/common.js":
-            js_content = inject_mutex_button_code(js_content)
        minimized_js_content = c_jsmin(js_content)
        # compute sha256 hash of minimized js content
        sha_hash = hashlib.sha256(minimized_js_content.encode()).hexdigest()[:8]
        minimized_js_path = common_js_path + '.min.' + sha_hash + '.js'
        # save to minimized js file
-        with open(minimized_js_path, "w", encoding='utf-8') as f:
+        with open(minimized_js_path, "w") as f:
            f.write(minimized_js_content)
        # return minimized js file path
        return minimized_js_path
--- a/themes/green.css
+++ b/themes/green.css
--- a/themes/gui_floating_menu.py
+++ b/themes/gui_floating_menu.py
@@ -1,7 +1,7 @@
 import gradio as gr

 def define_gui_floating_menu(customize_btns, functional, predefined_btns, cookies, web_cookie_cache):
-    with gr.Floating(init_x="20%", init_y="50%", visible=False, width="40%", drag="top", elem_id="f_area_input_secondary") as area_input_secondary:
+    with gr.Floating(init_x="20%", init_y="50%", visible=False, width="40%", drag="top") as area_input_secondary:
        with gr.Accordion("浮动输入区", open=True, elem_id="input-panel2"):
            with gr.Row() as row:
                row.style(equal_height=True)
@@ -17,7 +17,7 @@ def define_gui_floating_menu(customize_btns, functional, predefined_btns, cookie
                    clearBtn2 = gr.Button("清除", elem_id="elem_clear2", variant="secondary", visible=False); clearBtn2.style(size="sm")


-    with gr.Floating(init_x="20%", init_y="50%", visible=False, width="40%", drag="top", elem_id="f_area_customize") as area_customize:
+    with gr.Floating(init_x="20%", init_y="50%", visible=False, width="40%", drag="top") as area_customize:
        with gr.Accordion("自定义菜单", open=True, elem_id="edit-panel"):
            with gr.Row() as row:
                with gr.Column(scale=10):
@@ -35,9 +35,9 @@ def define_gui_floating_menu(customize_btns, functional, predefined_btns, cookie
                    # update btn
                    h = basic_fn_confirm.click(assign_btn, [web_cookie_cache, cookies, basic_btn_dropdown, basic_fn_title, basic_fn_prefix, basic_fn_suffix],
                                            [web_cookie_cache, cookies, *customize_btns.values(), *predefined_btns.values()])
-                    h.then(None, [web_cookie_cache], None, _js="""(web_cookie_cache)=>{localStorage.setItem("web_cookie_cache", web_cookie_cache);}""")
+                    h.then(None, [web_cookie_cache], None, _js="""(web_cookie_cache)=>{setCookie("web_cookie_cache", web_cookie_cache, 365);}""")
                    # clean up btn
                    h2 = basic_fn_clean.click(assign_btn, [web_cookie_cache, cookies, basic_btn_dropdown, basic_fn_title, basic_fn_prefix, basic_fn_suffix, gr.State(True)],
                                            [web_cookie_cache, cookies, *customize_btns.values(), *predefined_btns.values()])
-                    h2.then(None, [web_cookie_cache], None, _js="""(web_cookie_cache)=>{localStorage.setItem("web_cookie_cache", web_cookie_cache);}""")
+                    h2.then(None, [web_cookie_cache], None, _js="""(web_cookie_cache)=>{setCookie("web_cookie_cache", web_cookie_cache, 365);}""")
    return area_input_secondary, txt2, area_customize, submitBtn2, resetBtn2, clearBtn2, stopBtn2
--- a/themes/init.js
+++ b/themes/init.js
@@ -3,8 +3,6 @@ async function GptAcademicJavaScriptInit(dark, prompt, live2d, layout, tts) {
    audio_fn_init();
    minor_ui_adjustment();
    ButtonWithDropdown_init();
-    update_conversation_metadata();
-    window.addEventListener("gptac_restore_chat_from_local_storage", restore_chat_from_local_storage);
    
    // 加载欢迎页面
    const welcomeMessage = new WelcomeMessage();
--- a/themes/theme.py
+++ b/themes/theme.py
@@ -87,6 +87,21 @@ js_code_for_toggle_darkmode = """() => {
 }"""


+js_code_for_persistent_cookie_init = """(web_cookie_cache, cookie) => {
+    return [getCookie("web_cookie_cache"), cookie];
+}
+"""
+
+# 详见 themes/common.js
+js_code_reset = """
+(a,b,c)=>{
+    let stopButton = document.getElementById("elem_stop");
+    stopButton.click();
+    return reset_conversation(a,b);
+}
+"""
+
+
 js_code_clear = """
 (a,b)=>{
    return ["", ""];
--- a/themes/welcome.js
+++ b/themes/welcome.js
@@ -84,7 +84,7 @@ class WelcomeMessage {
        this.max_welcome_card_num = 6;
        this.card_array = [];
        this.static_welcome_message_previous = [];
-        this.reflesh_time_interval = 15 * 1000;
+        this.reflesh_time_interval = 15*1000;


        const reflesh_render_status = () => {
@@ -96,9 +96,6 @@ class WelcomeMessage {
        };
        const pageFocusHandler = new PageFocusHandler();
        pageFocusHandler.addFocusCallback(reflesh_render_status);
-
-        // call update when page size change, call this.update when page size change
-        window.addEventListener('resize', this.update.bind(this));
    }

    begin_render() {
@@ -108,7 +105,7 @@ class WelcomeMessage {
    async startRefleshCards() {
        await new Promise(r => setTimeout(r, this.reflesh_time_interval));
        await this.reflesh_cards();
-        if (this.visible) {
+        if (this.visible){
            setTimeout(() => {
                this.startRefleshCards.call(this);
            }, 1);
@@ -116,7 +113,7 @@ class WelcomeMessage {
    }

    async reflesh_cards() {
-        if (!this.visible) {
+        if (!this.visible){
            return;
        }

@@ -176,18 +173,18 @@ class WelcomeMessage {
    }

    shuffle(array) {
-        var currentIndex = array.length, randomIndex;
+        var currentIndex = array.length,  randomIndex;

        // While there remain elements to shuffle...
        while (currentIndex != 0) {

-            // Pick a remaining element...
-            randomIndex = Math.floor(Math.random() * currentIndex);
-            currentIndex--;
+          // Pick a remaining element...
+          randomIndex = Math.floor(Math.random() * currentIndex);
+          currentIndex--;

-            // And swap it with the current element.
-            [array[currentIndex], array[randomIndex]] = [
-                array[randomIndex], array[currentIndex]];
+          // And swap it with the current element.
+          [array[currentIndex], array[randomIndex]] = [
+            array[randomIndex], array[currentIndex]];
        }

        return array;
@@ -195,33 +192,23 @@ class WelcomeMessage {

    async update() {
        // console.log('update')
-        const elem_chatbot = document.getElementById('gpt-chatbot');
-        const chatbot_top = elem_chatbot.getBoundingClientRect().top;
-        const welcome_card_container = document.getElementsByClassName('welcome-card-container')[0];
-        let welcome_card_overflow = false;
-        if (welcome_card_container) {
-            const welcome_card_top = welcome_card_container.getBoundingClientRect().top;
-            if (welcome_card_top < chatbot_top) {
-                welcome_card_overflow = true;
-                // console.log("welcome_card_overflow");
-            }
-        }
        var page_width = document.documentElement.clientWidth;
        const width_to_hide_welcome = 1200;
-        if (!await this.isChatbotEmpty() || page_width < width_to_hide_welcome || welcome_card_overflow) {
+        if (!await this.isChatbotEmpty() || page_width < width_to_hide_welcome) {
            if (this.visible) {
-                console.log("remove welcome");
-                this.removeWelcome(); this.visible = false; // this two lines must always be together
+                this.removeWelcome();
+                this.visible = false;
                this.card_array = [];
                this.static_welcome_message_previous = [];
            }
            return;
        }
-        if (this.visible) {
+        if (this.visible){
            return;
        }
-        console.log("show welcome");
-        this.showWelcome(); this.visible = true; // this two lines must always be together
+        // console.log("welcome");
+        this.showWelcome();
+        this.visible = true;
        this.startRefleshCards();
    }

@@ -233,28 +220,28 @@ class WelcomeMessage {
        const title = document.createElement('div');
        title.classList.add('welcome-card-title');

-        // 创建图标
-        const svg = document.createElement('img');
-        svg.classList.add('welcome-svg');
-        svg.src = message.svg;
-        svg.style.height = '30px';
-        title.appendChild(svg);
+            // 创建图标
+            const svg = document.createElement('img');
+            svg.classList.add('welcome-svg');
+            svg.src = message.svg;
+            svg.style.height = '30px';
+            title.appendChild(svg);

-        // 创建标题
-        const text = document.createElement('a');
-        text.textContent = message.title;
-        text.classList.add('welcome-title-text');
-        text.href = message.url;
-        text.target = "_blank";
-        title.appendChild(text)
+            // 创建标题
+            const text = document.createElement('a');
+            text.textContent = message.title;
+            text.classList.add('welcome-title-text');
+            text.href = message.url;
+            text.target = "_blank";
+            title.appendChild(text)

        // 创建内容
        const content = document.createElement('div');
        content.classList.add('welcome-content');
-        const content_c = document.createElement('div');
-        content_c.classList.add('welcome-content-c');
-        content_c.textContent = message.content;
-        content.appendChild(content_c);
+            const content_c = document.createElement('div');
+            content_c.classList.add('welcome-content-c');
+            content_c.textContent = message.content;
+            content.appendChild(content_c);

        // 将标题和内容添加到卡片 div 中
        card.appendChild(title);
@@ -320,28 +307,28 @@ class WelcomeMessage {

 class PageFocusHandler {
    constructor() {
-        this.hasReturned = false;
-        this.focusCallbacks = [];
+      this.hasReturned = false;
+      this.focusCallbacks = [];

-        // Bind the focus and blur event handlers
-        window.addEventListener('visibilitychange', this.handleFocus.bind(this));
+      // Bind the focus and blur event handlers
+      window.addEventListener('visibilitychange', this.handleFocus.bind(this));
    }

    // Method to handle the focus event
    handleFocus() {
-        if (this.hasReturned) {
-            this.focusCallbacks.forEach(callback => callback());
-        }
-        this.hasReturned = true;
+      if (this.hasReturned) {
+        this.focusCallbacks.forEach(callback => callback());
+      }
+      this.hasReturned = true;
    }

    // Method to add a custom callback function
    addFocusCallback(callback) {
-        if (typeof callback === 'function') {
-            this.focusCallbacks.push(callback);
-        } else {
-            throw new Error('Callback must be a function');
-        }
+      if (typeof callback === 'function') {
+        this.focusCallbacks.push(callback);
+      } else {
+        throw new Error('Callback must be a function');
+      }
    }
 }

--- a/toolbox.py
+++ b/toolbox.py
@@ -8,7 +8,6 @@ import base64
 import gradio
 import shutil
 import glob
-import json
 import uuid
 from loguru import logger
 from functools import wraps
@@ -93,9 +92,8 @@ def ArgsGeneralWrapper(f):
    """
    def decorated(request: gradio.Request, cookies:dict, max_length:int, llm_model:str,
                  txt:str, txt2:str, top_p:float, temperature:float, chatbot:list,
-                  json_history:str, system_prompt:str, plugin_advanced_arg:dict, *args):
+                  history:list, system_prompt:str, plugin_advanced_arg:dict, *args):
        txt_passon = txt
-        history = json.loads(json_history) if json_history else []
        if txt == "" and txt2 != "": txt_passon = txt2
        # 引入一个有cookie的chatbot
        if request.username is not None:
@@ -150,11 +148,10 @@ def ArgsGeneralWrapper(f):
    return decorated


-def update_ui(chatbot:ChatBotWithCookies, history:list, msg:str="正常", **kwargs):  # 刷新界面
+def update_ui(chatbot:ChatBotWithCookies, history, msg="正常", **kwargs):  # 刷新界面
    """
    刷新用户界面
    """
-    assert isinstance(history, list), "history必须是一个list"
    assert isinstance(
        chatbot, ChatBotWithCookies
    ), "在传递chatbot的过程中不要将其丢弃。必要时, 可用clear将其清空, 然后用for+append循环重新赋值。"
@@ -178,11 +175,10 @@ def update_ui(chatbot:ChatBotWithCookies, history:list, msg:str="正常", **kwar
    else:
        chatbot_gr = chatbot

-    json_history = json.dumps(history, ensure_ascii=False)
-    yield cookies, chatbot_gr, json_history, msg
+    yield cookies, chatbot_gr, history, msg


-def update_ui_lastest_msg(lastmsg:str, chatbot:ChatBotWithCookies, history:list, delay:float=1, msg:str="正常"):  # 刷新界面
+def update_ui_lastest_msg(lastmsg:str, chatbot:ChatBotWithCookies, history:list, delay=1, msg="正常"):  # 刷新界面
    """
    刷新用户界面
    """
@@ -1033,7 +1029,7 @@ def check_repeat_upload(new_pdf_path, pdf_hash):
    # 如果所有页的内容都相同，返回 True
    return False, None

-def log_chat(llm_model: str, input_str: str, output_str: str):
+def log_chat(llm_model: str, input_str: str, output_str: str, user_name: str=default_user_name):
    try:
        if output_str and input_str and llm_model:
            uid = str(uuid.uuid4().hex)
@@ -1042,8 +1038,8 @@ def log_chat(llm_model: str, input_str: str, output_str: str):
            logger.bind(chat_msg=True).info(dedent(
            """
            ╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
-            [UID]
-            {uid}
+            [UID/USER]
+            {uid}/{user_name}
            [Model]
            {llm_model}
            [Query]
@@ -1051,6 +1047,6 @@ def log_chat(llm_model: str, input_str: str, output_str: str):
            [Response]
            {output_str}
            ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
-            """).format(uid=uid, llm_model=llm_model, input_str=input_str, output_str=output_str))
+            """).format(uid=uid, user_name=user_name, llm_model=llm_model, input_str=input_str, output_str=output_str))
    except:
        logger.error(trimmed_format_exc())
--- a/4
+++ b/4
@@ -1,5 +1,5 @@
 {
-  "version": 3.91,
+  "version": 3.90,
  "show_feature": true,
-  "new_feature": "优化前端并修复TTS的BUG <-> 添加时间线回溯功能 <-> 支持chatgpt-4o-latest <-> 增加RAG组件 <-> 升级多合一主提交键"
+  "new_feature": "增加RAG组件 <-> 升级多合一主提交键"
 }