Revert "Update README.md (#1581 )"

This reverts commit 0665eb75ed.
Update README.md (#1581 )
2025-12-06 14:36:48 +00:00 · 2024-02-26 22:53:15 +08:00 · 2024-02-26 22:52:00 +08:00 · 2024-02-25 21:13:56 +08:00 · 2024-02-25 21:13:41 +08:00 · 2024-02-23 13:28:49 +08:00
--- a/1
+++ b/1
@@ -18,7 +18,6 @@ WORKDIR /gpt

 # 安装大部分依赖，利用Docker缓存加速以后的构建 （以下三行，可以删除）
 COPY requirements.txt ./
-COPY ./docs/gradio-3.32.6-py3-none-any.whl ./docs/gradio-3.32.6-py3-none-any.whl
 RUN pip3 install -r requirements.txt


--- a/README.md
+++ b/README.md
@@ -1,8 +1,8 @@
-> **Caution**
->
-> 2023.11.12: 某些依赖包尚不兼容python 3.12，推荐python 3.11。
->
-> 2023.12.26: 安装依赖时，请选择`requirements.txt`中**指定的版本**。 安装命令：`pip install -r requirements.txt`。本项目完全开源免费，您可通过订阅[在线服务](https://github.com/binary-husky/gpt_academic/wiki/online)的方式鼓励本项目的发展。
+> [!IMPORTANT]  
+> 2024.1.18: 更新3.70版本，支持Mermaid绘图库（让大模型绘制脑图）  
+> 2024.1.17: 恭迎GLM4，全力支持Qwen、GLM、DeepseekCoder等国内中文大语言基座模型！  
+> 2024.1.17: 某些依赖包尚不兼容python 3.12，推荐python 3.11。  
+> 2024.1.17: 安装依赖时，请选择`requirements.txt`中**指定的版本**。 安装命令：`pip install -r requirements.txt`。本项目完全开源免费，您可通过订阅[在线服务](https://github.com/binary-husky/gpt_academic/wiki/online)的方式鼓励本项目的发展。

 <br>

@@ -42,13 +42,11 @@ If you like this project, please give it a Star.
 Read this in [English](docs/README.English.md) | [日本語](docs/README.Japanese.md) | [한국어](docs/README.Korean.md) | [Русский](docs/README.Russian.md) | [Français](docs/README.French.md). All translations have been provided by the project itself. To translate this project to arbitrary language with GPT, read and run [`multi_language.py`](multi_language.py) (experimental).
 <br>

-
-> 1.请注意只有 **高亮** 标识的插件（按钮）才支持读取文件，部分插件位于插件区的**下拉菜单**中。另外我们以**最高优先级**欢迎和处理任何新插件的PR。
->
-> 2.本项目中每个文件的功能都在[自译解报告](https://github.com/binary-husky/gpt_academic/wiki/GPT‐Academic项目自译解报告)`self_analysis.md`详细说明。随着版本的迭代，您也可以随时自行点击相关函数插件，调用GPT重新生成项目的自我解析报告。常见问题请查阅wiki。
+> [!NOTE]
+> 1.本项目中每个文件的功能都在[自译解报告](https://github.com/binary-husky/gpt_academic/wiki/GPT‐Academic项目自译解报告)`self_analysis.md`详细说明。随着版本的迭代，您也可以随时自行点击相关函数插件，调用GPT重新生成项目的自我解析报告。常见问题请查阅wiki。
 >    [![常规安装方法](https://img.shields.io/static/v1?label=&message=常规安装方法&color=gray)](#installation)  [![一键安装脚本](https://img.shields.io/static/v1?label=&message=一键安装脚本&color=gray)](https://github.com/binary-husky/gpt_academic/releases)  [![配置说明](https://img.shields.io/static/v1?label=&message=配置说明&color=gray)](https://github.com/binary-husky/gpt_academic/wiki/项目配置说明) [![wiki](https://img.shields.io/static/v1?label=&message=wiki&color=gray)]([https://github.com/binary-husky/gpt_academic/wiki/项目配置说明](https://github.com/binary-husky/gpt_academic/wiki))
 >
-> 3.本项目兼容并鼓励尝试国产大语言模型ChatGLM等。支持多个api-key共存，可在配置文件中填写如`API_KEY="openai-key1,openai-key2,azure-key3,api2d-key4"`。需要临时更换`API_KEY`时，在输入区输入临时的`API_KEY`然后回车键提交即可生效。
+> 2.本项目兼容并鼓励尝试国内中文大语言基座模型如通义千问，智谱GLM等。支持多个api-key共存，可在配置文件中填写如`API_KEY="openai-key1,openai-key2,azure-key3,api2d-key4"`。需要临时更换`API_KEY`时，在输入区输入临时的`API_KEY`然后回车键提交即可生效。

 <br><br>

@@ -56,7 +54,12 @@ Read this in [English](docs/README.English.md) | [日本語](docs/README.Japanes

 功能（⭐= 近期新增功能） | 描述
 --- | ---
-⭐[接入新模型](https://github.com/binary-husky/gpt_academic/wiki/%E5%A6%82%E4%BD%95%E5%88%87%E6%8D%A2%E6%A8%A1%E5%9E%8B) | 百度[千帆](https://cloud.baidu.com/doc/WENXINWORKSHOP/s/Nlks5zkzu)与文心一言, 通义千问[Qwen](https://modelscope.cn/models/qwen/Qwen-7B-Chat/summary)，上海AI-Lab[书生](https://github.com/InternLM/InternLM)，讯飞[星火](https://xinghuo.xfyun.cn/)，[LLaMa2](https://huggingface.co/meta-llama/Llama-2-7b-chat-hf)，[智谱API](https://open.bigmodel.cn/)，DALLE3, [DeepseekCoder](https://coder.deepseek.com/)
+⭐[接入新模型](https://github.com/binary-husky/gpt_academic/wiki/%E5%A6%82%E4%BD%95%E5%88%87%E6%8D%A2%E6%A8%A1%E5%9E%8B) | 百度[千帆](https://cloud.baidu.com/doc/WENXINWORKSHOP/s/Nlks5zkzu)与文心一言, 通义千问[Qwen](https://modelscope.cn/models/qwen/Qwen-7B-Chat/summary)，上海AI-Lab[书生](https://github.com/InternLM/InternLM)，讯飞[星火](https://xinghuo.xfyun.cn/)，[LLaMa2](https://huggingface.co/meta-llama/Llama-2-7b-chat-hf)，[智谱GLM4](https://open.bigmodel.cn/)，DALLE3, [DeepseekCoder](https://coder.deepseek.com/)
+⭐支持mermaid图像渲染 | 支持让GPT生成[流程图](https://www.bilibili.com/video/BV18c41147H9/)、状态转移图、甘特图、饼状图、GitGraph等等（3.7版本）
+⭐Arxiv论文精细翻译 ([Docker](https://github.com/binary-husky/gpt_academic/pkgs/container/gpt_academic_with_latex)) | [插件] 一键[以超高质量翻译arxiv论文](https://www.bilibili.com/video/BV1dz4y1v77A/)，目前最好的论文翻译工具
+⭐[实时语音对话输入](https://github.com/binary-husky/gpt_academic/blob/master/docs/use_audio.md) | [插件] 异步[监听音频](https://www.bilibili.com/video/BV1AV4y187Uy/)，自动断句，自动寻找回答时机
+⭐AutoGen多智能体插件 | [插件] 借助微软AutoGen，探索多Agent的智能涌现可能！
+⭐虚空终端插件 | [插件] 能够使用自然语言直接调度本项目其他插件
 润色、翻译、代码解释 | 一键润色、翻译、查找论文语法错误、解释代码
 [自定义快捷键](https://www.bilibili.com/video/BV14s4y1E7jN) | 支持自定义快捷键
 模块化设计 | 支持自定义强大的[插件](https://github.com/binary-husky/gpt_academic/tree/master/crazy_functions)，插件支持[热更新](https://github.com/binary-husky/gpt_academic/wiki/%E5%87%BD%E6%95%B0%E6%8F%92%E4%BB%B6%E6%8C%87%E5%8D%97)
@@ -65,22 +68,16 @@ Read this in [English](docs/README.English.md) | [日本語](docs/README.Japanes
 Latex全文[翻译](https://www.bilibili.com/video/BV1nk4y1Y7Js/)、[润色](https://www.bilibili.com/video/BV1FT411H7c5/) | [插件] 一键翻译或润色latex论文
 批量注释生成 | [插件] 一键批量生成函数注释
 Markdown[中英互译](https://www.bilibili.com/video/BV1yo4y157jV/) | [插件] 看到上面5种语言的[README](https://github.com/binary-husky/gpt_academic/blob/master/docs/README_EN.md)了吗？就是出自他的手笔
-⭐支持mermaid图像渲染 | 支持让GPT生成[流程图](https://www.bilibili.com/video/BV18c41147H9/)、状态转移图、甘特图、饼状图、GitGraph等等（3.7版本）
 [PDF论文全文翻译功能](https://www.bilibili.com/video/BV1KT411x7Wn) | [插件] PDF论文提取题目&摘要+翻译全文（多线程）
 [Arxiv小助手](https://www.bilibili.com/video/BV1LM4y1279X) | [插件] 输入arxiv文章url即可一键翻译摘要+下载PDF
 Latex论文一键校对 | [插件] 仿Grammarly对Latex文章进行语法、拼写纠错+输出对照PDF
 [谷歌学术统合小助手](https://www.bilibili.com/video/BV19L411U7ia) | [插件] 给定任意谷歌学术搜索页面URL，让gpt帮你[写relatedworks](https://www.bilibili.com/video/BV1GP411U7Az/)
 互联网信息聚合+GPT | [插件] 一键[让GPT从互联网获取信息](https://www.bilibili.com/video/BV1om4y127ck)回答问题，让信息永不过时
-⭐Arxiv论文精细翻译 ([Docker](https://github.com/binary-husky/gpt_academic/pkgs/container/gpt_academic_with_latex)) | [插件] 一键[以超高质量翻译arxiv论文](https://www.bilibili.com/video/BV1dz4y1v77A/)，目前最好的论文翻译工具
-⭐[实时语音对话输入](https://github.com/binary-husky/gpt_academic/blob/master/docs/use_audio.md) | [插件] 异步[监听音频](https://www.bilibili.com/video/BV1AV4y187Uy/)，自动断句，自动寻找回答时机
 公式/图片/表格显示 | 可以同时显示公式的[tex形式和渲染形式](https://user-images.githubusercontent.com/96192199/230598842-1d7fcddd-815d-40ee-af60-baf488a199df.png)，支持公式、代码高亮
-⭐AutoGen多智能体插件 | [插件] 借助微软AutoGen，探索多Agent的智能涌现可能！
 启动暗色[主题](https://github.com/binary-husky/gpt_academic/issues/173) | 在浏览器url后面添加```/?__theme=dark```可以切换dark主题
 [多LLM模型](https://www.bilibili.com/video/BV1wT411p7yf)支持 | 同时被GPT3.5、GPT4、[清华ChatGLM2](https://github.com/THUDM/ChatGLM2-6B)、[复旦MOSS](https://github.com/OpenLMLab/MOSS)伺候的感觉一定会很不错吧？
-⭐ChatGLM2微调模型 | 支持加载ChatGLM2微调模型，提供ChatGLM2微调辅助插件
 更多LLM模型接入，支持[huggingface部署](https://huggingface.co/spaces/qingxu98/gpt-academic) | 加入Newbing接口(新必应)，引入清华[Jittorllms](https://github.com/Jittor/JittorLLMs)支持[LLaMA](https://github.com/facebookresearch/llama)和[盘古α](https://openi.org.cn/pangu/)
 ⭐[void-terminal](https://github.com/binary-husky/void-terminal) pip包 | 脱离GUI，在Python中直接调用本项目的所有函数插件（开发中）
-⭐虚空终端插件 | [插件] 能够使用自然语言直接调度本项目其他插件
 更多新功能展示 (图像生成等) …… | 见本文档结尾处 ……
 </div>

@@ -119,6 +116,25 @@ Latex论文一键校对 | [插件] 仿Grammarly对Latex文章进行语法、拼
 <br><br>

 # Installation
+
+```mermaid
+flowchart TD
+    A{"安装方法"} --> W1("I. 🔑直接运行 (Windows, Linux or MacOS)")
+    W1 --> W11["1. Python pip包管理依赖"]
+    W1 --> W12["2. Anaconda包管理依赖（推荐⭐）"]
+
+    A --> W2["II. 🐳使用Docker (Windows, Linux or MacOS)"]
+
+    W2 --> k1["1. 部署项目全部能力的大镜像（推荐⭐）"]
+    W2 --> k2["2. 仅在线模型（GPT, GLM4等）镜像"]
+    W2 --> k3["3. 在线模型 + Latex的大镜像"]
+
+    A --> W4["IV. 🚀其他部署方法"]
+    W4 --> C1["1. Windows/MacOS 一键安装运行脚本（推荐⭐）"]
+    W4 --> C2["2. Huggingface, Sealos远程部署"]
+    W4 --> C4["3. ... 其他 ..."]
+```
+
 ### 安装方法I：直接运行 (Windows, Linux or MacOS)

 1. 下载项目
@@ -132,7 +148,7 @@ Latex论文一键校对 | [插件] 仿Grammarly对Latex文章进行语法、拼

    在`config.py`中，配置API KEY等变量。[特殊网络环境设置方法](https://github.com/binary-husky/gpt_academic/issues/1)、[Wiki-项目配置说明](https://github.com/binary-husky/gpt_academic/wiki/项目配置说明)。

-    「 程序会优先检查是否存在名为`config_private.py`的私密配置文件，并用其中的配置覆盖`config.py`的同名配置。如您能理解以上读取逻辑，我们强烈建议您在`config.py`同路径下创建一个名为`config_private.py`的新配置文件，并使用`config_private.py`配置项目，以确保更新或其他用户无法轻易查看您的私有配置 」。
+    「 程序会优先检查是否存在名为`config_private.py`的私密配置文件，并用其中的配置覆盖`config.py`的同名配置。如您能理解以上读取逻辑，我们强烈建议您在`config.py`同路径下创建一个名为`config_private.py`的新配置文件，并使用`config_private.py`配置项目，从而确保自动更新时不会丢失配置 」。

    「 支持通过`环境变量`配置项目，环境变量的书写格式参考`docker-compose.yml`文件或者我们的[Wiki页面](https://github.com/binary-husky/gpt_academic/wiki/项目配置说明)。配置读取优先级: `环境变量` > `config_private.py` > `config.py` 」。

@@ -152,10 +168,10 @@ Latex论文一键校对 | [插件] 仿Grammarly对Latex文章进行语法、拼
 <details><summary>如果需要支持清华ChatGLM2/复旦MOSS/RWKV作为后端，请点击展开此处</summary>
 <p>

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

 ```sh
-# 【可选步骤I】支持清华ChatGLM2。清华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)
+# 【可选步骤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】支持复旦MOSS
@@ -197,7 +213,7 @@ pip install peft
    docker-compose up
    ```

-1. 仅ChatGPT+文心一言+spark等在线模型（推荐大多数人选择）
+1. 仅ChatGPT + GLM4 + 文心一言+spark等在线模型（推荐大多数人选择）
 [![basic](https://github.com/binary-husky/gpt_academic/actions/workflows/build-without-local-llms.yml/badge.svg?branch=master)](https://github.com/binary-husky/gpt_academic/actions/workflows/build-without-local-llms.yml)
 [![basiclatex](https://github.com/binary-husky/gpt_academic/actions/workflows/build-with-latex.yml/badge.svg?branch=master)](https://github.com/binary-husky/gpt_academic/actions/workflows/build-with-latex.yml)
 [![basicaudio](https://github.com/binary-husky/gpt_academic/actions/workflows/build-with-audio-assistant.yml/badge.svg?branch=master)](https://github.com/binary-husky/gpt_academic/actions/workflows/build-with-audio-assistant.yml)
@@ -209,7 +225,7 @@ pip install peft

 P.S. 如果需要依赖Latex的插件功能，请见Wiki。另外，您也可以直接使用方案4或者方案0获取Latex功能。

-2. ChatGPT + ChatGLM2 + MOSS + LLAMA2 + 通义千问（需要熟悉[Nvidia Docker](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#installing-on-ubuntu-and-debian)运行时）
+2. ChatGPT + GLM3 + MOSS + LLAMA2 + 通义千问（需要熟悉[Nvidia Docker](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#installing-on-ubuntu-and-debian)运行时）
 [![chatglm](https://github.com/binary-husky/gpt_academic/actions/workflows/build-with-chatglm.yml/badge.svg?branch=master)](https://github.com/binary-husky/gpt_academic/actions/workflows/build-with-chatglm.yml)

    ``` sh
@@ -327,8 +343,8 @@ Tip：不指定文件直接点击 `载入对话历史存档` 可以查看历史h


 ### II：版本:
-
- version 3.70（todo）: 优化AutoGen插件主题并设计一系列衍生插件
+- version 3.80(TODO): 优化AutoGen插件主题并设计一系列衍生插件
+- version 3.70: 引入Mermaid绘图，实现GPT画脑图等功能   
 - version 3.60: 引入AutoGen作为新一代插件的基石
 - version 3.57: 支持GLM3，星火v3，文心一言v4，修复本地模型的并发BUG
 - version 3.56: 支持动态追加基础功能按钮，新汇报PDF汇总页面
@@ -361,6 +377,32 @@ GPT Academic开发者QQ群：`610599535`
    - 某些浏览器翻译插件干扰此软件前端的运行
    - 官方Gradio目前有很多兼容性问题，请**务必使用`requirement.txt`安装Gradio**

+```mermaid
+timeline LR
+    title GPT-Academic项目发展历程
+    section 2.x
+        1.0~2.2: 基础功能: 引入模块化函数插件: 可折叠式布局: 函数插件支持热重载
+        2.3~2.5: 增强多线程交互性: 新增PDF全文翻译功能: 新增输入区切换位置的功能: 自更新
+        2.6: 重构了插件结构: 提高了交互性: 加入更多插件
+    section 3.x
+        3.0~3.1: 对chatglm支持: 对其他小型llm支持: 支持同时问询多个gpt模型: 支持多个apikey负载均衡
+        3.2~3.3: 函数插件支持更多参数接口: 保存对话功能: 解读任意语言代码: 同时询问任意的LLM组合: 互联网信息综合功能
+        3.4: 加入arxiv论文翻译: 加入latex论文批改功能
+        3.44: 正式支持Azure: 优化界面易用性
+        3.46: 自定义ChatGLM2微调模型: 实时语音对话
+        3.49: 支持阿里达摩院通义千问: 上海AI-Lab书生: 讯飞星火: 支持百度千帆平台 & 文心一言
+        3.50: 虚空终端: 支持插件分类: 改进UI: 设计新主题
+        3.53: 动态选择不同界面主题: 提高稳定性: 解决多用户冲突问题
+        3.55: 动态代码解释器: 重构前端界面: 引入悬浮窗口与菜单栏
+        3.56: 动态追加基础功能按钮: 新汇报PDF汇总页面
+        3.57: GLM3, 星火v3: 支持文心一言v4: 修复本地模型的并发BUG
+        3.60: 引入AutoGen
+        3.70: 引入Mermaid绘图: 实现GPT画脑图等功能
+        3.80(TODO): 优化AutoGen插件主题: 设计衍生插件
+
+```
+
+
 ### III：主题
 可以通过修改`THEME`选项（config.py）变更主题
 1. `Chuanhu-Small-and-Beautiful` [网址](https://github.com/GaiZhenbiao/ChuanhuChatGPT/)
--- a/config.py
+++ b/config.py
@@ -2,8 +2,8 @@
    以下所有配置也都支持利用环境变量覆写，环境变量配置格式见docker-compose.yml。
    读取优先级：环境变量 > config_private.py > config.py
    --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-    All the following configurations also support using environment variables to override, 
-    and the environment variable configuration format can be seen in docker-compose.yml. 
+    All the following configurations also support using environment variables to override,
+    and the environment variable configuration format can be seen in docker-compose.yml.
    Configuration reading priority: environment variable > config_private.py > config.py
 """

@@ -33,7 +33,7 @@ else:
 # ------------------------------------ 以下配置可以优化体验, 但大部分场合下并不需要修改 ------------------------------------

 # 重新URL重新定向，实现更换API_URL的作用（高危设置! 常规情况下不要修改! 通过修改此设置，您将把您的API-KEY和对话隐私完全暴露给您设定的中间人！）
-# 格式: API_URL_REDIRECT = {"https://api.openai.com/v1/chat/completions": "在这里填写重定向的api.openai.com的URL"} 
+# 格式: API_URL_REDIRECT = {"https://api.openai.com/v1/chat/completions": "在这里填写重定向的api.openai.com的URL"}
 # 举例: API_URL_REDIRECT = {"https://api.openai.com/v1/chat/completions": "https://reverse-proxy-url/v1/chat/completions"}
 API_URL_REDIRECT = {}

@@ -66,7 +66,7 @@ LAYOUT = "LEFT-RIGHT"   # "LEFT-RIGHT"（左右布局） # "TOP-DOWN"（上下


 # 暗色模式 / 亮色模式
-DARK_MODE = True        
+DARK_MODE = True


 # 发送请求到OpenAI后，等待多久判定为超时
@@ -86,14 +86,14 @@ DEFAULT_FN_GROUPS = ['对话', '编程', '学术', '智能体']


 # 模型选择是 (注意: LLM_MODEL是默认选中的模型, 它*必须*被包含在AVAIL_LLM_MODELS列表中 )
-LLM_MODEL = "gpt-3.5-turbo" # 可选 ↓↓↓
-AVAIL_LLM_MODELS = ["gpt-3.5-turbo-1106","gpt-4-1106-preview","gpt-4-vision-preview",
-                    "gpt-3.5-turbo-16k", "gpt-3.5-turbo", "azure-gpt-3.5",
-                    "gpt-4", "gpt-4-32k", "azure-gpt-4", "api2d-gpt-4",
-                    "gemini-pro", "chatglm3", "moss", "claude-2"]
+LLM_MODEL = "gpt-3.5-turbo-16k" # 可选 ↓↓↓
+AVAIL_LLM_MODELS = ["gpt-4-1106-preview", "gpt-4-turbo-preview", "gpt-4-vision-preview",
+                    "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-3-turbo",
+                    "gemini-pro", "chatglm3", "claude-2"]
 # P.S. 其他可用的模型还包括 [
-# "qwen-turbo", "qwen-plus", "qwen-max"
-# "zhipuai", "qianfan", "deepseekcoder", "llama2", "qwen-local", "gpt-3.5-turbo-0613", 
+# "moss", "qwen-turbo", "qwen-plus", "qwen-max"
+# "zhipuai", "qianfan", "deepseekcoder", "llama2", "qwen-local", "gpt-3.5-turbo-0613",
 # "gpt-3.5-turbo-16k-0613",  "gpt-3.5-random", "api2d-gpt-3.5-turbo", 'api2d-gpt-3.5-turbo-16k',
 # "spark", "sparkv2", "sparkv3", "chatglm_onnx", "claude-1-100k", "claude-2", "internlm", "jittorllms_pangualpha", "jittorllms_llama"
 # ]
@@ -158,7 +158,7 @@ API_ORG = ""


 # 如果需要使用Slack Claude，使用教程详情见 request_llms/README.md
-SLACK_CLAUDE_BOT_ID = ''   
+SLACK_CLAUDE_BOT_ID = ''
 SLACK_CLAUDE_USER_TOKEN = ''


@@ -195,13 +195,24 @@ XFYUN_API_KEY = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"

 # 接入智谱大模型
 ZHIPUAI_API_KEY = ""
-ZHIPUAI_MODEL = "chatglm_turbo"
+ZHIPUAI_MODEL = "" # 此选项已废弃，不再需要填写
+
+
+# # 火山引擎YUNQUE大模型
+# YUNQUE_SECRET_KEY = ""
+# YUNQUE_ACCESS_KEY = ""
+# YUNQUE_MODEL = ""


 # Claude API KEY
 ANTHROPIC_API_KEY = ""


+# Mathpix 拥有执行PDF的OCR功能，但是需要注册账号
+MATHPIX_APPID = ""
+MATHPIX_APPKEY = ""
+
+
 # 自定义API KEY格式
 CUSTOM_API_KEY_PATTERN = ""

@@ -218,8 +229,8 @@ HUGGINGFACE_ACCESS_TOKEN = "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"
 # 获取方法：复制以下空间https://huggingface.co/spaces/qingxu98/grobid，设为public，然后GROBID_URL = "https://(你的hf用户名如qingxu98)-(你的填写的空间名如grobid).hf.space"
 GROBID_URLS = [
    "https://qingxu98-grobid.hf.space","https://qingxu98-grobid2.hf.space","https://qingxu98-grobid3.hf.space",
-    "https://qingxu98-grobid4.hf.space","https://qingxu98-grobid5.hf.space", "https://qingxu98-grobid6.hf.space", 
-    "https://qingxu98-grobid7.hf.space", "https://qingxu98-grobid8.hf.space", 
+    "https://qingxu98-grobid4.hf.space","https://qingxu98-grobid5.hf.space", "https://qingxu98-grobid6.hf.space",
+    "https://qingxu98-grobid7.hf.space", "https://qingxu98-grobid8.hf.space",
 ]


@@ -240,7 +251,7 @@ PATH_LOGGING = "gpt_log"


 # 除了连接OpenAI之外，还有哪些场合允许使用代理，请勿修改
-WHEN_TO_USE_PROXY = ["Download_LLM", "Download_Gradio_Theme", "Connect_Grobid", 
+WHEN_TO_USE_PROXY = ["Download_LLM", "Download_Gradio_Theme", "Connect_Grobid",
                     "Warmup_Modules", "Nougat_Download", "AutoGen"]


@@ -291,9 +302,8 @@ NUM_CUSTOM_BASIC_BTN = 4
 │   ├── BAIDU_CLOUD_API_KEY
 │   └── BAIDU_CLOUD_SECRET_KEY
 │
-├── "zhipuai" 智谱AI大模型chatglm_turbo
-│   ├── ZHIPUAI_API_KEY
-│   └── ZHIPUAI_MODEL
+├── "glm-4", "glm-3-turbo", "zhipuai" 智谱AI大模型
+│   └── ZHIPUAI_API_KEY
 │
 ├── "qwen-turbo" 等通义千问大模型
 │   └──  DASHSCOPE_API_KEY
@@ -305,7 +315,7 @@ NUM_CUSTOM_BASIC_BTN = 4
    ├── NEWBING_STYLE
    └── NEWBING_COOKIES

-    
+
 本地大模型示意图
 │
 ├── "chatglm3"
@@ -345,6 +355,9 @@ NUM_CUSTOM_BASIC_BTN = 4
 │   └── ALIYUN_SECRET
 │
 └── PDF文档精准解析
-    └── GROBID_URLS
+    ├── GROBID_URLS
+    ├── MATHPIX_APPID
+    └── MATHPIX_APPKEY
+

 """
--- a/core_functional.py
+++ b/core_functional.py
@@ -3,30 +3,69 @@
 # 'stop' 颜色对应 theme.py 中的 color_er
 import importlib
 from toolbox import clear_line_break
-
+from toolbox import apply_gpt_academic_string_mask_langbased
+from toolbox import build_gpt_academic_masked_string_langbased
+from textwrap import dedent

 def get_core_functions():
    return {
-        "英语学术润色": {
-            # 前缀，会被加在你的输入之前。例如，用来描述你的要求，例如翻译、解释代码、润色等等
-            "Prefix":   r"Below is a paragraph from an academic paper. Polish the writing to meet the academic style, " +
-                        r"improve the spelling, grammar, clarity, concision and overall readability. When necessary, rewrite the whole sentence. " +
-                        r"Firstly, you should provide the polished paragraph. "
-                        r"Secondly, you should list all your modification and explain the reasons to do so in markdown table." + "\n\n",
-            # 后缀，会被加在你的输入之后。例如，配合前缀可以把你的输入内容用引号圈起来
+
+        "学术语料润色": {
+            # [1*] 前缀字符串，会被加在你的输入之前。例如，用来描述你的要求，例如翻译、解释代码、润色等等。
+            #      这里填一个提示词字符串就行了，这里为了区分中英文情景搞复杂了一点
+            "Prefix":   build_gpt_academic_masked_string_langbased(
+                            text_show_english=
+                                r"Below is a paragraph from an academic paper. Polish the writing to meet the academic style, "
+                                r"improve the spelling, grammar, clarity, concision and overall readability. When necessary, rewrite the whole sentence. "
+                                r"Firstly, you should provide the polished paragraph. "
+                                r"Secondly, you should list all your modification and explain the reasons to do so in markdown table.",
+                            text_show_chinese=
+                                r"作为一名中文学术论文写作改进助理，你的任务是改进所提供文本的拼写、语法、清晰、简洁和整体可读性，"
+                                r"同时分解长句，减少重复，并提供改进建议。请先提供文本的更正版本，然后在markdown表格中列出修改的内容，并给出修改的理由:"
+                        ) + "\n\n",
+            # [2*] 后缀字符串，会被加在你的输入之后。例如，配合前缀可以把你的输入内容用引号圈起来
            "Suffix":   r"",
-            # 按钮颜色 (默认 secondary)
+            # [3] 按钮颜色 (可选参数，默认 secondary)
            "Color":    r"secondary",
-            # 按钮是否可见 (默认 True，即可见)
+            # [4] 按钮是否可见 (可选参数，默认 True，即可见)
            "Visible": True,
-            # 是否在触发时清除历史 (默认 False，即不处理之前的对话历史)
-            "AutoClearHistory": False
+            # [5] 是否在触发时清除历史 (可选参数，默认 False，即不处理之前的对话历史)
+            "AutoClearHistory": False,
+            # [6] 文本预处理 （可选参数，默认 None，举例：写个函数移除所有的换行符）
+            "PreProcess": None,
        },
-        "中文学术润色": {
-            "Prefix":   r"作为一名中文学术论文写作改进助理，你的任务是改进所提供文本的拼写、语法、清晰、简洁和整体可读性，" +
-                        r"同时分解长句，减少重复，并提供改进建议。请只提供文本的更正版本，避免包括解释。请编辑以下文本" + "\n\n",
-            "Suffix":   r"",
+        
+        
+        "总结绘制脑图": {
+            # 前缀，会被加在你的输入之前。例如，用来描述你的要求，例如翻译、解释代码、润色等等
+            "Prefix":   r"",
+            # 后缀，会被加在你的输入之后。例如，配合前缀可以把你的输入内容用引号圈起来
+            "Suffix":
+                # dedent() 函数用于去除多行字符串的缩进
+                dedent("\n"+r'''
+                    ==============================
+
+                    使用mermaid flowchart对以上文本进行总结，概括上述段落的内容以及内在逻辑关系，例如：
+
+                    以下是对以上文本的总结，以mermaid flowchart的形式展示：
+                    ```mermaid
+                    flowchart LR
+                        A["节点名1"] --> B("节点名2")
+                        B --> C{"节点名3"}
+                        C --> D["节点名4"]
+                        C --> |"箭头名1"| E["节点名5"]
+                        C --> |"箭头名2"| F["节点名6"]
+                    ```
+
+                    警告：
+                    （1）使用中文
+                    （2）节点名字使用引号包裹，如["Laptop"]
+                    （3）`|` 和 `"`之间不要存在空格
+                    （4）根据情况选择flowchart LR（从左到右）或者flowchart TD（从上到下）
+                '''),
        },
+        
+        
        "查找语法错误": {
            "Prefix":   r"Help me ensure that the grammar and the spelling is correct. "
                        r"Do not try to polish the text, if no mistake is found, tell me that this paragraph is good. "
@@ -46,42 +85,61 @@ def get_core_functions():
            "Suffix":   r"",
            "PreProcess": clear_line_break,    # 预处理：清除换行符
        },
+        
+        
        "中译英": {
            "Prefix":   r"Please translate following sentence to English:" + "\n\n",
            "Suffix":   r"",
        },
-        "学术中英互译": {
-            "Prefix":   r"I want you to act as a scientific English-Chinese translator, " +
-                        r"I will provide you with some paragraphs in one language " +
-                        r"and your task is to accurately and academically translate the paragraphs only into the other language. " +
-                        r"Do not repeat the original provided paragraphs after translation. " +
-                        r"You should use artificial intelligence tools, " +
-                        r"such as natural language processing, and rhetorical knowledge " +
-                        r"and experience about effective writing techniques to reply. " +
-                        r"I'll give you my paragraphs as follows, tell me what language it is written in, and then translate:" + "\n\n",
-            "Suffix": "",
-            "Color": "secondary",
+        
+        
+        "学术英中互译": {
+            "Prefix":   build_gpt_academic_masked_string_langbased(
+                            text_show_chinese=
+                                r"I want you to act as a scientific English-Chinese translator, "
+                                r"I will provide you with some paragraphs in one language "
+                                r"and your task is to accurately and academically translate the paragraphs only into the other language. "
+                                r"Do not repeat the original provided paragraphs after translation. "
+                                r"You should use artificial intelligence tools, "
+                                r"such as natural language processing, and rhetorical knowledge "
+                                r"and experience about effective writing techniques to reply. "
+                                r"I'll give you my paragraphs as follows, tell me what language it is written in, and then translate:",
+                            text_show_english=
+                                r"你是经验丰富的翻译，请把以下学术文章段落翻译成中文，"
+                                r"并同时充分考虑中文的语法、清晰、简洁和整体可读性，"
+                                r"必要时，你可以修改整个句子的顺序以确保翻译后的段落符合中文的语言习惯。"
+                                r"你需要翻译的文本如下："
+                        ) + "\n\n",
+            "Suffix":   r"",
        },
+        
+        
        "英译中": {
            "Prefix":   r"翻译成地道的中文：" + "\n\n",
            "Suffix":   r"",
-            "Visible": False,
+            "Visible":  False,
        },
+        
+        
        "找图片": {
-            "Prefix":   r"我需要你找一张网络图片。使用Unsplash API(https://source.unsplash.com/960x640/?<英语关键词>)获取图片URL，" +
+            "Prefix":   r"我需要你找一张网络图片。使用Unsplash API(https://source.unsplash.com/960x640/?<英语关键词>)获取图片URL，"
                        r"然后请使用Markdown格式封装，并且不要有反斜线，不要用代码块。现在，请按以下描述给我发送图片：" + "\n\n",
            "Suffix":   r"",
-            "Visible": False,
+            "Visible":  False,
        },
+        
+        
        "解释代码": {
            "Prefix":   r"请解释以下代码：" + "\n```\n",
            "Suffix":   "\n```\n",
        },
+        
+        
        "参考文献转Bib": {
-            "Prefix":   r"Here are some bibliography items, please transform them into bibtex style." +
-                        r"Note that, reference styles maybe more than one kind, you should transform each item correctly." +
-                        r"Items need to be transformed:",
-            "Visible": False,
+            "Prefix":   r"Here are some bibliography items, please transform them into bibtex style."
+                        r"Note that, reference styles maybe more than one kind, you should transform each item correctly."
+                        r"Items need to be transformed:" + "\n\n",
+            "Visible":  False,
            "Suffix":   r"",
        }
    }
@@ -98,8 +156,18 @@ def handle_core_functionality(additional_fn, inputs, history, chatbot):
        return inputs, history
    else:
        # 预制功能
-        if "PreProcess" in core_functional[additional_fn]: inputs = core_functional[additional_fn]["PreProcess"](inputs)  # 获取预处理函数（如果有的话）
-        inputs = core_functional[additional_fn]["Prefix"] + inputs + core_functional[additional_fn]["Suffix"]
+        if "PreProcess" in core_functional[additional_fn]:
+            if core_functional[additional_fn]["PreProcess"] is not None:
+                inputs = core_functional[additional_fn]["PreProcess"](inputs)  # 获取预处理函数（如果有的话）
+        # 为字符串加上上面定义的前缀和后缀。
+        inputs = apply_gpt_academic_string_mask_langbased(
+            string = core_functional[additional_fn]["Prefix"] + inputs + core_functional[additional_fn]["Suffix"],
+            lang_reference = inputs,
+        )
        if core_functional[additional_fn].get("AutoClearHistory", False):
            history = []
        return inputs, history
+
+if __name__ == "__main__":
+    t = get_core_functions()["总结绘制脑图"]
+    print(t["Prefix"] + t["Suffix"])
--- a/crazy_functional.py
+++ b/crazy_functional.py
@@ -32,115 +32,122 @@ def get_crazy_functions():
    from crazy_functions.理解PDF文档内容 import 理解PDF文档内容标准文件输入
    from crazy_functions.Latex全文润色 import Latex中文润色
    from crazy_functions.Latex全文润色 import Latex英文纠错
-    from crazy_functions.Latex全文翻译 import Latex中译英
-    from crazy_functions.Latex全文翻译 import Latex英译中
    from crazy_functions.批量Markdown翻译 import Markdown中译英
    from crazy_functions.虚空终端 import 虚空终端
-
+    from crazy_functions.生成多种Mermaid图表 import 生成多种Mermaid图表

    function_plugins = {
        "虚空终端": {
            "Group": "对话|编程|学术|智能体",
            "Color": "stop",
            "AsButton": True,
-            "Function": HotReload(虚空终端)
+            "Function": HotReload(虚空终端),
        },
        "解析整个Python项目": {
            "Group": "编程",
            "Color": "stop",
            "AsButton": True,
            "Info": "解析一个Python项目的所有源文件(.py) | 输入参数为路径",
-            "Function": HotReload(解析一个Python项目)
+            "Function": HotReload(解析一个Python项目),
        },
        "载入对话历史存档（先上传存档或输入路径）": {
            "Group": "对话",
            "Color": "stop",
            "AsButton": False,
            "Info": "载入对话历史存档 | 输入参数为路径",
-            "Function": HotReload(载入对话历史存档)
+            "Function": HotReload(载入对话历史存档),
        },
        "删除所有本地对话历史记录（谨慎操作）": {
            "Group": "对话",
            "AsButton": False,
            "Info": "删除所有本地对话历史记录，谨慎操作 | 不需要输入参数",
-            "Function": HotReload(删除所有本地对话历史记录)
+            "Function": HotReload(删除所有本地对话历史记录),
        },
        "清除所有缓存文件（谨慎操作）": {
            "Group": "对话",
            "Color": "stop",
            "AsButton": False,  # 加入下拉菜单中
            "Info": "清除所有缓存文件，谨慎操作 | 不需要输入参数",
-            "Function": HotReload(清除缓存)
+            "Function": HotReload(清除缓存),
+        },
+        "生成多种Mermaid图表(从当前对话或路径(.pdf/.md/.docx)中生产图表）": {
+            "Group": "对话",
+            "Color": "stop",
+            "AsButton": False,
+            "Info" : "基于当前对话或文件生成多种Mermaid图表,图表类型由模型判断",
+            "Function": HotReload(生成多种Mermaid图表),
+            "AdvancedArgs": True,
+            "ArgsReminder": "请输入图类型对应的数字,不输入则为模型自行判断:1-流程图,2-序列图,3-类图,4-饼图,5-甘特图,6-状态图,7-实体关系图,8-象限提示图,9-思维导图",
        },
        "批量总结Word文档": {
            "Group": "学术",
            "Color": "stop",
            "AsButton": True,
            "Info": "批量总结word文档 | 输入参数为路径",
-            "Function": HotReload(总结word文档)
+            "Function": HotReload(总结word文档),
        },
        "解析整个Matlab项目": {
            "Group": "编程",
            "Color": "stop",
            "AsButton": False,
            "Info": "解析一个Matlab项目的所有源文件(.m) | 输入参数为路径",
-            "Function": HotReload(解析一个Matlab项目)
+            "Function": HotReload(解析一个Matlab项目),
        },
        "解析整个C++项目头文件": {
            "Group": "编程",
            "Color": "stop",
            "AsButton": False,  # 加入下拉菜单中
            "Info": "解析一个C++项目的所有头文件(.h/.hpp) | 输入参数为路径",
-            "Function": HotReload(解析一个C项目的头文件)
+            "Function": HotReload(解析一个C项目的头文件),
        },
        "解析整个C++项目（.cpp/.hpp/.c/.h）": {
            "Group": "编程",
            "Color": "stop",
            "AsButton": False,  # 加入下拉菜单中
            "Info": "解析一个C++项目的所有源文件（.cpp/.hpp/.c/.h）| 输入参数为路径",
-            "Function": HotReload(解析一个C项目)
+            "Function": HotReload(解析一个C项目),
        },
        "解析整个Go项目": {
            "Group": "编程",
            "Color": "stop",
            "AsButton": False,  # 加入下拉菜单中
            "Info": "解析一个Go项目的所有源文件 | 输入参数为路径",
-            "Function": HotReload(解析一个Golang项目)
+            "Function": HotReload(解析一个Golang项目),
        },
        "解析整个Rust项目": {
            "Group": "编程",
            "Color": "stop",
            "AsButton": False,  # 加入下拉菜单中
            "Info": "解析一个Rust项目的所有源文件 | 输入参数为路径",
-            "Function": HotReload(解析一个Rust项目)
+            "Function": HotReload(解析一个Rust项目),
        },
        "解析整个Java项目": {
            "Group": "编程",
            "Color": "stop",
            "AsButton": False,  # 加入下拉菜单中
            "Info": "解析一个Java项目的所有源文件 | 输入参数为路径",
-            "Function": HotReload(解析一个Java项目)
+            "Function": HotReload(解析一个Java项目),
        },
        "解析整个前端项目（js,ts,css等）": {
            "Group": "编程",
            "Color": "stop",
            "AsButton": False,  # 加入下拉菜单中
            "Info": "解析一个前端项目的所有源文件（js,ts,css等） | 输入参数为路径",
-            "Function": HotReload(解析一个前端项目)
+            "Function": HotReload(解析一个前端项目),
        },
        "解析整个Lua项目": {
            "Group": "编程",
            "Color": "stop",
            "AsButton": False,  # 加入下拉菜单中
            "Info": "解析一个Lua项目的所有源文件 | 输入参数为路径",
-            "Function": HotReload(解析一个Lua项目)
+            "Function": HotReload(解析一个Lua项目),
        },
        "解析整个CSharp项目": {
            "Group": "编程",
            "Color": "stop",
            "AsButton": False,  # 加入下拉菜单中
            "Info": "解析一个CSharp项目的所有源文件 | 输入参数为路径",
-            "Function": HotReload(解析一个CSharp项目)
+            "Function": HotReload(解析一个CSharp项目),
        },
        "解析Jupyter Notebook文件": {
            "Group": "编程",
@@ -156,103 +163,104 @@ def get_crazy_functions():
            "Color": "stop",
            "AsButton": False,
            "Info": "读取Tex论文并写摘要 | 输入参数为路径",
-            "Function": HotReload(读文章写摘要)
+            "Function": HotReload(读文章写摘要),
        },
        "翻译README或MD": {
            "Group": "编程",
            "Color": "stop",
            "AsButton": True,
            "Info": "将Markdown翻译为中文 | 输入参数为路径或URL",
-            "Function": HotReload(Markdown英译中)
+            "Function": HotReload(Markdown英译中),
        },
        "翻译Markdown或README（支持Github链接）": {
            "Group": "编程",
            "Color": "stop",
            "AsButton": False,
            "Info": "将Markdown或README翻译为中文 | 输入参数为路径或URL",
-            "Function": HotReload(Markdown英译中)
+            "Function": HotReload(Markdown英译中),
        },
        "批量生成函数注释": {
            "Group": "编程",
            "Color": "stop",
            "AsButton": False,  # 加入下拉菜单中
            "Info": "批量生成函数的注释 | 输入参数为路径",
-            "Function": HotReload(批量生成函数注释)
+            "Function": HotReload(批量生成函数注释),
        },
        "保存当前的对话": {
            "Group": "对话",
            "AsButton": True,
            "Info": "保存当前的对话 | 不需要输入参数",
-            "Function": HotReload(对话历史存档)
+            "Function": HotReload(对话历史存档),
        },
        "[多线程Demo]解析此项目本身（源码自译解）": {
            "Group": "对话|编程",
            "AsButton": False,  # 加入下拉菜单中
            "Info": "多线程解析并翻译此项目的源码 | 不需要输入参数",
-            "Function": HotReload(解析项目本身)
+            "Function": HotReload(解析项目本身),
        },
        "历史上的今天": {
            "Group": "对话",
            "AsButton": True,
            "Info": "查看历史上的今天事件 (这是一个面向开发者的插件Demo) | 不需要输入参数",
-            "Function": HotReload(高阶功能模板函数)
+            "Function": HotReload(高阶功能模板函数),
        },
        "精准翻译PDF论文": {
            "Group": "学术",
            "Color": "stop",
-            "AsButton": True,  
+            "AsButton": True,
            "Info": "精准翻译PDF论文为中文 | 输入参数为路径",
-            "Function": HotReload(批量翻译PDF文档)
+            "Function": HotReload(批量翻译PDF文档),
        },
        "询问多个GPT模型": {
            "Group": "对话",
            "Color": "stop",
            "AsButton": True,
-            "Function": HotReload(同时问询)
+            "Function": HotReload(同时问询),
        },
        "批量总结PDF文档": {
            "Group": "学术",
            "Color": "stop",
            "AsButton": False,  # 加入下拉菜单中
            "Info": "批量总结PDF文档的内容 | 输入参数为路径",
-            "Function": HotReload(批量总结PDF文档)
+            "Function": HotReload(批量总结PDF文档),
        },
        "谷歌学术检索助手（输入谷歌学术搜索页url）": {
            "Group": "学术",
            "Color": "stop",
            "AsButton": False,  # 加入下拉菜单中
            "Info": "使用谷歌学术检索助手搜索指定URL的结果 | 输入参数为谷歌学术搜索页的URL",
-            "Function": HotReload(谷歌检索小助手)
+            "Function": HotReload(谷歌检索小助手),
        },
        "理解PDF文档内容 （模仿ChatPDF）": {
            "Group": "学术",
            "Color": "stop",
            "AsButton": False,  # 加入下拉菜单中
            "Info": "理解PDF文档的内容并进行回答 | 输入参数为路径",
-            "Function": HotReload(理解PDF文档内容标准文件输入)
+            "Function": HotReload(理解PDF文档内容标准文件输入),
        },
        "英文Latex项目全文润色（输入路径或上传压缩包）": {
            "Group": "学术",
            "Color": "stop",
            "AsButton": False,  # 加入下拉菜单中
            "Info": "对英文Latex项目全文进行润色处理 | 输入参数为路径或上传压缩包",
-            "Function": HotReload(Latex英文润色)
-        },
-        "英文Latex项目全文纠错（输入路径或上传压缩包）": {
-            "Group": "学术",
-            "Color": "stop",
-            "AsButton": False,  # 加入下拉菜单中
-            "Info": "对英文Latex项目全文进行纠错处理 | 输入参数为路径或上传压缩包",
-            "Function": HotReload(Latex英文纠错)
+            "Function": HotReload(Latex英文润色),
        },
+
        "中文Latex项目全文润色（输入路径或上传压缩包）": {
            "Group": "学术",
            "Color": "stop",
            "AsButton": False,  # 加入下拉菜单中
            "Info": "对中文Latex项目全文进行润色处理 | 输入参数为路径或上传压缩包",
-            "Function": HotReload(Latex中文润色)
+            "Function": HotReload(Latex中文润色),
        },
-
+        # 已经被新插件取代
+        # "英文Latex项目全文纠错（输入路径或上传压缩包）": {
+        #     "Group": "学术",
+        #     "Color": "stop",
+        #     "AsButton": False,  # 加入下拉菜单中
+        #     "Info": "对英文Latex项目全文进行纠错处理 | 输入参数为路径或上传压缩包",
+        #     "Function": HotReload(Latex英文纠错),
+        # },
        # 已经被新插件取代
        # "Latex项目全文中译英（输入路径或上传压缩包）": {
        #     "Group": "学术",
@@ -261,7 +269,6 @@ def get_crazy_functions():
        #     "Info": "对Latex项目全文进行中译英处理 | 输入参数为路径或上传压缩包",
        #     "Function": HotReload(Latex中译英)
        # },
-
        # 已经被新插件取代
        # "Latex项目全文英译中（输入路径或上传压缩包）": {
        #     "Group": "学术",
@@ -270,339 +277,417 @@ def get_crazy_functions():
        #     "Info": "对Latex项目全文进行英译中处理 | 输入参数为路径或上传压缩包",
        #     "Function": HotReload(Latex英译中)
        # },
-        
        "批量Markdown中译英（输入路径或上传压缩包）": {
            "Group": "编程",
            "Color": "stop",
            "AsButton": False,  # 加入下拉菜单中
            "Info": "批量将Markdown文件中文翻译为英文 | 输入参数为路径或上传压缩包",
-            "Function": HotReload(Markdown中译英)
+            "Function": HotReload(Markdown中译英),
        },
    }

    # -=--=- 尚未充分测试的实验性插件 & 需要额外依赖的插件 -=--=-
    try:
        from crazy_functions.下载arxiv论文翻译摘要 import 下载arxiv论文并翻译摘要
-        function_plugins.update({
-            "一键下载arxiv论文并翻译摘要（先在input输入编号，如1812.10695）": {
-                "Group": "学术",
-                "Color": "stop",
-                "AsButton": False,  # 加入下拉菜单中
-                # "Info": "下载arxiv论文并翻译摘要 | 输入参数为arxiv编号如1812.10695",
-                "Function": HotReload(下载arxiv论文并翻译摘要)
+
+        function_plugins.update(
+            {
+                "一键下载arxiv论文并翻译摘要（先在input输入编号，如1812.10695）": {
+                    "Group": "学术",
+                    "Color": "stop",
+                    "AsButton": False,  # 加入下拉菜单中
+                    # "Info": "下载arxiv论文并翻译摘要 | 输入参数为arxiv编号如1812.10695",
+                    "Function": HotReload(下载arxiv论文并翻译摘要),
+                }
            }
-        })
+        )
    except:
        print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")

    try:
        from crazy_functions.联网的ChatGPT import 连接网络回答问题
-        function_plugins.update({
-            "连接网络回答问题（输入问题后点击该插件，需要访问谷歌）": {
-                "Group": "对话",
-                "Color": "stop",
-                "AsButton": False,  # 加入下拉菜单中
-                # "Info": "连接网络回答问题（需要访问谷歌）| 输入参数是一个问题",
-                "Function": HotReload(连接网络回答问题)
+
+        function_plugins.update(
+            {
+                "连接网络回答问题（输入问题后点击该插件，需要访问谷歌）": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": False,  # 加入下拉菜单中
+                    # "Info": "连接网络回答问题（需要访问谷歌）| 输入参数是一个问题",
+                    "Function": HotReload(连接网络回答问题),
+                }
            }
-        })
+        )
        from crazy_functions.联网的ChatGPT_bing版 import 连接bing搜索回答问题
-        function_plugins.update({
-            "连接网络回答问题（中文Bing版，输入问题后点击该插件）": {
-                "Group": "对话",
-                "Color": "stop",
-                "AsButton": False,  # 加入下拉菜单中
-                "Info": "连接网络回答问题（需要访问中文Bing）| 输入参数是一个问题",
-                "Function": HotReload(连接bing搜索回答问题)
+
+        function_plugins.update(
+            {
+                "连接网络回答问题（中文Bing版，输入问题后点击该插件）": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": False,  # 加入下拉菜单中
+                    "Info": "连接网络回答问题（需要访问中文Bing）| 输入参数是一个问题",
+                    "Function": HotReload(连接bing搜索回答问题),
+                }
            }
-        })
+        )
    except:
        print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")

    try:
        from crazy_functions.解析项目源代码 import 解析任意code项目
-        function_plugins.update({
-            "解析项目源代码（手动指定和筛选源代码文件类型）": {
-                "Group": "编程",
-                "Color": "stop",
-                "AsButton": False,
-                "AdvancedArgs": True,  # 调用时，唤起高级参数输入区（默认False）
-                "ArgsReminder": "输入时用逗号隔开, *代表通配符, 加了^代表不匹配; 不输入代表全部匹配。例如: \"*.c, ^*.cpp, config.toml, ^*.toml\"",  # 高级参数输入区的显示提示
-                "Function": HotReload(解析任意code项目)
-            },
-        })
+
+        function_plugins.update(
+            {
+                "解析项目源代码（手动指定和筛选源代码文件类型）": {
+                    "Group": "编程",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": True,  # 调用时，唤起高级参数输入区（默认False）
+                    "ArgsReminder": '输入时用逗号隔开, *代表通配符, 加了^代表不匹配; 不输入代表全部匹配。例如: "*.c, ^*.cpp, config.toml, ^*.toml"',  # 高级参数输入区的显示提示
+                    "Function": HotReload(解析任意code项目),
+                },
+            }
+        )
    except:
        print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")

    try:
        from crazy_functions.询问多个大语言模型 import 同时问询_指定模型
-        function_plugins.update({
-            "询问多个GPT模型（手动指定询问哪些模型）": {
-                "Group": "对话",
-                "Color": "stop",
-                "AsButton": False,
-                "AdvancedArgs": True,  # 调用时，唤起高级参数输入区（默认False）
-                "ArgsReminder": "支持任意数量的llm接口，用&符号分隔。例如chatglm&gpt-3.5-turbo&gpt-4",  # 高级参数输入区的显示提示
-                "Function": HotReload(同时问询_指定模型)
-            },
-        })
+
+        function_plugins.update(
+            {
+                "询问多个GPT模型（手动指定询问哪些模型）": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": True,  # 调用时，唤起高级参数输入区（默认False）
+                    "ArgsReminder": "支持任意数量的llm接口，用&符号分隔。例如chatglm&gpt-3.5-turbo&gpt-4",  # 高级参数输入区的显示提示
+                    "Function": HotReload(同时问询_指定模型),
+                },
+            }
+        )
    except:
        print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")

    try:
        from crazy_functions.图片生成 import 图片生成_DALLE2, 图片生成_DALLE3, 图片修改_DALLE2
-        function_plugins.update({
-            "图片生成_DALLE2 （先切换模型到gpt-*）": {
-                "Group": "对话",
-                "Color": "stop",
-                "AsButton": False,
-                "AdvancedArgs": True,  # 调用时，唤起高级参数输入区（默认False）
-                "ArgsReminder": "在这里输入分辨率, 如1024x1024（默认），支持 256x256, 512x512, 1024x1024",  # 高级参数输入区的显示提示
-                "Info": "使用DALLE2生成图片 | 输入参数字符串，提供图像的内容",
-                "Function": HotReload(图片生成_DALLE2)
-            },
-        })
-        function_plugins.update({
-            "图片生成_DALLE3 （先切换模型到gpt-*）": {
-                "Group": "对话",
-                "Color": "stop",
-                "AsButton": False,
-                "AdvancedArgs": True,  # 调用时，唤起高级参数输入区（默认False）
-                "ArgsReminder": "在这里输入自定义参数「分辨率-质量(可选)-风格(可选)」, 参数示例「1024x1024-hd-vivid」 || 分辨率支持 「1024x1024」(默认) /「1792x1024」/「1024x1792」 || 质量支持 「-standard」(默认) /「-hd」 || 风格支持 「-vivid」(默认) /「-natural」", # 高级参数输入区的显示提示
-                "Info": "使用DALLE3生成图片 | 输入参数字符串，提供图像的内容",
-                "Function": HotReload(图片生成_DALLE3)
-            },
-        })
-        function_plugins.update({
-            "图片修改_DALLE2 （先切换模型到gpt-*）": {
-                "Group": "对话",
-                "Color": "stop",
-                "AsButton": False,
-                "AdvancedArgs": False,  # 调用时，唤起高级参数输入区（默认False）
-                # "Info": "使用DALLE2修改图片 | 输入参数字符串，提供图像的内容",
-                "Function": HotReload(图片修改_DALLE2)
-            },
-        })
+
+        function_plugins.update(
+            {
+                "图片生成_DALLE2 （先切换模型到gpt-*）": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": True,  # 调用时，唤起高级参数输入区（默认False）
+                    "ArgsReminder": "在这里输入分辨率, 如1024x1024（默认），支持 256x256, 512x512, 1024x1024",  # 高级参数输入区的显示提示
+                    "Info": "使用DALLE2生成图片 | 输入参数字符串，提供图像的内容",
+                    "Function": HotReload(图片生成_DALLE2),
+                },
+            }
+        )
+        function_plugins.update(
+            {
+                "图片生成_DALLE3 （先切换模型到gpt-*）": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": True,  # 调用时，唤起高级参数输入区（默认False）
+                    "ArgsReminder": "在这里输入自定义参数「分辨率-质量(可选)-风格(可选)」, 参数示例「1024x1024-hd-vivid」 || 分辨率支持 「1024x1024」(默认) /「1792x1024」/「1024x1792」 || 质量支持 「-standard」(默认) /「-hd」 || 风格支持 「-vivid」(默认) /「-natural」",  # 高级参数输入区的显示提示
+                    "Info": "使用DALLE3生成图片 | 输入参数字符串，提供图像的内容",
+                    "Function": HotReload(图片生成_DALLE3),
+                },
+            }
+        )
+        function_plugins.update(
+            {
+                "图片修改_DALLE2 （先切换模型到gpt-*）": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": False,  # 调用时，唤起高级参数输入区（默认False）
+                    # "Info": "使用DALLE2修改图片 | 输入参数字符串，提供图像的内容",
+                    "Function": HotReload(图片修改_DALLE2),
+                },
+            }
+        )
    except:
        print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")

    try:
        from crazy_functions.总结音视频 import 总结音视频
-        function_plugins.update({
-            "批量总结音视频（输入路径或上传压缩包）": {
-                "Group": "对话",
-                "Color": "stop",
-                "AsButton": False,
-                "AdvancedArgs": True,
-                "ArgsReminder": "调用openai api 使用whisper-1模型, 目前支持的格式:mp4, m4a, wav, mpga, mpeg, mp3。此处可以输入解析提示，例如：解析为简体中文（默认）。",
-                "Info": "批量总结音频或视频 | 输入参数为路径",
-                "Function": HotReload(总结音视频)
+
+        function_plugins.update(
+            {
+                "批量总结音视频（输入路径或上传压缩包）": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": True,
+                    "ArgsReminder": "调用openai api 使用whisper-1模型, 目前支持的格式:mp4, m4a, wav, mpga, mpeg, mp3。此处可以输入解析提示，例如：解析为简体中文（默认）。",
+                    "Info": "批量总结音频或视频 | 输入参数为路径",
+                    "Function": HotReload(总结音视频),
+                }
            }
-        })
+        )
    except:
        print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")

    try:
        from crazy_functions.数学动画生成manim import 动画生成
-        function_plugins.update({
-            "数学动画生成（Manim）": {
-                "Group": "对话",
-                "Color": "stop",
-                "AsButton": False,
-                "Info": "按照自然语言描述生成一个动画 | 输入参数是一段话",
-                "Function": HotReload(动画生成)
+
+        function_plugins.update(
+            {
+                "数学动画生成（Manim）": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "Info": "按照自然语言描述生成一个动画 | 输入参数是一段话",
+                    "Function": HotReload(动画生成),
+                }
            }
-        })
+        )
    except:
        print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")

    try:
        from crazy_functions.批量Markdown翻译 import Markdown翻译指定语言
-        function_plugins.update({
-            "Markdown翻译（指定翻译成何种语言）": {
-                "Group": "编程",
-                "Color": "stop",
-                "AsButton": False,
-                "AdvancedArgs": True,
-                "ArgsReminder": "请输入要翻译成哪种语言，默认为Chinese。",
-                "Function": HotReload(Markdown翻译指定语言)
+
+        function_plugins.update(
+            {
+                "Markdown翻译（指定翻译成何种语言）": {
+                    "Group": "编程",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": True,
+                    "ArgsReminder": "请输入要翻译成哪种语言，默认为Chinese。",
+                    "Function": HotReload(Markdown翻译指定语言),
+                }
            }
-        })
+        )
    except:
        print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")

    try:
        from crazy_functions.知识库问答 import 知识库文件注入
-        function_plugins.update({
-            "构建知识库（先上传文件素材,再运行此插件）": {
-                "Group": "对话",
-                "Color": "stop",
-                "AsButton": False,
-                "AdvancedArgs": True,
-                "ArgsReminder": "此处待注入的知识库名称id, 默认为default。文件进入知识库后可长期保存。可以通过再次调用本插件的方式，向知识库追加更多文档。",
-                "Function": HotReload(知识库文件注入)
+
+        function_plugins.update(
+            {
+                "构建知识库（先上传文件素材,再运行此插件）": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": True,
+                    "ArgsReminder": "此处待注入的知识库名称id, 默认为default。文件进入知识库后可长期保存。可以通过再次调用本插件的方式，向知识库追加更多文档。",
+                    "Function": HotReload(知识库文件注入),
+                }
            }
-        })
+        )
    except:
        print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")

    try:
        from crazy_functions.知识库问答 import 读取知识库作答
-        function_plugins.update({
-            "知识库文件注入（构建知识库后,再运行此插件）": {
-                "Group": "对话",
-                "Color": "stop",
-                "AsButton": False,
-                "AdvancedArgs": True,
-                "ArgsReminder": "待提取的知识库名称id, 默认为default, 您需要构建知识库后再运行此插件。",
-                "Function": HotReload(读取知识库作答)
+
+        function_plugins.update(
+            {
+                "知识库文件注入（构建知识库后,再运行此插件）": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": True,
+                    "ArgsReminder": "待提取的知识库名称id, 默认为default, 您需要构建知识库后再运行此插件。",
+                    "Function": HotReload(读取知识库作答),
+                }
            }
-        })
+        )
    except:
        print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")

    try:
        from crazy_functions.交互功能函数模板 import 交互功能模板函数
-        function_plugins.update({
-            "交互功能模板Demo函数（查找wallhaven.cc的壁纸）": {
-                "Group": "对话",
-                "Color": "stop",
-                "AsButton": False,
-                "Function": HotReload(交互功能模板函数)
+
+        function_plugins.update(
+            {
+                "交互功能模板Demo函数（查找wallhaven.cc的壁纸）": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "Function": HotReload(交互功能模板函数),
+                }
            }
-        })
+        )
    except:
        print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")

    try:
-        from crazy_functions.Latex输出PDF结果 import Latex英文纠错加PDF对比
-        function_plugins.update({
-            "Latex英文纠错+高亮修正位置 [需Latex]": {
-                "Group": "学术",
-                "Color": "stop",
-                "AsButton": False,
-                "AdvancedArgs": True,
-                "ArgsReminder": "如果有必要, 请在此处追加更细致的矫错指令（使用英文）。",
-                "Function": HotReload(Latex英文纠错加PDF对比)
+        from crazy_functions.Latex输出PDF import Latex英文纠错加PDF对比
+        from crazy_functions.Latex输出PDF import Latex翻译中文并重新编译PDF
+        from crazy_functions.Latex输出PDF import PDF翻译中文并重新编译PDF
+
+        function_plugins.update(
+            {
+                "Latex英文纠错+高亮修正位置 [需Latex]": {
+                    "Group": "学术",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": True,
+                    "ArgsReminder": "如果有必要, 请在此处追加更细致的矫错指令（使用英文）。",
+                    "Function": HotReload(Latex英文纠错加PDF对比),
+                },
+                "Arxiv论文精细翻译（输入arxivID）[需Latex]": {
+                    "Group": "学术",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": True,
+                    "ArgsReminder": r"如果有必要, 请在此处给出自定义翻译命令, 解决部分词汇翻译不准确的问题。 "
+                                    r"例如当单词'agent'翻译不准确时, 请尝试把以下指令复制到高级参数区: "
+                                    r'If the term "agent" is used in this section, it should be translated to "智能体". ',
+                    "Info": "Arixv论文精细翻译 | 输入参数arxiv论文的ID，比如1812.10695",
+                    "Function": HotReload(Latex翻译中文并重新编译PDF),
+                },
+                "本地Latex论文精细翻译（上传Latex项目）[需Latex]": {
+                    "Group": "学术",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": True,
+                    "ArgsReminder": r"如果有必要, 请在此处给出自定义翻译命令, 解决部分词汇翻译不准确的问题。 "
+                                    r"例如当单词'agent'翻译不准确时, 请尝试把以下指令复制到高级参数区: "
+                                    r'If the term "agent" is used in this section, it should be translated to "智能体". ',
+                    "Info": "本地Latex论文精细翻译 | 输入参数是路径",
+                    "Function": HotReload(Latex翻译中文并重新编译PDF),
+                },
+                "PDF翻译中文并重新编译PDF（上传PDF）[需Latex]": {
+                    "Group": "学术",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": True,
+                    "ArgsReminder": r"如果有必要, 请在此处给出自定义翻译命令, 解决部分词汇翻译不准确的问题。 "
+                                    r"例如当单词'agent'翻译不准确时, 请尝试把以下指令复制到高级参数区: "
+                                    r'If the term "agent" is used in this section, it should be translated to "智能体". ',
+                    "Info": "PDF翻译中文，并重新编译PDF | 输入参数为路径",
+                    "Function": HotReload(PDF翻译中文并重新编译PDF)
+                }
            }
-        })
-        from crazy_functions.Latex输出PDF结果 import Latex翻译中文并重新编译PDF
-        function_plugins.update({
-            "Arxiv论文精细翻译（输入arxivID）[需Latex]": {
-                "Group": "学术",
-                "Color": "stop",
-                "AsButton": False,
-                "AdvancedArgs": True,
-                "ArgsReminder":
-                    "如果有必要, 请在此处给出自定义翻译命令, 解决部分词汇翻译不准确的问题。 " +
-                    "例如当单词'agent'翻译不准确时, 请尝试把以下指令复制到高级参数区: " +
-                    'If the term "agent" is used in this section, it should be translated to "智能体". ',
-                "Info": "Arixv论文精细翻译 | 输入参数arxiv论文的ID，比如1812.10695",
-                "Function": HotReload(Latex翻译中文并重新编译PDF)
-            }
-        })
-        function_plugins.update({
-            "本地Latex论文精细翻译（上传Latex项目）[需Latex]": {
-                "Group": "学术",
-                "Color": "stop",
-                "AsButton": False,
-                "AdvancedArgs": True,
-                "ArgsReminder":
-                    "如果有必要, 请在此处给出自定义翻译命令, 解决部分词汇翻译不准确的问题。 " +
-                    "例如当单词'agent'翻译不准确时, 请尝试把以下指令复制到高级参数区: " +
-                    'If the term "agent" is used in this section, it should be translated to "智能体". ',
-                "Info": "本地Latex论文精细翻译 | 输入参数是路径",
-                "Function": HotReload(Latex翻译中文并重新编译PDF)
-            }
-        })
+        )
    except:
        print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")

    try:
        from toolbox import get_conf
-        ENABLE_AUDIO = get_conf('ENABLE_AUDIO')
+
+        ENABLE_AUDIO = get_conf("ENABLE_AUDIO")
        if ENABLE_AUDIO:
            from crazy_functions.语音助手 import 语音助手
-            function_plugins.update({
-                "实时语音对话": {
-                    "Group": "对话",
-                    "Color": "stop",
-                    "AsButton": True,
-                    "Info": "这是一个时刻聆听着的语音对话助手 | 没有输入参数",
-                    "Function": HotReload(语音助手)
+
+            function_plugins.update(
+                {
+                    "实时语音对话": {
+                        "Group": "对话",
+                        "Color": "stop",
+                        "AsButton": True,
+                        "Info": "这是一个时刻聆听着的语音对话助手 | 没有输入参数",
+                        "Function": HotReload(语音助手),
+                    }
                }
-            })
+            )
    except:
        print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")

    try:
        from crazy_functions.批量翻译PDF文档_NOUGAT import 批量翻译PDF文档
-        function_plugins.update({
-            "精准翻译PDF文档（NOUGAT）": {
-                "Group": "学术",
-                "Color": "stop",
-                "AsButton": False,
-                "Function": HotReload(批量翻译PDF文档)
+
+        function_plugins.update(
+            {
+                "精准翻译PDF文档（NOUGAT）": {
+                    "Group": "学术",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "Function": HotReload(批量翻译PDF文档),
+                }
            }
-        })
+        )
    except:
        print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")

    try:
        from crazy_functions.函数动态生成 import 函数动态生成
-        function_plugins.update({
-            "动态代码解释器（CodeInterpreter）": {
-                "Group": "智能体",
-                "Color": "stop",
-                "AsButton": False,
-                "Function": HotReload(函数动态生成)
+
+        function_plugins.update(
+            {
+                "动态代码解释器（CodeInterpreter）": {
+                    "Group": "智能体",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "Function": HotReload(函数动态生成),
+                }
            }
-        })
+        )
    except:
        print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")

    try:
        from crazy_functions.多智能体 import 多智能体终端
-        function_plugins.update({
-            "AutoGen多智能体终端（仅供测试）": {
-                "Group": "智能体",
-                "Color": "stop",
-                "AsButton": False,
-                "Function": HotReload(多智能体终端)
+
+        function_plugins.update(
+            {
+                "AutoGen多智能体终端（仅供测试）": {
+                    "Group": "智能体",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "Function": HotReload(多智能体终端),
+                }
            }
-        })
+        )
    except:
        print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")

    try:
        from crazy_functions.互动小游戏 import 随机小游戏
-        function_plugins.update({
-            "随机互动小游戏（仅供测试）": {
-                "Group": "智能体",
-                "Color": "stop",
-                "AsButton": False,
-                "Function": HotReload(随机小游戏)
+
+        function_plugins.update(
+            {
+                "随机互动小游戏（仅供测试）": {
+                    "Group": "智能体",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "Function": HotReload(随机小游戏),
+                }
            }
-        })
+        )
    except:
        print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")
+
+    # try:
+    #     from crazy_functions.高级功能函数模板 import 测试图表渲染
+    #     function_plugins.update({
+    #         "绘制逻辑关系（测试图表渲染）": {
+    #             "Group": "智能体",
+    #             "Color": "stop",
+    #             "AsButton": True,
+    #             "Function": HotReload(测试图表渲染)
+    #         }
+    #     })
+    # except:
+    #     print(trimmed_format_exc())
+    #     print('Load function plugin failed')

    # try:
    #     from crazy_functions.chatglm微调工具 import 微调数据集生成
@@ -618,8 +703,6 @@ def get_crazy_functions():
    # except:
    #     print('Load function plugin failed')

-
-
    """
    设置默认值:
    - 默认 Group = 对话
@@ -629,12 +712,12 @@ def get_crazy_functions():
    """
    for name, function_meta in function_plugins.items():
        if "Group" not in function_meta:
-            function_plugins[name]["Group"] = '对话'
+            function_plugins[name]["Group"] = "对话"
        if "AsButton" not in function_meta:
            function_plugins[name]["AsButton"] = True
        if "AdvancedArgs" not in function_meta:
            function_plugins[name]["AdvancedArgs"] = False
        if "Color" not in function_meta:
-            function_plugins[name]["Color"] = 'secondary'
+            function_plugins[name]["Color"] = "secondary"

    return function_plugins
--- a/crazy_functions/CodeInterpreter.py
+++ b/crazy_functions/CodeInterpreter.py
@@ -1,232 +0,0 @@
-from collections.abc import Callable, Iterable, Mapping
-from typing import Any
-from toolbox import CatchException, update_ui, gen_time_str, trimmed_format_exc
-from toolbox import promote_file_to_downloadzone, get_log_folder
-from .crazy_utils import request_gpt_model_in_new_thread_with_ui_alive
-from .crazy_utils import input_clipping, try_install_deps
-from multiprocessing import Process, Pipe
-import os
-import time
-
-templete = """
-```python
-import ...  # Put dependencies here, e.g. import numpy as np
-
-class TerminalFunction(object): # Do not change the name of the class, The name of the class must be `TerminalFunction`
-
-    def run(self, path):    # The name of the function must be `run`, it takes only a positional argument.
-        # rewrite the function you have just written here 
-        ...
-        return generated_file_path
-```
-"""
-
-def inspect_dependency(chatbot, history):
-    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-    return True
-
-def get_code_block(reply):
-    import re
-    pattern = r"```([\s\S]*?)```" # regex pattern to match code blocks
-    matches = re.findall(pattern, reply) # find all code blocks in text
-    if len(matches) == 1: 
-        return matches[0].strip('python') #  code block
-    for match in matches:
-        if 'class TerminalFunction' in match:
-            return match.strip('python') #  code block
-    raise RuntimeError("GPT is not generating proper code.")
-
-def gpt_interact_multi_step(txt, file_type, llm_kwargs, chatbot, history):
-    # 输入
-    prompt_compose = [
-        f'Your job:\n'
-        f'1. write a single Python function, which takes a path of a `{file_type}` file as the only argument and returns a `string` containing the result of analysis or the path of generated files. \n',
-        f"2. You should write this function to perform following task: " + txt + "\n",
-        f"3. Wrap the output python function with markdown codeblock."
-    ]
-    i_say = "".join(prompt_compose)
-    demo = []
-
-    # 第一步
-    gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive(
-        inputs=i_say, inputs_show_user=i_say, 
-        llm_kwargs=llm_kwargs, chatbot=chatbot, history=demo, 
-        sys_prompt= r"You are a programmer."
-    )
-    history.extend([i_say, gpt_say])
-    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 界面更新
-
-    # 第二步
-    prompt_compose = [
-        "If previous stage is successful, rewrite the function you have just written to satisfy following templete: \n",
-        templete
-    ]
-    i_say = "".join(prompt_compose); inputs_show_user = "If previous stage is successful, rewrite the function you have just written to satisfy executable templete. "
-    gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive(
-        inputs=i_say, inputs_show_user=inputs_show_user, 
-        llm_kwargs=llm_kwargs, chatbot=chatbot, history=history, 
-        sys_prompt= r"You are a programmer."
-    )
-    code_to_return = gpt_say
-    history.extend([i_say, gpt_say])
-    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 界面更新
-    
-    # # 第三步
-    # i_say = "Please list to packages to install to run the code above. Then show me how to use `try_install_deps` function to install them."
-    # i_say += 'For instance. `try_install_deps(["opencv-python", "scipy", "numpy"])`'
-    # installation_advance = yield from request_gpt_model_in_new_thread_with_ui_alive(
-    #     inputs=i_say, inputs_show_user=inputs_show_user, 
-    #     llm_kwargs=llm_kwargs, chatbot=chatbot, history=history, 
-    #     sys_prompt= r"You are a programmer."
-    # )
-    # # # 第三步  
-    # i_say = "Show me how to use `pip` to install packages to run the code above. "
-    # i_say += 'For instance. `pip install -r opencv-python scipy numpy`'
-    # installation_advance = yield from request_gpt_model_in_new_thread_with_ui_alive(
-    #     inputs=i_say, inputs_show_user=i_say, 
-    #     llm_kwargs=llm_kwargs, chatbot=chatbot, history=history, 
-    #     sys_prompt= r"You are a programmer."
-    # )
-    installation_advance = ""
-    
-    return code_to_return, installation_advance, txt, file_type, llm_kwargs, chatbot, history
-
-def make_module(code):
-    module_file = 'gpt_fn_' + gen_time_str().replace('-','_')
-    with open(f'{get_log_folder()}/{module_file}.py', 'w', encoding='utf8') as f:
-        f.write(code)
-
-    def get_class_name(class_string):
-        import re
-        # Use regex to extract the class name
-        class_name = re.search(r'class (\w+)\(', class_string).group(1)
-        return class_name
-
-    class_name = get_class_name(code)
-    return f"{get_log_folder().replace('/', '.')}.{module_file}->{class_name}"
-
-def init_module_instance(module):
-    import importlib
-    module_, class_ = module.split('->')
-    init_f = getattr(importlib.import_module(module_), class_)
-    return init_f()
-
-def for_immediate_show_off_when_possible(file_type, fp, chatbot):
-    if file_type in ['png', 'jpg']:
-        image_path = os.path.abspath(fp)
-        chatbot.append(['这是一张图片, 展示如下:',  
-            f'本地文件地址: <br/>`{image_path}`<br/>'+
-            f'本地文件预览: <br/><div align="center"><img src="file={image_path}"></div>'
-        ])
-    return chatbot
-
-def subprocess_worker(instance, file_path, return_dict):
-    return_dict['result'] = instance.run(file_path)
-
-def have_any_recent_upload_files(chatbot):
-    _5min = 5 * 60
-    if not chatbot: return False    # chatbot is None
-    most_recent_uploaded = chatbot._cookies.get("most_recent_uploaded", None)
-    if not most_recent_uploaded: return False   # most_recent_uploaded is None
-    if time.time() - most_recent_uploaded["time"] < _5min: return True # most_recent_uploaded is new
-    else: return False  # most_recent_uploaded is too old
-
-def get_recent_file_prompt_support(chatbot):
-    most_recent_uploaded = chatbot._cookies.get("most_recent_uploaded", None)
-    path = most_recent_uploaded['path']
-    return path
-
-@CatchException
-def 虚空终端CodeInterpreter(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-    """
-    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
-    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
-    plugin_kwargs   插件模型的参数，暂时没有用武之地
-    chatbot         聊天显示框的句柄，用于显示给用户
-    history         聊天历史，前情提要
-    system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
-    """
-    raise NotImplementedError
-
-    # 清空历史，以免输入溢出
-    history = []; clear_file_downloadzone(chatbot)
-
-    # 基本信息：功能、贡献者
-    chatbot.append([
-        "函数插件功能？",
-        "CodeInterpreter开源版, 此插件处于开发阶段, 建议暂时不要使用, 插件初始化中 ..."
-    ])
-    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-
-    if have_any_recent_upload_files(chatbot):
-        file_path = get_recent_file_prompt_support(chatbot)
-    else:
-        chatbot.append(["文件检索", "没有发现任何近期上传的文件。"])
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-
-    # 读取文件
-    if ("recently_uploaded_files" in plugin_kwargs) and (plugin_kwargs["recently_uploaded_files"] == ""): plugin_kwargs.pop("recently_uploaded_files")
-    recently_uploaded_files = plugin_kwargs.get("recently_uploaded_files", None)
-    file_path = recently_uploaded_files[-1]
-    file_type = file_path.split('.')[-1]
-
-    # 粗心检查
-    if is_the_upload_folder(txt):
-        chatbot.append([
-            "...",
-            f"请在输入框内填写需求，然后再次点击该插件（文件路径 {file_path} 已经被记忆）"
-        ])
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        return
-    
-    # 开始干正事
-    for j in range(5):  # 最多重试5次
-        try:
-            code, installation_advance, txt, file_type, llm_kwargs, chatbot, history = \
-                yield from gpt_interact_multi_step(txt, file_type, llm_kwargs, chatbot, history)
-            code = get_code_block(code)
-            res = make_module(code)
-            instance = init_module_instance(res)
-            break
-        except Exception as e:
-            chatbot.append([f"第{j}次代码生成尝试，失败了", f"错误追踪\n```\n{trimmed_format_exc()}\n```\n"])
-            yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-
-    # 代码生成结束, 开始执行
-    try:
-        import multiprocessing
-        manager = multiprocessing.Manager()
-        return_dict = manager.dict()
-
-        p = multiprocessing.Process(target=subprocess_worker, args=(instance, file_path, return_dict))
-        # only has 10 seconds to run
-        p.start(); p.join(timeout=10)
-        if p.is_alive(): p.terminate(); p.join()
-        p.close()
-        res = return_dict['result']
-        # res = instance.run(file_path)
-    except Exception as e:
-        chatbot.append(["执行失败了", f"错误追踪\n```\n{trimmed_format_exc()}\n```\n"])
-        # chatbot.append(["如果是缺乏依赖，请参考以下建议", installation_advance])
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        return
-
-    # 顺利完成，收尾
-    res = str(res)
-    if os.path.exists(res):
-        chatbot.append(["执行成功了，结果是一个有效文件", "结果：" + res])
-        new_file_path = promote_file_to_downloadzone(res, chatbot=chatbot)
-        chatbot = for_immediate_show_off_when_possible(file_type, new_file_path, chatbot)
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 界面更新
-    else:
-        chatbot.append(["执行成功了，结果是一个字符串", "结果：" + res])
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 界面更新   
-
-"""
-测试：
-    裁剪图像，保留下半部分
-    交换图像的蓝色通道和红色通道
-    将图像转为灰度图像
-    将csv文件转excel表格
-"""
--- a/crazy_functions/Latex全文润色.py
+++ b/crazy_functions/Latex全文润色.py
@@ -135,11 +135,11 @@ def 多文件润色(file_manifest, project_folder, llm_kwargs, plugin_kwargs, ch


@CatchException
-def Latex英文润色(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def Latex英文润色(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    # 基本信息：功能、贡献者
    chatbot.append([
        "函数插件功能？",
-        "对整个Latex项目进行润色。函数插件贡献者: Binary-Husky。（注意，此插件不调用Latex，如果有Latex环境，请使用“Latex英文纠错+高亮”插件）"])
+        "对整个Latex项目进行润色。函数插件贡献者: Binary-Husky。（注意，此插件不调用Latex，如果有Latex环境，请使用「Latex英文纠错+高亮修正位置(需Latex)插件」"])
    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面

    # 尝试导入依赖，如果缺少依赖，则给出安装建议
@@ -173,7 +173,7 @@ def Latex英文润色(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_p


@CatchException
-def Latex中文润色(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def Latex中文润色(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    # 基本信息：功能、贡献者
    chatbot.append([
        "函数插件功能？",
@@ -209,7 +209,7 @@ def Latex中文润色(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_p


@CatchException
-def Latex英文纠错(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def Latex英文纠错(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    # 基本信息：功能、贡献者
    chatbot.append([
        "函数插件功能？",
--- a/crazy_functions/Latex全文翻译.py
+++ b/crazy_functions/Latex全文翻译.py
@@ -106,7 +106,7 @@ def 多文件翻译(file_manifest, project_folder, llm_kwargs, plugin_kwargs, ch


@CatchException
-def Latex英译中(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def Latex英译中(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    # 基本信息：功能、贡献者
    chatbot.append([
        "函数插件功能？",
@@ -143,7 +143,7 @@ def Latex英译中(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prom


@CatchException
-def Latex中译英(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def Latex中译英(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    # 基本信息：功能、贡献者
    chatbot.append([
        "函数插件功能？",
--- a/crazy_functions/Latex输出PDF.py
+++ b/crazy_functions/Latex输出PDF.py
@@ -0,0 +1,484 @@
+from toolbox import update_ui, trimmed_format_exc, get_conf, get_log_folder, promote_file_to_downloadzone
+from toolbox import CatchException, report_exception, update_ui_lastest_msg, zip_result, gen_time_str
+from functools import partial
+import glob, os, requests, time, json, tarfile
+
+pj = os.path.join
+ARXIV_CACHE_DIR = os.path.expanduser(f"~/arxiv_cache/")
+
+
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- 工具函数 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+# 专业词汇声明  = 'If the term "agent" is used in this section, it should be translated to "智能体". '
+def switch_prompt(pfg, mode, more_requirement):
+    """
+    Generate prompts and system prompts based on the mode for proofreading or translating.
+    Args:
+    - pfg: Proofreader or Translator instance.
+    - mode: A string specifying the mode, either 'proofread' or 'translate_zh'.
+
+    Returns:
+    - inputs_array: A list of strings containing prompts for users to respond to.
+    - sys_prompt_array: A list of strings containing prompts for system prompts.
+    """
+    n_split = len(pfg.sp_file_contents)
+    if mode == 'proofread_en':
+        inputs_array = [r"Below is a section from an academic paper, proofread this section." +
+                        r"Do not modify any latex command such as \section, \cite, \begin, \item and equations. " + more_requirement +
+                        r"Answer me only with the revised text:" +
+                        f"\n\n{frag}" for frag in pfg.sp_file_contents]
+        sys_prompt_array = ["You are a professional academic paper writer." for _ in range(n_split)]
+    elif mode == 'translate_zh':
+        inputs_array = [
+            r"Below is a section from an English academic paper, translate it into Chinese. " + more_requirement +
+            r"Do not modify any latex command such as \section, \cite, \begin, \item and equations. " +
+            r"Answer me only with the translated text:" +
+            f"\n\n{frag}" for frag in pfg.sp_file_contents]
+        sys_prompt_array = ["You are a professional translator." for _ in range(n_split)]
+    else:
+        assert False, "未知指令"
+    return inputs_array, sys_prompt_array
+
+
+def desend_to_extracted_folder_if_exist(project_folder):
+    """ 
+    Descend into the extracted folder if it exists, otherwise return the original folder.
+
+    Args:
+    - project_folder: A string specifying the folder path.
+
+    Returns:
+    - A string specifying the path to the extracted folder, or the original folder if there is no extracted folder.
+    """
+    maybe_dir = [f for f in glob.glob(f'{project_folder}/*') if os.path.isdir(f)]
+    if len(maybe_dir) == 0: return project_folder
+    if maybe_dir[0].endswith('.extract'): return maybe_dir[0]
+    return project_folder
+
+
+def move_project(project_folder, arxiv_id=None):
+    """ 
+    Create a new work folder and copy the project folder to it.
+
+    Args:
+    - project_folder: A string specifying the folder path of the project.
+
+    Returns:
+    - A string specifying the path to the new work folder.
+    """
+    import shutil, time
+    time.sleep(2)  # avoid time string conflict
+    if arxiv_id is not None:
+        new_workfolder = pj(ARXIV_CACHE_DIR, arxiv_id, 'workfolder')
+    else:
+        new_workfolder = f'{get_log_folder()}/{gen_time_str()}'
+    try:
+        shutil.rmtree(new_workfolder)
+    except:
+        pass
+
+    # align subfolder if there is a folder wrapper
+    items = glob.glob(pj(project_folder, '*'))
+    items = [item for item in items if os.path.basename(item) != '__MACOSX']
+    if len(glob.glob(pj(project_folder, '*.tex'))) == 0 and len(items) == 1:
+        if os.path.isdir(items[0]): project_folder = items[0]
+
+    shutil.copytree(src=project_folder, dst=new_workfolder)
+    return new_workfolder
+
+
+def arxiv_download(chatbot, history, txt, allow_cache=True):
+    def check_cached_translation_pdf(arxiv_id):
+        translation_dir = pj(ARXIV_CACHE_DIR, arxiv_id, 'translation')
+        if not os.path.exists(translation_dir):
+            os.makedirs(translation_dir)
+        target_file = pj(translation_dir, 'translate_zh.pdf')
+        if os.path.exists(target_file):
+            promote_file_to_downloadzone(target_file, rename_file=None, chatbot=chatbot)
+            target_file_compare = pj(translation_dir, 'comparison.pdf')
+            if os.path.exists(target_file_compare):
+                promote_file_to_downloadzone(target_file_compare, rename_file=None, chatbot=chatbot)
+            return target_file
+        return False
+
+    def is_float(s):
+        try:
+            float(s)
+            return True
+        except ValueError:
+            return False
+
+    if ('.' in txt) and ('/' not in txt) and is_float(txt):  # is arxiv ID
+        txt = 'https://arxiv.org/abs/' + txt.strip()
+    if ('.' in txt) and ('/' not in txt) and is_float(txt[:10]):  # is arxiv ID
+        txt = 'https://arxiv.org/abs/' + txt[:10]
+
+    if not txt.startswith('https://arxiv.org'): 
+        return txt, None    # 是本地文件，跳过下载
+    
+    # <-------------- inspect format ------------->
+    chatbot.append([f"检测到arxiv文档连接", '尝试下载 ...'])
+    yield from update_ui(chatbot=chatbot, history=history)
+    time.sleep(1)  # 刷新界面
+
+    url_ = txt  # https://arxiv.org/abs/1707.06690
+    if not txt.startswith('https://arxiv.org/abs/'):
+        msg = f"解析arxiv网址失败, 期望格式例如: https://arxiv.org/abs/1707.06690。实际得到格式: {url_}。"
+        yield from update_ui_lastest_msg(msg, chatbot=chatbot, history=history)  # 刷新界面
+        return msg, None
+    # <-------------- set format ------------->
+    arxiv_id = url_.split('/abs/')[-1]
+    if 'v' in arxiv_id: arxiv_id = arxiv_id[:10]
+    cached_translation_pdf = check_cached_translation_pdf(arxiv_id)
+    if cached_translation_pdf and allow_cache: return cached_translation_pdf, arxiv_id
+
+    url_tar = url_.replace('/abs/', '/e-print/')
+    translation_dir = pj(ARXIV_CACHE_DIR, arxiv_id, 'e-print')
+    extract_dst = pj(ARXIV_CACHE_DIR, arxiv_id, 'extract')
+    os.makedirs(translation_dir, exist_ok=True)
+
+    # <-------------- download arxiv source file ------------->
+    dst = pj(translation_dir, arxiv_id + '.tar')
+    if os.path.exists(dst):
+        yield from update_ui_lastest_msg("调用缓存", chatbot=chatbot, history=history)  # 刷新界面
+    else:
+        yield from update_ui_lastest_msg("开始下载", chatbot=chatbot, history=history)  # 刷新界面
+        proxies = get_conf('proxies')
+        r = requests.get(url_tar, proxies=proxies)
+        with open(dst, 'wb+') as f:
+            f.write(r.content)
+    # <-------------- extract file ------------->
+    yield from update_ui_lastest_msg("下载完成", chatbot=chatbot, history=history)  # 刷新界面
+    from toolbox import extract_archive
+    extract_archive(file_path=dst, dest_dir=extract_dst)
+    return extract_dst, arxiv_id
+
+
+def pdf2tex_project(pdf_file_path):
+    # Mathpix API credentials
+    app_id, app_key = get_conf('MATHPIX_APPID', 'MATHPIX_APPKEY')
+    headers = {"app_id": app_id, "app_key": app_key}
+
+    # Step 1: Send PDF file for processing
+    options = {
+        "conversion_formats": {"tex.zip": True},
+        "math_inline_delimiters": ["$", "$"],
+        "rm_spaces": True
+    }
+
+    response = requests.post(url="https://api.mathpix.com/v3/pdf",
+                             headers=headers,
+                             data={"options_json": json.dumps(options)},
+                             files={"file": open(pdf_file_path, "rb")})
+
+    if response.ok:
+        pdf_id = response.json()["pdf_id"]
+        print(f"PDF processing initiated. PDF ID: {pdf_id}")
+
+        # Step 2: Check processing status
+        while True:
+            conversion_response = requests.get(f"https://api.mathpix.com/v3/pdf/{pdf_id}", headers=headers)
+            conversion_data = conversion_response.json()
+
+            if conversion_data["status"] == "completed":
+                print("PDF processing completed.")
+                break
+            elif conversion_data["status"] == "error":
+                print("Error occurred during processing.")
+            else:
+                print(f"Processing status: {conversion_data['status']}")
+                time.sleep(5)  # wait for a few seconds before checking again
+
+        # Step 3: Save results to local files
+        output_dir = os.path.join(os.path.dirname(pdf_file_path), 'mathpix_output')
+        if not os.path.exists(output_dir):
+            os.makedirs(output_dir)
+
+        url = f"https://api.mathpix.com/v3/pdf/{pdf_id}.tex"
+        response = requests.get(url, headers=headers)
+        file_name_wo_dot = '_'.join(os.path.basename(pdf_file_path).split('.')[:-1])
+        output_name = f"{file_name_wo_dot}.tex.zip"
+        output_path = os.path.join(output_dir, output_name)
+        with open(output_path, "wb") as output_file:
+            output_file.write(response.content)
+        print(f"tex.zip file saved at: {output_path}")
+
+        import zipfile
+        unzip_dir = os.path.join(output_dir, file_name_wo_dot)
+        with zipfile.ZipFile(output_path, 'r') as zip_ref:
+            zip_ref.extractall(unzip_dir)
+
+        return unzip_dir
+
+    else:
+        print(f"Error sending PDF for processing. Status code: {response.status_code}")
+        return None
+
+
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= 插件主程序1 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=    
+
+
+@CatchException
+def Latex英文纠错加PDF对比(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
+    # <-------------- information about this plugin ------------->
+    chatbot.append(["函数插件功能？",
+                    "对整个Latex项目进行纠错, 用latex编译为PDF对修正处做高亮。函数插件贡献者: Binary-Husky。注意事项: 目前仅支持GPT3.5/GPT4，其他模型转化效果未知。目前对机器学习类文献转化效果最好，其他类型文献转化效果未知。仅在Windows系统进行了测试，其他操作系统表现未知。"])
+    yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+
+    # <-------------- more requirements ------------->
+    if ("advanced_arg" in plugin_kwargs) and (plugin_kwargs["advanced_arg"] == ""): plugin_kwargs.pop("advanced_arg")
+    more_req = plugin_kwargs.get("advanced_arg", "")
+    _switch_prompt_ = partial(switch_prompt, more_requirement=more_req)
+
+    # <-------------- check deps ------------->
+    try:
+        import glob, os, time, subprocess
+        subprocess.Popen(['pdflatex', '-version'])
+        from .latex_fns.latex_actions import Latex精细分解与转化, 编译Latex
+    except Exception as e:
+        chatbot.append([f"解析项目: {txt}",
+                        f"尝试执行Latex指令失败。Latex没有安装, 或者不在环境变量PATH中。安装方法https://tug.org/texlive/。报错信息\n\n```\n\n{trimmed_format_exc()}\n\n```\n\n"])
+        yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+        return
+
+    # <-------------- clear history and read input ------------->
+    history = []
+    if os.path.exists(txt):
+        project_folder = txt
+    else:
+        if txt == "": txt = '空空如也的输入栏'
+        report_exception(chatbot, history, a=f"解析项目: {txt}", b=f"找不到本地项目或无权访问: {txt}")
+        yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+        return
+    file_manifest = [f for f in glob.glob(f'{project_folder}/**/*.tex', recursive=True)]
+    if len(file_manifest) == 0:
+        report_exception(chatbot, history, a=f"解析项目: {txt}", b=f"找不到任何.tex文件: {txt}")
+        yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+        return
+
+    # <-------------- if is a zip/tar file ------------->
+    project_folder = desend_to_extracted_folder_if_exist(project_folder)
+
+    # <-------------- move latex project away from temp folder ------------->
+    project_folder = move_project(project_folder, arxiv_id=None)
+
+    # <-------------- if merge_translate_zh is already generated, skip gpt req ------------->
+    if not os.path.exists(project_folder + '/merge_proofread_en.tex'):
+        yield from Latex精细分解与转化(file_manifest, project_folder, llm_kwargs, plugin_kwargs,
+                                       chatbot, history, system_prompt, mode='proofread_en',
+                                       switch_prompt=_switch_prompt_)
+
+    # <-------------- compile PDF ------------->
+    success = yield from 编译Latex(chatbot, history, main_file_original='merge',
+                                   main_file_modified='merge_proofread_en',
+                                   work_folder_original=project_folder, work_folder_modified=project_folder,
+                                   work_folder=project_folder)
+
+    # <-------------- zip PDF ------------->
+    zip_res = zip_result(project_folder)
+    if success:
+        chatbot.append((f"成功啦", '请查收结果（压缩包）...'))
+        yield from update_ui(chatbot=chatbot, history=history);
+        time.sleep(1)  # 刷新界面
+        promote_file_to_downloadzone(file=zip_res, chatbot=chatbot)
+    else:
+        chatbot.append((f"失败了",
+                        '虽然PDF生成失败了, 但请查收结果（压缩包）, 内含已经翻译的Tex文档, 也是可读的, 您可以到Github Issue区, 用该压缩包+对话历史存档进行反馈 ...'))
+        yield from update_ui(chatbot=chatbot, history=history);
+        time.sleep(1)  # 刷新界面
+        promote_file_to_downloadzone(file=zip_res, chatbot=chatbot)
+
+    # <-------------- we are done ------------->
+    return success
+
+
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= 插件主程序2 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=    
+
+@CatchException
+def Latex翻译中文并重新编译PDF(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
+    # <-------------- information about this plugin ------------->
+    chatbot.append([
+        "函数插件功能？",
+        "对整个Latex项目进行翻译, 生成中文PDF。函数插件贡献者: Binary-Husky。注意事项: 此插件Windows支持最佳，Linux下必须使用Docker安装，详见项目主README.md。目前仅支持GPT3.5/GPT4，其他模型转化效果未知。目前对机器学习类文献转化效果最好，其他类型文献转化效果未知。"])
+    yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+
+    # <-------------- more requirements ------------->
+    if ("advanced_arg" in plugin_kwargs) and (plugin_kwargs["advanced_arg"] == ""): plugin_kwargs.pop("advanced_arg")
+    more_req = plugin_kwargs.get("advanced_arg", "")
+    no_cache = more_req.startswith("--no-cache")
+    if no_cache: more_req.lstrip("--no-cache")
+    allow_cache = not no_cache
+    _switch_prompt_ = partial(switch_prompt, more_requirement=more_req)
+
+    # <-------------- check deps ------------->
+    try:
+        import glob, os, time, subprocess
+        subprocess.Popen(['pdflatex', '-version'])
+        from .latex_fns.latex_actions import Latex精细分解与转化, 编译Latex
+    except Exception as e:
+        chatbot.append([f"解析项目: {txt}",
+                        f"尝试执行Latex指令失败。Latex没有安装, 或者不在环境变量PATH中。安装方法https://tug.org/texlive/。报错信息\n\n```\n\n{trimmed_format_exc()}\n\n```\n\n"])
+        yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+        return
+
+    # <-------------- clear history and read input ------------->
+    history = []
+    try:
+        txt, arxiv_id = yield from arxiv_download(chatbot, history, txt, allow_cache)
+    except tarfile.ReadError as e:
+        yield from update_ui_lastest_msg(
+            "无法自动下载该论文的Latex源码，请前往arxiv打开此论文下载页面，点other Formats，然后download source手动下载latex源码包。接下来调用本地Latex翻译插件即可。", 
+            chatbot=chatbot, history=history)
+        return
+
+    if txt.endswith('.pdf'):
+        report_exception(chatbot, history, a=f"解析项目: {txt}", b=f"发现已经存在翻译好的PDF文档")
+        yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+        return
+
+    if os.path.exists(txt):
+        project_folder = txt
+    else:
+        if txt == "": txt = '空空如也的输入栏'
+        report_exception(chatbot, history, a=f"解析项目: {txt}", b=f"找不到本地项目或无法处理: {txt}")
+        yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+        return
+
+    file_manifest = [f for f in glob.glob(f'{project_folder}/**/*.tex', recursive=True)]
+    if len(file_manifest) == 0:
+        report_exception(chatbot, history, a=f"解析项目: {txt}", b=f"找不到任何.tex文件: {txt}")
+        yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+        return
+
+    # <-------------- if is a zip/tar file ------------->
+    project_folder = desend_to_extracted_folder_if_exist(project_folder)
+
+    # <-------------- move latex project away from temp folder ------------->
+    project_folder = move_project(project_folder, arxiv_id)
+
+    # <-------------- if merge_translate_zh is already generated, skip gpt req ------------->
+    if not os.path.exists(project_folder + '/merge_translate_zh.tex'):
+        yield from Latex精细分解与转化(file_manifest, project_folder, llm_kwargs, plugin_kwargs,
+                                       chatbot, history, system_prompt, mode='translate_zh',
+                                       switch_prompt=_switch_prompt_)
+
+    # <-------------- compile PDF ------------->
+    success = yield from 编译Latex(chatbot, history, main_file_original='merge',
+                                   main_file_modified='merge_translate_zh', mode='translate_zh',
+                                   work_folder_original=project_folder, work_folder_modified=project_folder,
+                                   work_folder=project_folder)
+
+    # <-------------- zip PDF ------------->
+    zip_res = zip_result(project_folder)
+    if success:
+        chatbot.append((f"成功啦", '请查收结果（压缩包）...'))
+        yield from update_ui(chatbot=chatbot, history=history);
+        time.sleep(1)  # 刷新界面
+        promote_file_to_downloadzone(file=zip_res, chatbot=chatbot)
+    else:
+        chatbot.append((f"失败了",
+                        '虽然PDF生成失败了, 但请查收结果（压缩包）, 内含已经翻译的Tex文档, 您可以到Github Issue区, 用该压缩包进行反馈。如系统是Linux，请检查系统字体（见Github wiki） ...'))
+        yield from update_ui(chatbot=chatbot, history=history);
+        time.sleep(1)  # 刷新界面
+        promote_file_to_downloadzone(file=zip_res, chatbot=chatbot)
+
+    # <-------------- we are done ------------->
+    return success
+
+
+#  =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- 插件主程序3  =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=   
+
+@CatchException
+def PDF翻译中文并重新编译PDF(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+    # <-------------- information about this plugin ------------->
+    chatbot.append([
+        "函数插件功能？",
+        "将PDF转换为Latex项目，翻译为中文后重新编译为PDF。函数插件贡献者: Marroh。注意事项: 此插件Windows支持最佳，Linux下必须使用Docker安装，详见项目主README.md。目前仅支持GPT3.5/GPT4，其他模型转化效果未知。目前对机器学习类文献转化效果最好，其他类型文献转化效果未知。"])
+    yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+
+    # <-------------- more requirements ------------->
+    if ("advanced_arg" in plugin_kwargs) and (plugin_kwargs["advanced_arg"] == ""): plugin_kwargs.pop("advanced_arg")
+    more_req = plugin_kwargs.get("advanced_arg", "")
+    no_cache = more_req.startswith("--no-cache")
+    if no_cache: more_req.lstrip("--no-cache")
+    allow_cache = not no_cache
+    _switch_prompt_ = partial(switch_prompt, more_requirement=more_req)
+
+    # <-------------- check deps ------------->
+    try:
+        import glob, os, time, subprocess
+        subprocess.Popen(['pdflatex', '-version'])
+        from .latex_fns.latex_actions import Latex精细分解与转化, 编译Latex
+    except Exception as e:
+        chatbot.append([f"解析项目: {txt}",
+                        f"尝试执行Latex指令失败。Latex没有安装, 或者不在环境变量PATH中。安装方法https://tug.org/texlive/。报错信息\n\n```\n\n{trimmed_format_exc()}\n\n```\n\n"])
+        yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+        return
+
+    # <-------------- clear history and read input ------------->
+    if os.path.exists(txt):
+        project_folder = txt
+    else:
+        if txt == "": txt = '空空如也的输入栏'
+        report_exception(chatbot, history, a=f"解析项目: {txt}", b=f"找不到本地项目或无法处理: {txt}")
+        yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+        return
+
+    file_manifest = [f for f in glob.glob(f'{project_folder}/**/*.pdf', recursive=True)]
+    if len(file_manifest) == 0:
+        report_exception(chatbot, history, a=f"解析项目: {txt}", b=f"找不到任何.pdf文件: {txt}")
+        yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+        return
+    if len(file_manifest) != 1:
+        report_exception(chatbot, history, a=f"解析项目: {txt}", b=f"不支持同时处理多个pdf文件: {txt}")
+        yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+        return
+    app_id, app_key = get_conf('MATHPIX_APPID', 'MATHPIX_APPKEY')
+    if len(app_id) == 0 or len(app_key) == 0:
+        report_exception(chatbot, history, a="缺失 MATHPIX_APPID 和 MATHPIX_APPKEY。", b=f"请配置 MATHPIX_APPID 和 MATHPIX_APPKEY")
+        yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+        return
+
+    # <-------------- convert pdf into tex ------------->
+    project_folder = pdf2tex_project(file_manifest[0])
+
+    # Translate English Latex to Chinese Latex, and compile it
+    file_manifest = [f for f in glob.glob(f'{project_folder}/**/*.tex', recursive=True)]
+    if len(file_manifest) == 0:
+        report_exception(chatbot, history, a=f"解析项目: {txt}", b=f"找不到任何.tex文件: {txt}")
+        yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+        return
+
+    # <-------------- if is a zip/tar file ------------->
+    project_folder = desend_to_extracted_folder_if_exist(project_folder)
+
+    # <-------------- move latex project away from temp folder ------------->
+    project_folder = move_project(project_folder)
+
+    # <-------------- if merge_translate_zh is already generated, skip gpt req ------------->
+    if not os.path.exists(project_folder + '/merge_translate_zh.tex'):
+        yield from Latex精细分解与转化(file_manifest, project_folder, llm_kwargs, plugin_kwargs,
+                                       chatbot, history, system_prompt, mode='translate_zh',
+                                       switch_prompt=_switch_prompt_)
+
+    # <-------------- compile PDF ------------->
+    success = yield from 编译Latex(chatbot, history, main_file_original='merge',
+                                   main_file_modified='merge_translate_zh', mode='translate_zh',
+                                   work_folder_original=project_folder, work_folder_modified=project_folder,
+                                   work_folder=project_folder)
+
+    # <-------------- zip PDF ------------->
+    zip_res = zip_result(project_folder)
+    if success:
+        chatbot.append((f"成功啦", '请查收结果（压缩包）...'))
+        yield from update_ui(chatbot=chatbot, history=history);
+        time.sleep(1)  # 刷新界面
+        promote_file_to_downloadzone(file=zip_res, chatbot=chatbot)
+    else:
+        chatbot.append((f"失败了",
+                        '虽然PDF生成失败了, 但请查收结果（压缩包）, 内含已经翻译的Tex文档, 您可以到Github Issue区, 用该压缩包进行反馈。如系统是Linux，请检查系统字体（见Github wiki） ...'))
+        yield from update_ui(chatbot=chatbot, history=history);
+        time.sleep(1)  # 刷新界面
+        promote_file_to_downloadzone(file=zip_res, chatbot=chatbot)
+
+    # <-------------- we are done ------------->
+    return success
--- a/crazy_functions/Latex输出PDF结果.py
+++ b/crazy_functions/Latex输出PDF结果.py
@@ -1,306 +0,0 @@
-from toolbox import update_ui, trimmed_format_exc, get_conf, get_log_folder, promote_file_to_downloadzone
-from toolbox import CatchException, report_exception, update_ui_lastest_msg, zip_result, gen_time_str
-from functools import partial
-import glob, os, requests, time
-pj = os.path.join
-ARXIV_CACHE_DIR = os.path.expanduser(f"~/arxiv_cache/")
-
-# =================================== 工具函数 ===============================================
-# 专业词汇声明  = 'If the term "agent" is used in this section, it should be translated to "智能体". '
-def switch_prompt(pfg, mode, more_requirement):
-    """
-    Generate prompts and system prompts based on the mode for proofreading or translating.
-    Args:
-    - pfg: Proofreader or Translator instance.
-    - mode: A string specifying the mode, either 'proofread' or 'translate_zh'.
-
-    Returns:
-    - inputs_array: A list of strings containing prompts for users to respond to.
-    - sys_prompt_array: A list of strings containing prompts for system prompts.
-    """
-    n_split = len(pfg.sp_file_contents)
-    if mode == 'proofread_en':
-        inputs_array = [r"Below is a section from an academic paper, proofread this section." + 
-                        r"Do not modify any latex command such as \section, \cite, \begin, \item and equations. " + more_requirement +
-                        r"Answer me only with the revised text:" + 
-                        f"\n\n{frag}" for frag in pfg.sp_file_contents]
-        sys_prompt_array = ["You are a professional academic paper writer." for _ in range(n_split)]
-    elif mode == 'translate_zh':
-        inputs_array = [r"Below is a section from an English academic paper, translate it into Chinese. " + more_requirement + 
-                        r"Do not modify any latex command such as \section, \cite, \begin, \item and equations. " + 
-                        r"Answer me only with the translated text:" + 
-                        f"\n\n{frag}" for frag in pfg.sp_file_contents]
-        sys_prompt_array = ["You are a professional translator." for _ in range(n_split)]
-    else:
-        assert False, "未知指令"
-    return inputs_array, sys_prompt_array
-
-def desend_to_extracted_folder_if_exist(project_folder):
-    """ 
-    Descend into the extracted folder if it exists, otherwise return the original folder.
-
-    Args:
-    - project_folder: A string specifying the folder path.
-
-    Returns:
-    - A string specifying the path to the extracted folder, or the original folder if there is no extracted folder.
-    """
-    maybe_dir = [f for f in glob.glob(f'{project_folder}/*') if os.path.isdir(f)]
-    if len(maybe_dir) == 0: return project_folder
-    if maybe_dir[0].endswith('.extract'): return maybe_dir[0]
-    return project_folder
-
-def move_project(project_folder, arxiv_id=None):
-    """ 
-    Create a new work folder and copy the project folder to it.
-
-    Args:
-    - project_folder: A string specifying the folder path of the project.
-
-    Returns:
-    - A string specifying the path to the new work folder.
-    """
-    import shutil, time
-    time.sleep(2)   # avoid time string conflict
-    if arxiv_id is not None:
-        new_workfolder = pj(ARXIV_CACHE_DIR, arxiv_id, 'workfolder')
-    else:
-        new_workfolder = f'{get_log_folder()}/{gen_time_str()}'
-    try:
-        shutil.rmtree(new_workfolder)
-    except:
-        pass
-
-    # align subfolder if there is a folder wrapper
-    items = glob.glob(pj(project_folder,'*'))
-    items = [item for item in items if os.path.basename(item)!='__MACOSX']
-    if len(glob.glob(pj(project_folder,'*.tex'))) == 0 and len(items) == 1:
-        if os.path.isdir(items[0]): project_folder = items[0]
-
-    shutil.copytree(src=project_folder, dst=new_workfolder)
-    return new_workfolder
-
-def arxiv_download(chatbot, history, txt, allow_cache=True):
-    def check_cached_translation_pdf(arxiv_id):
-        translation_dir = pj(ARXIV_CACHE_DIR, arxiv_id, 'translation')
-        if not os.path.exists(translation_dir):
-            os.makedirs(translation_dir)
-        target_file = pj(translation_dir, 'translate_zh.pdf')
-        if os.path.exists(target_file):
-            promote_file_to_downloadzone(target_file, rename_file=None, chatbot=chatbot)
-            target_file_compare = pj(translation_dir, 'comparison.pdf')
-            if os.path.exists(target_file_compare):
-                promote_file_to_downloadzone(target_file_compare, rename_file=None, chatbot=chatbot)
-            return target_file
-        return False
-    def is_float(s):
-        try:
-            float(s)
-            return True
-        except ValueError:
-            return False
-    if ('.' in txt) and ('/' not in txt) and is_float(txt): # is arxiv ID
-        txt = 'https://arxiv.org/abs/' + txt.strip()
-    if ('.' in txt) and ('/' not in txt) and is_float(txt[:10]): # is arxiv ID
-        txt = 'https://arxiv.org/abs/' + txt[:10]
-    if not txt.startswith('https://arxiv.org'): 
-        return txt, None
-    
-    # <-------------- inspect format ------------->
-    chatbot.append([f"检测到arxiv文档连接", '尝试下载 ...']) 
-    yield from update_ui(chatbot=chatbot, history=history)
-    time.sleep(1) # 刷新界面
-
-    url_ = txt   # https://arxiv.org/abs/1707.06690
-    if not txt.startswith('https://arxiv.org/abs/'): 
-        msg = f"解析arxiv网址失败, 期望格式例如: https://arxiv.org/abs/1707.06690。实际得到格式: {url_}。"
-        yield from update_ui_lastest_msg(msg, chatbot=chatbot, history=history) # 刷新界面
-        return msg, None
-    # <-------------- set format ------------->
-    arxiv_id = url_.split('/abs/')[-1]
-    if 'v' in arxiv_id: arxiv_id = arxiv_id[:10]
-    cached_translation_pdf = check_cached_translation_pdf(arxiv_id)
-    if cached_translation_pdf and allow_cache: return cached_translation_pdf, arxiv_id
-
-    url_tar = url_.replace('/abs/', '/e-print/')
-    translation_dir = pj(ARXIV_CACHE_DIR, arxiv_id, 'e-print')
-    extract_dst = pj(ARXIV_CACHE_DIR, arxiv_id, 'extract')
-    os.makedirs(translation_dir, exist_ok=True)
-    
-    # <-------------- download arxiv source file ------------->
-    dst = pj(translation_dir, arxiv_id+'.tar')
-    if os.path.exists(dst):
-        yield from update_ui_lastest_msg("调用缓存", chatbot=chatbot, history=history)  # 刷新界面
-    else:
-        yield from update_ui_lastest_msg("开始下载", chatbot=chatbot, history=history)  # 刷新界面
-        proxies = get_conf('proxies')
-        r = requests.get(url_tar, proxies=proxies)
-        with open(dst, 'wb+') as f:
-            f.write(r.content)
-    # <-------------- extract file ------------->
-    yield from update_ui_lastest_msg("下载完成", chatbot=chatbot, history=history)  # 刷新界面
-    from toolbox import extract_archive
-    extract_archive(file_path=dst, dest_dir=extract_dst)
-    return extract_dst, arxiv_id
-# ========================================= 插件主程序1 =====================================================    
-
-
-@CatchException
-def Latex英文纠错加PDF对比(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-    # <-------------- information about this plugin ------------->
-    chatbot.append([ "函数插件功能？",
-        "对整个Latex项目进行纠错, 用latex编译为PDF对修正处做高亮。函数插件贡献者: Binary-Husky。注意事项: 目前仅支持GPT3.5/GPT4，其他模型转化效果未知。目前对机器学习类文献转化效果最好，其他类型文献转化效果未知。仅在Windows系统进行了测试，其他操作系统表现未知。"])
-    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-    
-    # <-------------- more requirements ------------->
-    if ("advanced_arg" in plugin_kwargs) and (plugin_kwargs["advanced_arg"] == ""): plugin_kwargs.pop("advanced_arg")
-    more_req = plugin_kwargs.get("advanced_arg", "")
-    _switch_prompt_ = partial(switch_prompt, more_requirement=more_req)
-
-    # <-------------- check deps ------------->
-    try:
-        import glob, os, time, subprocess
-        subprocess.Popen(['pdflatex', '-version'])
-        from .latex_fns.latex_actions import Latex精细分解与转化, 编译Latex
-    except Exception as e:
-        chatbot.append([ f"解析项目: {txt}",
-            f"尝试执行Latex指令失败。Latex没有安装, 或者不在环境变量PATH中。安装方法https://tug.org/texlive/。报错信息\n\n```\n\n{trimmed_format_exc()}\n\n```\n\n"])
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        return
-    
-
-    # <-------------- clear history and read input ------------->
-    history = []
-    if os.path.exists(txt):
-        project_folder = txt
-    else:
-        if txt == "": txt = '空空如也的输入栏'
-        report_exception(chatbot, history, a = f"解析项目: {txt}", b = f"找不到本地项目或无权访问: {txt}")
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        return
-    file_manifest = [f for f in glob.glob(f'{project_folder}/**/*.tex', recursive=True)]
-    if len(file_manifest) == 0:
-        report_exception(chatbot, history, a = f"解析项目: {txt}", b = f"找不到任何.tex文件: {txt}")
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        return
-    
-
-    # <-------------- if is a zip/tar file ------------->
-    project_folder = desend_to_extracted_folder_if_exist(project_folder)
-
-
-    # <-------------- move latex project away from temp folder ------------->
-    project_folder = move_project(project_folder, arxiv_id=None)
-
-
-    # <-------------- if merge_translate_zh is already generated, skip gpt req ------------->
-    if not os.path.exists(project_folder + '/merge_proofread_en.tex'):
-        yield from Latex精细分解与转化(file_manifest, project_folder, llm_kwargs, plugin_kwargs, 
-                                chatbot, history, system_prompt, mode='proofread_en', switch_prompt=_switch_prompt_)
-
-
-    # <-------------- compile PDF ------------->
-    success = yield from 编译Latex(chatbot, history, main_file_original='merge', main_file_modified='merge_proofread_en', 
-                             work_folder_original=project_folder, work_folder_modified=project_folder, work_folder=project_folder)
-    
-
-    # <-------------- zip PDF ------------->
-    zip_res = zip_result(project_folder)
-    if success:
-        chatbot.append((f"成功啦", '请查收结果（压缩包）...'))
-        yield from update_ui(chatbot=chatbot, history=history); time.sleep(1) # 刷新界面
-        promote_file_to_downloadzone(file=zip_res, chatbot=chatbot)
-    else:
-        chatbot.append((f"失败了", '虽然PDF生成失败了, 但请查收结果（压缩包）, 内含已经翻译的Tex文档, 也是可读的, 您可以到Github Issue区, 用该压缩包+对话历史存档进行反馈 ...'))
-        yield from update_ui(chatbot=chatbot, history=history); time.sleep(1) # 刷新界面
-        promote_file_to_downloadzone(file=zip_res, chatbot=chatbot)
-
-    # <-------------- we are done ------------->
-    return success
-
-# ========================================= 插件主程序2 =====================================================    
-
-@CatchException
-def Latex翻译中文并重新编译PDF(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-    # <-------------- information about this plugin ------------->
-    chatbot.append([
-        "函数插件功能？",
-        "对整个Latex项目进行翻译, 生成中文PDF。函数插件贡献者: Binary-Husky。注意事项: 此插件Windows支持最佳，Linux下必须使用Docker安装，详见项目主README.md。目前仅支持GPT3.5/GPT4，其他模型转化效果未知。目前对机器学习类文献转化效果最好，其他类型文献转化效果未知。"])
-    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-
-    # <-------------- more requirements ------------->
-    if ("advanced_arg" in plugin_kwargs) and (plugin_kwargs["advanced_arg"] == ""): plugin_kwargs.pop("advanced_arg")
-    more_req = plugin_kwargs.get("advanced_arg", "")
-    no_cache = more_req.startswith("--no-cache")
-    if no_cache: more_req.lstrip("--no-cache")
-    allow_cache = not no_cache
-    _switch_prompt_ = partial(switch_prompt, more_requirement=more_req)
-
-    # <-------------- check deps ------------->
-    try:
-        import glob, os, time, subprocess
-        subprocess.Popen(['pdflatex', '-version'])
-        from .latex_fns.latex_actions import Latex精细分解与转化, 编译Latex
-    except Exception as e:
-        chatbot.append([ f"解析项目: {txt}",
-            f"尝试执行Latex指令失败。Latex没有安装, 或者不在环境变量PATH中。安装方法https://tug.org/texlive/。报错信息\n\n```\n\n{trimmed_format_exc()}\n\n```\n\n"])
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        return
-    
-
-    # <-------------- clear history and read input ------------->
-    history = []
-    txt, arxiv_id = yield from arxiv_download(chatbot, history, txt, allow_cache)
-    if txt.endswith('.pdf'):
-        report_exception(chatbot, history, a = f"解析项目: {txt}", b = f"发现已经存在翻译好的PDF文档")
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        return
-    
-
-    if os.path.exists(txt):
-        project_folder = txt
-    else:
-        if txt == "": txt = '空空如也的输入栏'
-        report_exception(chatbot, history, a = f"解析项目: {txt}", b = f"找不到本地项目或无法处理: {txt}")
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        return
-    
-    file_manifest = [f for f in glob.glob(f'{project_folder}/**/*.tex', recursive=True)]
-    if len(file_manifest) == 0:
-        report_exception(chatbot, history, a = f"解析项目: {txt}", b = f"找不到任何.tex文件: {txt}")
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        return
-    
-
-    # <-------------- if is a zip/tar file ------------->
-    project_folder = desend_to_extracted_folder_if_exist(project_folder)
-
-
-    # <-------------- move latex project away from temp folder ------------->
-    project_folder = move_project(project_folder, arxiv_id)
-
-
-    # <-------------- if merge_translate_zh is already generated, skip gpt req ------------->
-    if not os.path.exists(project_folder + '/merge_translate_zh.tex'):
-        yield from Latex精细分解与转化(file_manifest, project_folder, llm_kwargs, plugin_kwargs, 
-                                chatbot, history, system_prompt, mode='translate_zh', switch_prompt=_switch_prompt_)
-
-
-    # <-------------- compile PDF ------------->
-    success = yield from 编译Latex(chatbot, history, main_file_original='merge', main_file_modified='merge_translate_zh', mode='translate_zh', 
-                             work_folder_original=project_folder, work_folder_modified=project_folder, work_folder=project_folder)
-
-    # <-------------- zip PDF ------------->
-    zip_res = zip_result(project_folder)
-    if success:
-        chatbot.append((f"成功啦", '请查收结果（压缩包）...'))
-        yield from update_ui(chatbot=chatbot, history=history); time.sleep(1) # 刷新界面
-        promote_file_to_downloadzone(file=zip_res, chatbot=chatbot)
-    else:
-        chatbot.append((f"失败了", '虽然PDF生成失败了, 但请查收结果（压缩包）, 内含已经翻译的Tex文档, 您可以到Github Issue区, 用该压缩包进行反馈。如系统是Linux，请检查系统字体（见Github wiki） ...'))
-        yield from update_ui(chatbot=chatbot, history=history); time.sleep(1) # 刷新界面
-        promote_file_to_downloadzone(file=zip_res, chatbot=chatbot)
-
-
-    # <-------------- we are done ------------->
-    return success
--- a/crazy_functions/agent_fns/general.py
+++ b/crazy_functions/agent_fns/general.py
@@ -35,7 +35,11 @@ def gpt_academic_generate_oai_reply(
 class AutoGenGeneral(PluginMultiprocessManager):
    def gpt_academic_print_override(self, user_proxy, message, sender):
        # ⭐⭐ run in subprocess
-        self.child_conn.send(PipeCom("show", sender.name + "\n\n---\n\n" + message["content"]))
+        try:
+            print_msg = sender.name + "\n\n---\n\n" + message["content"]
+        except:
+            print_msg = sender.name + "\n\n---\n\n" + message
+        self.child_conn.send(PipeCom("show", print_msg))

    def gpt_academic_get_human_input(self, user_proxy, message):
        # ⭐⭐ run in subprocess
@@ -62,33 +66,33 @@ class AutoGenGeneral(PluginMultiprocessManager):
    def exe_autogen(self, input):
        # ⭐⭐ run in subprocess
        input = input.content
-        with ProxyNetworkActivate("AutoGen"):
-            code_execution_config = {"work_dir": self.autogen_work_dir, "use_docker": self.use_docker}
-            agents = self.define_agents()
-            user_proxy = None
-            assistant = None
-            for agent_kwargs in agents:
-                agent_cls = agent_kwargs.pop('cls')
-                kwargs = {
-                    'llm_config':self.llm_kwargs,
-                    'code_execution_config':code_execution_config
-                }
-                kwargs.update(agent_kwargs)
-                agent_handle = agent_cls(**kwargs)
-                agent_handle._print_received_message = lambda a,b: self.gpt_academic_print_override(agent_kwargs, a, b)
-                for d in agent_handle._reply_func_list:
-                    if hasattr(d['reply_func'],'__name__') and d['reply_func'].__name__ == 'generate_oai_reply':
-                        d['reply_func'] = gpt_academic_generate_oai_reply
-                if agent_kwargs['name'] == 'user_proxy':
-                    agent_handle.get_human_input = lambda a: self.gpt_academic_get_human_input(user_proxy, a)
-                    user_proxy = agent_handle
-                if agent_kwargs['name'] == 'assistant': assistant = agent_handle
-            try:
-                if user_proxy is None or assistant is None: raise Exception("用户代理或助理代理未定义")
+        code_execution_config = {"work_dir": self.autogen_work_dir, "use_docker": self.use_docker}
+        agents = self.define_agents()
+        user_proxy = None
+        assistant = None
+        for agent_kwargs in agents:
+            agent_cls = agent_kwargs.pop('cls')
+            kwargs = {
+                'llm_config':self.llm_kwargs,
+                'code_execution_config':code_execution_config
+            }
+            kwargs.update(agent_kwargs)
+            agent_handle = agent_cls(**kwargs)
+            agent_handle._print_received_message = lambda a,b: self.gpt_academic_print_override(agent_kwargs, a, b)
+            for d in agent_handle._reply_func_list:
+                if hasattr(d['reply_func'],'__name__') and d['reply_func'].__name__ == 'generate_oai_reply':
+                    d['reply_func'] = gpt_academic_generate_oai_reply
+            if agent_kwargs['name'] == 'user_proxy':
+                agent_handle.get_human_input = lambda a: self.gpt_academic_get_human_input(user_proxy, a)
+                user_proxy = agent_handle
+            if agent_kwargs['name'] == 'assistant': assistant = agent_handle
+        try:
+            if user_proxy is None or assistant is None: raise Exception("用户代理或助理代理未定义")
+            with ProxyNetworkActivate("AutoGen"):
                user_proxy.initiate_chat(assistant, message=input)
-            except Exception as e:
-                tb_str = '```\n' + trimmed_format_exc() + '```'
-                self.child_conn.send(PipeCom("done", "AutoGen 执行失败: \n\n" + tb_str))
+        except Exception as e:
+            tb_str = '```\n' + trimmed_format_exc() + '```'
+            self.child_conn.send(PipeCom("done", "AutoGen 执行失败: \n\n" + tb_str))

    def subprocess_worker(self, child_conn):
        # ⭐⭐ run in subprocess
--- a/crazy_functions/agent_fns/pipe.py
+++ b/crazy_functions/agent_fns/pipe.py
@@ -9,7 +9,7 @@ class PipeCom:


 class PluginMultiprocessManager:
-    def __init__(self, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+    def __init__(self, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
        # ⭐ run in main process
        self.autogen_work_dir = os.path.join(get_log_folder("autogen"), gen_time_str())
        self.previous_work_dir_files = {}
@@ -18,7 +18,7 @@ class PluginMultiprocessManager:
        self.chatbot = chatbot
        self.history = history
        self.system_prompt = system_prompt
-        # self.web_port = web_port
+        # self.user_request = user_request
        self.alive = True
        self.use_docker = get_conf("AUTOGEN_USE_DOCKER")
        self.last_user_input = ""
--- a/crazy_functions/chatglm微调工具.py
+++ b/crazy_functions/chatglm微调工具.py
@@ -32,7 +32,7 @@ def string_to_options(arguments):
    return args

@CatchException
-def 微调数据集生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 微调数据集生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    """
    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -40,7 +40,7 @@ def 微调数据集生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, syst
    chatbot         聊天显示框的句柄，用于显示给用户
    history         聊天历史，前情提要
    system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
    """
    history = []    # 清空历史，以免输入溢出
    chatbot.append(("这是什么功能？", "[Local Message] 微调数据集生成"))
@@ -80,7 +80,7 @@ def 微调数据集生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, syst


@CatchException
-def 启动微调(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 启动微调(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    """
    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -88,7 +88,7 @@ def 启动微调(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt
    chatbot         聊天显示框的句柄，用于显示给用户
    history         聊天历史，前情提要
    system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
    """
    import subprocess
    history = []    # 清空历史，以免输入溢出
--- a/crazy_functions/crazy_utils.py
+++ b/crazy_functions/crazy_utils.py
@@ -12,7 +12,7 @@ def input_clipping(inputs, history, max_token_limit):
    mode = 'input-and-history'
    # 当 输入部分的token占比 小于 全文的一半时，只裁剪历史
    input_token_num = get_token_num(inputs)
-    if input_token_num < max_token_limit//2: 
+    if input_token_num < max_token_limit//2:
        mode = 'only-history'
        max_token_limit = max_token_limit - input_token_num

@@ -21,7 +21,7 @@ def input_clipping(inputs, history, max_token_limit):
    n_token = get_token_num('\n'.join(everything))
    everything_token = [get_token_num(e) for e in everything]
    delta = max(everything_token) // 16 # 截断时的颗粒度
-        
+
    while n_token > max_token_limit:
        where = np.argmax(everything_token)
        encoded = enc.encode(everything[where], disallowed_special=())
@@ -38,9 +38,9 @@ def input_clipping(inputs, history, max_token_limit):
    return inputs, history

 def request_gpt_model_in_new_thread_with_ui_alive(
-        inputs, inputs_show_user, llm_kwargs, 
+        inputs, inputs_show_user, llm_kwargs,
        chatbot, history, sys_prompt, refresh_interval=0.2,
-        handle_token_exceed=True, 
+        handle_token_exceed=True,
        retry_times_at_unknown_error=2,
        ):
    """
@@ -77,7 +77,7 @@ def request_gpt_model_in_new_thread_with_ui_alive(
        exceeded_cnt = 0
        while True:
            # watchdog error
-            if len(mutable) >= 2 and (time.time()-mutable[1]) > watch_dog_patience: 
+            if len(mutable) >= 2 and (time.time()-mutable[1]) > watch_dog_patience:
                raise RuntimeError("检测到程序终止。")
            try:
                # 【第一种情况】：顺利完成
@@ -140,12 +140,12 @@ def can_multi_process(llm):
    if llm.startswith('api2d-'): return True
    if llm.startswith('azure-'): return True
    if llm.startswith('spark'): return True
-    if llm.startswith('zhipuai'): return True
+    if llm.startswith('zhipuai') or llm.startswith('glm-'): return True
    return False

 def request_gpt_model_multi_threads_with_very_awesome_ui_and_high_efficiency(
-        inputs_array, inputs_show_user_array, llm_kwargs, 
-        chatbot, history_array, sys_prompt_array, 
+        inputs_array, inputs_show_user_array, llm_kwargs,
+        chatbot, history_array, sys_prompt_array,
        refresh_interval=0.2, max_workers=-1, scroller_max_len=30,
        handle_token_exceed=True, show_user_at_complete=False,
        retry_times_at_unknown_error=2,
@@ -189,7 +189,7 @@ def request_gpt_model_multi_threads_with_very_awesome_ui_and_high_efficiency(
    # 屏蔽掉 chatglm的多线程，可能会导致严重卡顿
    if not can_multi_process(llm_kwargs['llm_model']):
        max_workers = 1
-        
+
    executor = ThreadPoolExecutor(max_workers=max_workers)
    n_frag = len(inputs_array)
    # 用户反馈
@@ -214,7 +214,7 @@ def request_gpt_model_multi_threads_with_very_awesome_ui_and_high_efficiency(
            try:
                # 【第一种情况】：顺利完成
                gpt_say = predict_no_ui_long_connection(
-                    inputs=inputs, llm_kwargs=llm_kwargs, history=history, 
+                    inputs=inputs, llm_kwargs=llm_kwargs, history=history,
                    sys_prompt=sys_prompt, observe_window=mutable[index], console_slience=True
                )
                mutable[index][2] = "已成功"
@@ -246,7 +246,7 @@ def request_gpt_model_multi_threads_with_very_awesome_ui_and_high_efficiency(
                print(tb_str)
                gpt_say += f"[Local Message] 警告，线程{index}在执行过程中遭遇问题, Traceback：\n\n{tb_str}\n\n"
                if len(mutable[index][0]) > 0: gpt_say += "此线程失败前收到的回答：\n\n" + mutable[index][0]
-                if retry_op > 0: 
+                if retry_op > 0:
                    retry_op -= 1
                    wait = random.randint(5, 20)
                    if ("Rate limit reached" in tb_str) or ("Too Many Requests" in tb_str):
@@ -284,12 +284,11 @@ def request_gpt_model_multi_threads_with_very_awesome_ui_and_high_efficiency(
        # 在前端打印些好玩的东西
        for thread_index, _ in enumerate(worker_done):
            print_something_really_funny = "[ ...`"+mutable[thread_index][0][-scroller_max_len:].\
-                replace('\n', '').replace('`', '.').replace(
-                    ' ', '.').replace('<br/>', '.....').replace('$', '.')+"`... ]"
+                replace('\n', '').replace('`', '.').replace(' ', '.').replace('<br/>', '.....').replace('$', '.')+"`... ]"
            observe_win.append(print_something_really_funny)
        # 在前端打印些好玩的东西
-        stat_str = ''.join([f'`{mutable[thread_index][2]}`: {obs}\n\n' 
-                            if not done else f'`{mutable[thread_index][2]}`\n\n' 
+        stat_str = ''.join([f'`{mutable[thread_index][2]}`: {obs}\n\n'
+                            if not done else f'`{mutable[thread_index][2]}`\n\n'
                            for thread_index, done, obs in zip(range(len(worker_done)), worker_done, observe_win)])
        # 在前端打印些好玩的东西
        chatbot[-1] = [chatbot[-1][0], f'多线程操作已经开始，完成情况: \n\n{stat_str}' + ''.join(['.']*(cnt % 10+1))]
@@ -303,7 +302,7 @@ def request_gpt_model_multi_threads_with_very_awesome_ui_and_high_efficiency(
    for inputs_show_user, f in zip(inputs_show_user_array, futures):
        gpt_res = f.result()
        gpt_response_collection.extend([inputs_show_user, gpt_res])
-    
+
    # 是否在结束时，在界面上显示结果
    if show_user_at_complete:
        for inputs_show_user, f in zip(inputs_show_user_array, futures):
@@ -353,7 +352,7 @@ def read_and_clean_pdf_text(fp):
            if wtf['size'] not in fsize_statiscs: fsize_statiscs[wtf['size']] = 0
            fsize_statiscs[wtf['size']] += len(wtf['text'])
        return max(fsize_statiscs, key=fsize_statiscs.get)
-        
+
    def ffsize_same(a,b):
        """
        提取字体大小是否近似相等
@@ -389,7 +388,7 @@ def read_and_clean_pdf_text(fp):
            if index == 0:
                page_one_meta = [" ".join(["".join([wtf['text'] for wtf in l['spans']]) for l in t['lines']]).replace(
                    '- ', '') for t in text_areas['blocks'] if 'lines' in t]
-                
+
        ############################## <第 2 步，获取正文主字体> ##################################
        try:
            fsize_statiscs = {}
@@ -405,7 +404,7 @@ def read_and_clean_pdf_text(fp):
        mega_sec = []
        sec = []
        for index, line in enumerate(meta_line):
-            if index == 0: 
+            if index == 0:
                sec.append(line[fc])
                continue
            if REMOVE_FOOT_NOTE:
@@ -502,12 +501,12 @@ def get_files_from_everything(txt, type): # type='.md'
    """
    这个函数是用来获取指定目录下所有指定类型（如.md）的文件，并且对于网络上的文件，也可以获取它。
    下面是对每个参数和返回值的说明：
-    参数 
-    - txt: 路径或网址，表示要搜索的文件或者文件夹路径或网络上的文件。 
+    参数
+    - txt: 路径或网址，表示要搜索的文件或者文件夹路径或网络上的文件。
    - type: 字符串，表示要搜索的文件类型。默认是.md。
-    返回值 
-    - success: 布尔值，表示函数是否成功执行。 
-    - file_manifest: 文件路径列表，里面包含以指定类型为后缀名的所有文件的绝对路径。 
+    返回值
+    - success: 布尔值，表示函数是否成功执行。
+    - file_manifest: 文件路径列表，里面包含以指定类型为后缀名的所有文件的绝对路径。
    - project_folder: 字符串，表示文件所在的文件夹路径。如果是网络上的文件，就是临时文件夹的路径。
    该函数详细注释已添加，请确认是否满足您的需要。
    """
@@ -571,7 +570,7 @@ class nougat_interface():
    def NOUGAT_parse_pdf(self, fp, chatbot, history):
        from toolbox import update_ui_lastest_msg

-        yield from update_ui_lastest_msg("正在解析论文, 请稍候。进度：正在排队, 等待线程锁...", 
+        yield from update_ui_lastest_msg("正在解析论文, 请稍候。进度：正在排队, 等待线程锁...",
                                         chatbot=chatbot, history=history, delay=0)
        self.threadLock.acquire()
        import glob, threading, os
@@ -579,7 +578,7 @@ class nougat_interface():
        dst = os.path.join(get_log_folder(plugin_name='nougat'), gen_time_str())
        os.makedirs(dst)

-        yield from update_ui_lastest_msg("正在解析论文, 请稍候。进度：正在加载NOUGAT... （提示：首次运行需要花费较长时间下载NOUGAT参数）", 
+        yield from update_ui_lastest_msg("正在解析论文, 请稍候。进度：正在加载NOUGAT... （提示：首次运行需要花费较长时间下载NOUGAT参数）",
                                         chatbot=chatbot, history=history, delay=0)
        self.nougat_with_timeout(f'nougat --out "{os.path.abspath(dst)}" "{os.path.abspath(fp)}"', os.getcwd(), timeout=3600)
        res = glob.glob(os.path.join(dst,'*.mmd'))
--- a/crazy_functions/diagram_fns/file_tree.py
+++ b/crazy_functions/diagram_fns/file_tree.py
@@ -0,0 +1,122 @@
+import os
+from textwrap import indent
+
+class FileNode:
+    def __init__(self, name):
+        self.name = name
+        self.children = []
+        self.is_leaf = False
+        self.level = 0
+        self.parenting_ship = []
+        self.comment = ""
+        self.comment_maxlen_show = 50
+        
+    @staticmethod
+    def add_linebreaks_at_spaces(string, interval=10):
+        return '\n'.join(string[i:i+interval] for i in range(0, len(string), interval))
+
+    def sanitize_comment(self, comment):
+        if len(comment) > self.comment_maxlen_show: suf = '...'
+        else: suf = ''
+        comment = comment[:self.comment_maxlen_show]
+        comment = comment.replace('\"', '').replace('`', '').replace('\n', '').replace('`', '').replace('$', '')
+        comment = self.add_linebreaks_at_spaces(comment, 10)
+        return '`' + comment + suf + '`'
+
+    def add_file(self, file_path, file_comment):
+        directory_names, file_name = os.path.split(file_path)
+        current_node = self
+        level = 1
+        if directory_names == "":
+            new_node = FileNode(file_name)
+            current_node.children.append(new_node)
+            new_node.is_leaf = True
+            new_node.comment = self.sanitize_comment(file_comment)
+            new_node.level = level
+            current_node = new_node
+        else:
+            dnamesplit = directory_names.split(os.sep)
+            for i, directory_name in enumerate(dnamesplit):
+                found_child = False
+                level += 1
+                for child in current_node.children:
+                    if child.name == directory_name:
+                        current_node = child
+                        found_child = True
+                        break
+                if not found_child:
+                    new_node = FileNode(directory_name)
+                    current_node.children.append(new_node)
+                    new_node.level = level - 1
+                    current_node = new_node
+            term = FileNode(file_name)
+            term.level = level
+            term.comment = self.sanitize_comment(file_comment)
+            term.is_leaf = True
+            current_node.children.append(term)
+
+    def print_files_recursively(self, level=0, code="R0"):
+        print('    '*level + self.name + ' ' + str(self.is_leaf) + ' ' + str(self.level))
+        for j, child in enumerate(self.children):
+            child.print_files_recursively(level=level+1, code=code+str(j))
+            self.parenting_ship.extend(child.parenting_ship)
+            p1 = f"""{code}[\"🗎{self.name}\"]""" if self.is_leaf else f"""{code}[[\"📁{self.name}\"]]"""
+            p2 = """ --> """
+            p3 = f"""{code+str(j)}[\"🗎{child.name}\"]""" if child.is_leaf else f"""{code+str(j)}[[\"📁{child.name}\"]]"""
+            edge_code = p1 + p2 + p3
+            if edge_code in self.parenting_ship:
+                continue
+            self.parenting_ship.append(edge_code)
+        if self.comment != "":
+            pc1 = f"""{code}[\"🗎{self.name}\"]""" if self.is_leaf else f"""{code}[[\"📁{self.name}\"]]"""
+            pc2 = f""" -.-x """
+            pc3 = f"""C{code}[\"{self.comment}\"]:::Comment"""
+            edge_code = pc1 + pc2 + pc3
+            self.parenting_ship.append(edge_code)
+
+
+MERMAID_TEMPLATE = r"""
+```mermaid
+flowchart LR
+    %% <gpt_academic_hide_mermaid_code> 一个特殊标记，用于在生成mermaid图表时隐藏代码块
+    classDef Comment stroke-dasharray: 5 5
+    subgraph {graph_name}
+{relationship}
+    end
+```
+"""
+
+def build_file_tree_mermaid_diagram(file_manifest, file_comments, graph_name):
+    # Create the root node
+    file_tree_struct = FileNode("root")
+    # Build the tree structure
+    for file_path, file_comment in zip(file_manifest, file_comments):
+        file_tree_struct.add_file(file_path, file_comment)
+    file_tree_struct.print_files_recursively()
+    cc = "\n".join(file_tree_struct.parenting_ship)
+    ccc = indent(cc, prefix=" "*8)
+    return MERMAID_TEMPLATE.format(graph_name=graph_name, relationship=ccc)
+
+if __name__ == "__main__":
+    # File manifest
+    file_manifest = [
+        "cradle_void_terminal.ipynb",
+        "tests/test_utils.py",
+        "tests/test_plugins.py",
+        "tests/test_llms.py",
+        "config.py",
+        "build/ChatGLM-6b-onnx-u8s8/chatglm-6b-int8-onnx-merged/model_weights_0.bin",
+        "crazy_functions/latex_fns/latex_actions.py",
+        "crazy_functions/latex_fns/latex_toolbox.py"
+    ]
+    file_comments = [
+        "根据位置和名称，可能是一个模块的初始化文件根据位置和名称，可能是一个模块的初始化文件根据位置和名称，可能是一个模块的初始化文件",
+        "包含一些用于文本处理和模型微调的函数和装饰器包含一些用于文本处理和模型微调的函数和装饰器包含一些用于文本处理和模型微调的函数和装饰器",
+        "用于构建HTML报告的类和方法用于构建HTML报告的类和方法用于构建HTML报告的类和方法",
+        "包含了用于文本切分的函数，以及处理PDF文件的示例代码包含了用于文本切分的函数，以及处理PDF文件的示例代码包含了用于文本切分的函数，以及处理PDF文件的示例代码",
+        "用于解析和翻译PDF文件的功能和相关辅助函数用于解析和翻译PDF文件的功能和相关辅助函数用于解析和翻译PDF文件的功能和相关辅助函数",
+        "是一个包的初始化文件，用于初始化包的属性和导入模块是一个包的初始化文件，用于初始化包的属性和导入模块是一个包的初始化文件，用于初始化包的属性和导入模块",
+        "用于加载和分割文件中的文本的通用文件加载器用于加载和分割文件中的文本的通用文件加载器用于加载和分割文件中的文本的通用文件加载器",
+        "包含了用于构建和管理向量数据库的函数和类包含了用于构建和管理向量数据库的函数和类包含了用于构建和管理向量数据库的函数和类",
+    ]
+    print(build_file_tree_mermaid_diagram(file_manifest, file_comments, "项目文件树"))
--- a/crazy_functions/latex_fns/latex_toolbox.py
+++ b/crazy_functions/latex_fns/latex_toolbox.py
@@ -1,15 +1,18 @@
 import os, shutil
 import re
 import numpy as np
+
 PRESERVE = 0
 TRANSFORM = 1

 pj = os.path.join

-class LinkedListNode():
+
+class LinkedListNode:
    """
    Linked List Node
    """
+
    def __init__(self, string, preserve=True) -> None:
        self.string = string
        self.preserve = preserve
@@ -18,41 +21,47 @@ class LinkedListNode():
        # self.begin_line = 0
        # self.begin_char = 0

+
 def convert_to_linklist(text, mask):
    root = LinkedListNode("", preserve=True)
    current_node = root
    for c, m, i in zip(text, mask, range(len(text))):
-        if (m==PRESERVE and current_node.preserve) \
-            or (m==TRANSFORM and not current_node.preserve):
+        if (m == PRESERVE and current_node.preserve) or (
+            m == TRANSFORM and not current_node.preserve
+        ):
            # add
            current_node.string += c
        else:
-            current_node.next = LinkedListNode(c, preserve=(m==PRESERVE))
+            current_node.next = LinkedListNode(c, preserve=(m == PRESERVE))
            current_node = current_node.next
    return root

+
 def post_process(root):
    # 修复括号
    node = root
    while True:
        string = node.string
-        if node.preserve: 
+        if node.preserve:
            node = node.next
-            if node is None: break
+            if node is None:
+                break
            continue
+
        def break_check(string):
-            str_stack = [""] # (lv, index)
+            str_stack = [""]  # (lv, index)
            for i, c in enumerate(string):
-                if c == '{':
-                    str_stack.append('{')
-                elif c == '}':
+                if c == "{":
+                    str_stack.append("{")
+                elif c == "}":
                    if len(str_stack) == 1:
-                        print('stack fix')
+                        print("stack fix")
                        return i
                    str_stack.pop(-1)
                else:
                    str_stack[-1] += c
            return -1
+
        bp = break_check(string)

        if bp == -1:
@@ -69,51 +78,66 @@ def post_process(root):
            node.next = q

        node = node.next
-        if node is None: break
+        if node is None:
+            break

    # 屏蔽空行和太短的句子
    node = root
    while True:
-        if len(node.string.strip('\n').strip(''))==0: node.preserve = True
-        if len(node.string.strip('\n').strip(''))<42: node.preserve = True
+        if len(node.string.strip("\n").strip("")) == 0:
+            node.preserve = True
+        if len(node.string.strip("\n").strip("")) < 42:
+            node.preserve = True
        node = node.next
-        if node is None: break
+        if node is None:
+            break
    node = root
    while True:
        if node.next and node.preserve and node.next.preserve:
            node.string += node.next.string
            node.next = node.next.next
        node = node.next
-        if node is None: break
+        if node is None:
+            break

    # 将前后断行符脱离
    node = root
    prev_node = None
    while True:
        if not node.preserve:
-            lstriped_ = node.string.lstrip().lstrip('\n')
-            if (prev_node is not None) and (prev_node.preserve) and (len(lstriped_)!=len(node.string)):
-                prev_node.string += node.string[:-len(lstriped_)]
+            lstriped_ = node.string.lstrip().lstrip("\n")
+            if (
+                (prev_node is not None)
+                and (prev_node.preserve)
+                and (len(lstriped_) != len(node.string))
+            ):
+                prev_node.string += node.string[: -len(lstriped_)]
                node.string = lstriped_
-            rstriped_ = node.string.rstrip().rstrip('\n')
-            if (node.next is not None) and (node.next.preserve) and (len(rstriped_)!=len(node.string)):
-                node.next.string = node.string[len(rstriped_):] + node.next.string
+            rstriped_ = node.string.rstrip().rstrip("\n")
+            if (
+                (node.next is not None)
+                and (node.next.preserve)
+                and (len(rstriped_) != len(node.string))
+            ):
+                node.next.string = node.string[len(rstriped_) :] + node.next.string
                node.string = rstriped_
-        # =====
+        # =-=-=
        prev_node = node
        node = node.next
-        if node is None: break
+        if node is None:
+            break

    # 标注节点的行数范围
    node = root
    n_line = 0
    expansion = 2
    while True:
-        n_l = node.string.count('\n')
-        node.range = [n_line-expansion, n_line+n_l+expansion]   # 失败时，扭转的范围
-        n_line = n_line+n_l
+        n_l = node.string.count("\n")
+        node.range = [n_line - expansion, n_line + n_l + expansion]  # 失败时，扭转的范围
+        n_line = n_line + n_l
        node = node.next
-        if node is None: break
+        if node is None:
+            break
    return root


@@ -128,97 +152,125 @@ def set_forbidden_text(text, mask, pattern, flags=0):
    """
    Add a preserve text area in this paper
    e.g. with pattern = r"\\begin\{algorithm\}(.*?)\\end\{algorithm\}"
-    you can mask out (mask = PRESERVE so that text become untouchable for GPT) 
+    you can mask out (mask = PRESERVE so that text become untouchable for GPT)
    everything between "\begin{equation}" and "\end{equation}"
    """
-    if isinstance(pattern, list): pattern = '|'.join(pattern)
+    if isinstance(pattern, list):
+        pattern = "|".join(pattern)
    pattern_compile = re.compile(pattern, flags)
    for res in pattern_compile.finditer(text):
-        mask[res.span()[0]:res.span()[1]] = PRESERVE
+        mask[res.span()[0] : res.span()[1]] = PRESERVE
    return text, mask

+
 def reverse_forbidden_text(text, mask, pattern, flags=0, forbid_wrapper=True):
    """
    Move area out of preserve area (make text editable for GPT)
-    count the number of the braces so as to catch compelete text area. 
+    count the number of the braces so as to catch compelete text area.
    e.g.
-    \begin{abstract} blablablablablabla. \end{abstract} 
+    \begin{abstract} blablablablablabla. \end{abstract}
    """
-    if isinstance(pattern, list): pattern = '|'.join(pattern)
+    if isinstance(pattern, list):
+        pattern = "|".join(pattern)
    pattern_compile = re.compile(pattern, flags)
    for res in pattern_compile.finditer(text):
        if not forbid_wrapper:
-            mask[res.span()[0]:res.span()[1]] = TRANSFORM
+            mask[res.span()[0] : res.span()[1]] = TRANSFORM
        else:
-            mask[res.regs[0][0]: res.regs[1][0]] = PRESERVE   # '\\begin{abstract}'
-            mask[res.regs[1][0]: res.regs[1][1]] = TRANSFORM   # abstract
-            mask[res.regs[1][1]: res.regs[0][1]] = PRESERVE   # abstract
+            mask[res.regs[0][0] : res.regs[1][0]] = PRESERVE  # '\\begin{abstract}'
+            mask[res.regs[1][0] : res.regs[1][1]] = TRANSFORM  # abstract
+            mask[res.regs[1][1] : res.regs[0][1]] = PRESERVE  # abstract
    return text, mask

+
 def set_forbidden_text_careful_brace(text, mask, pattern, flags=0):
    """
    Add a preserve text area in this paper (text become untouchable for GPT).
-    count the number of the braces so as to catch compelete text area. 
+    count the number of the braces so as to catch compelete text area.
    e.g.
-    \caption{blablablablabla\texbf{blablabla}blablabla.} 
+    \caption{blablablablabla\texbf{blablabla}blablabla.}
    """
    pattern_compile = re.compile(pattern, flags)
    for res in pattern_compile.finditer(text):
        brace_level = -1
        p = begin = end = res.regs[0][0]
-        for _ in range(1024*16):
-            if text[p] == '}' and brace_level == 0: break
-            elif text[p] == '}':  brace_level -= 1
-            elif text[p] == '{':  brace_level += 1
+        for _ in range(1024 * 16):
+            if text[p] == "}" and brace_level == 0:
+                break
+            elif text[p] == "}":
+                brace_level -= 1
+            elif text[p] == "{":
+                brace_level += 1
            p += 1
-        end = p+1
+        end = p + 1
        mask[begin:end] = PRESERVE
    return text, mask

-def reverse_forbidden_text_careful_brace(text, mask, pattern, flags=0, forbid_wrapper=True):
+
+def reverse_forbidden_text_careful_brace(
+    text, mask, pattern, flags=0, forbid_wrapper=True
+):
    """
    Move area out of preserve area (make text editable for GPT)
-    count the number of the braces so as to catch compelete text area. 
+    count the number of the braces so as to catch compelete text area.
    e.g.
-    \caption{blablablablabla\texbf{blablabla}blablabla.} 
+    \caption{blablablablabla\texbf{blablabla}blablabla.}
    """
    pattern_compile = re.compile(pattern, flags)
    for res in pattern_compile.finditer(text):
        brace_level = 0
        p = begin = end = res.regs[1][0]
-        for _ in range(1024*16):
-            if text[p] == '}' and brace_level == 0: break
-            elif text[p] == '}':  brace_level -= 1
-            elif text[p] == '{':  brace_level += 1
+        for _ in range(1024 * 16):
+            if text[p] == "}" and brace_level == 0:
+                break
+            elif text[p] == "}":
+                brace_level -= 1
+            elif text[p] == "{":
+                brace_level += 1
            p += 1
        end = p
        mask[begin:end] = TRANSFORM
        if forbid_wrapper:
-            mask[res.regs[0][0]:begin] = PRESERVE
-            mask[end:res.regs[0][1]] = PRESERVE
+            mask[res.regs[0][0] : begin] = PRESERVE
+            mask[end : res.regs[0][1]] = PRESERVE
    return text, mask

+
 def set_forbidden_text_begin_end(text, mask, pattern, flags=0, limit_n_lines=42):
    """
    Find all \begin{} ... \end{} text block that with less than limit_n_lines lines.
    Add it to preserve area
    """
    pattern_compile = re.compile(pattern, flags)
+
    def search_with_line_limit(text, mask):
        for res in pattern_compile.finditer(text):
            cmd = res.group(1)  # begin{what}
-            this = res.group(2) # content between begin and end
-            this_mask = mask[res.regs[2][0]:res.regs[2][1]]
-            white_list = ['document', 'abstract', 'lemma', 'definition', 'sproof', 
-                          'em', 'emph', 'textit', 'textbf', 'itemize', 'enumerate']
-            if (cmd in white_list) or this.count('\n') >= limit_n_lines: # use a magical number 42
+            this = res.group(2)  # content between begin and end
+            this_mask = mask[res.regs[2][0] : res.regs[2][1]]
+            white_list = [
+                "document",
+                "abstract",
+                "lemma",
+                "definition",
+                "sproof",
+                "em",
+                "emph",
+                "textit",
+                "textbf",
+                "itemize",
+                "enumerate",
+            ]
+            if (cmd in white_list) or this.count(
+                "\n"
+            ) >= limit_n_lines:  # use a magical number 42
                this, this_mask = search_with_line_limit(this, this_mask)
-                mask[res.regs[2][0]:res.regs[2][1]] = this_mask
+                mask[res.regs[2][0] : res.regs[2][1]] = this_mask
            else:
-                mask[res.regs[0][0]:res.regs[0][1]] = PRESERVE
+                mask[res.regs[0][0] : res.regs[0][1]] = PRESERVE
        return text, mask
-    return search_with_line_limit(text, mask) 

+    return search_with_line_limit(text, mask)


 """
@@ -227,6 +279,7 @@ Latex Merge File
 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 """

+
 def find_main_tex_file(file_manifest, mode):
    """
    在多Tex文档中，寻找主文件，必须包含documentclass，返回找到的第一个。
@@ -234,27 +287,36 @@ def find_main_tex_file(file_manifest, mode):
    """
    canidates = []
    for texf in file_manifest:
-        if os.path.basename(texf).startswith('merge'):
+        if os.path.basename(texf).startswith("merge"):
            continue
-        with open(texf, 'r', encoding='utf8', errors='ignore') as f:
+        with open(texf, "r", encoding="utf8", errors="ignore") as f:
            file_content = f.read()
-        if r'\documentclass' in file_content:
+        if r"\documentclass" in file_content:
            canidates.append(texf)
        else:
            continue

    if len(canidates) == 0:
-        raise RuntimeError('无法找到一个主Tex文件（包含documentclass关键字）')
+        raise RuntimeError("无法找到一个主Tex文件（包含documentclass关键字）")
    elif len(canidates) == 1:
        return canidates[0]
-    else: # if len(canidates) >= 2 通过一些Latex模板中常见（但通常不会出现在正文）的单词，对不同latex源文件扣分，取评分最高者返回
+    else:  # if len(canidates) >= 2 通过一些Latex模板中常见（但通常不会出现在正文）的单词，对不同latex源文件扣分，取评分最高者返回
        canidates_score = []
        # 给出一些判定模板文档的词作为扣分项
-        unexpected_words = ['\\LaTeX', 'manuscript', 'Guidelines', 'font', 'citations', 'rejected', 'blind review', 'reviewers']
-        expected_words = ['\\input', '\\ref', '\\cite']
+        unexpected_words = [
+            "\\LaTeX",
+            "manuscript",
+            "Guidelines",
+            "font",
+            "citations",
+            "rejected",
+            "blind review",
+            "reviewers",
+        ]
+        expected_words = ["\\input", "\\ref", "\\cite"]
        for texf in canidates:
            canidates_score.append(0)
-            with open(texf, 'r', encoding='utf8', errors='ignore') as f:
+            with open(texf, "r", encoding="utf8", errors="ignore") as f:
                file_content = f.read()
                file_content = rm_comments(file_content)
            for uw in unexpected_words:
@@ -263,9 +325,10 @@ def find_main_tex_file(file_manifest, mode):
            for uw in expected_words:
                if uw in file_content:
                    canidates_score[-1] += 1
-        select = np.argmax(canidates_score) # 取评分最高者返回
+        select = np.argmax(canidates_score)  # 取评分最高者返回
        return canidates[select]
-    
+
+
 def rm_comments(main_file):
    new_file_remove_comment_lines = []
    for l in main_file.splitlines():
@@ -274,30 +337,39 @@ def rm_comments(main_file):
            pass
        else:
            new_file_remove_comment_lines.append(l)
-    main_file = '\n'.join(new_file_remove_comment_lines)
+    main_file = "\n".join(new_file_remove_comment_lines)
    # main_file = re.sub(r"\\include{(.*?)}", r"\\input{\1}", main_file)  # 将 \include 命令转换为 \input 命令
-    main_file = re.sub(r'(?<!\\)%.*', '', main_file)  # 使用正则表达式查找半行注释, 并替换为空字符串
+    main_file = re.sub(r"(?<!\\)%.*", "", main_file)  # 使用正则表达式查找半行注释, 并替换为空字符串
    return main_file

+
 def find_tex_file_ignore_case(fp):
    dir_name = os.path.dirname(fp)
    base_name = os.path.basename(fp)
    # 如果输入的文件路径是正确的
-    if os.path.isfile(pj(dir_name, base_name)): return pj(dir_name, base_name)
+    if os.path.isfile(pj(dir_name, base_name)):
+        return pj(dir_name, base_name)
    # 如果不正确，试着加上.tex后缀试试
-    if not base_name.endswith('.tex'): base_name+='.tex'
-    if os.path.isfile(pj(dir_name, base_name)): return pj(dir_name, base_name)
+    if not base_name.endswith(".tex"):
+        base_name += ".tex"
+    if os.path.isfile(pj(dir_name, base_name)):
+        return pj(dir_name, base_name)
    # 如果还找不到，解除大小写限制，再试一次
    import glob
-    for f in glob.glob(dir_name+'/*.tex'):
+
+    for f in glob.glob(dir_name + "/*.tex"):
        base_name_s = os.path.basename(fp)
        base_name_f = os.path.basename(f)
-        if base_name_s.lower() == base_name_f.lower(): return f
+        if base_name_s.lower() == base_name_f.lower():
+            return f
        # 试着加上.tex后缀试试
-        if not base_name_s.endswith('.tex'): base_name_s+='.tex'
-        if base_name_s.lower() == base_name_f.lower(): return f
+        if not base_name_s.endswith(".tex"):
+            base_name_s += ".tex"
+        if base_name_s.lower() == base_name_f.lower():
+            return f
    return None

+
 def merge_tex_files_(project_foler, main_file, mode):
    """
    Merge Tex project recrusively
@@ -309,18 +381,18 @@ def merge_tex_files_(project_foler, main_file, mode):
        fp_ = find_tex_file_ignore_case(fp)
        if fp_:
            try:
-                with open(fp_, 'r', encoding='utf-8', errors='replace') as fx: c = fx.read()
+                with open(fp_, "r", encoding="utf-8", errors="replace") as fx:
+                    c = fx.read()
            except:
                c = f"\n\nWarning from GPT-Academic: LaTex source file is missing!\n\n"
        else:
-            raise RuntimeError(f'找不到{fp}，Tex源文件缺失！')
+            raise RuntimeError(f"找不到{fp}，Tex源文件缺失！")
        c = merge_tex_files_(project_foler, c, mode)
-        main_file = main_file[:s.span()[0]] + c + main_file[s.span()[1]:]
+        main_file = main_file[: s.span()[0]] + c + main_file[s.span()[1] :]
    return main_file


 def find_title_and_abs(main_file):
-
    def extract_abstract_1(text):
        pattern = r"\\abstract\{(.*?)\}"
        match = re.search(pattern, text, re.DOTALL)
@@ -362,21 +434,30 @@ def merge_tex_files(project_foler, main_file, mode):
    main_file = merge_tex_files_(project_foler, main_file, mode)
    main_file = rm_comments(main_file)

-    if mode == 'translate_zh':
+    if mode == "translate_zh":
        # find paper documentclass
-        pattern = re.compile(r'\\documentclass.*\n')
+        pattern = re.compile(r"\\documentclass.*\n")
        match = pattern.search(main_file)
        assert match is not None, "Cannot find documentclass statement!"
        position = match.end()
-        add_ctex = '\\usepackage{ctex}\n'
-        add_url = '\\usepackage{url}\n' if '{url}' not in main_file else ''
+        add_ctex = "\\usepackage{ctex}\n"
+        add_url = "\\usepackage{url}\n" if "{url}" not in main_file else ""
        main_file = main_file[:position] + add_ctex + add_url + main_file[position:]
        # fontset=windows
        import platform
-        main_file = re.sub(r"\\documentclass\[(.*?)\]{(.*?)}", r"\\documentclass[\1,fontset=windows,UTF8]{\2}",main_file)
-        main_file = re.sub(r"\\documentclass{(.*?)}", r"\\documentclass[fontset=windows,UTF8]{\1}",main_file)
+
+        main_file = re.sub(
+            r"\\documentclass\[(.*?)\]{(.*?)}",
+            r"\\documentclass[\1,fontset=windows,UTF8]{\2}",
+            main_file,
+        )
+        main_file = re.sub(
+            r"\\documentclass{(.*?)}",
+            r"\\documentclass[fontset=windows,UTF8]{\1}",
+            main_file,
+        )
        # find paper abstract
-        pattern_opt1 = re.compile(r'\\begin\{abstract\}.*\n')
+        pattern_opt1 = re.compile(r"\\begin\{abstract\}.*\n")
        pattern_opt2 = re.compile(r"\\abstract\{(.*?)\}", flags=re.DOTALL)
        match_opt1 = pattern_opt1.search(main_file)
        match_opt2 = pattern_opt2.search(main_file)
@@ -385,7 +466,9 @@ def merge_tex_files(project_foler, main_file, mode):
            main_file = insert_abstract(main_file)
        match_opt1 = pattern_opt1.search(main_file)
        match_opt2 = pattern_opt2.search(main_file)
-        assert (match_opt1 is not None) or (match_opt2 is not None), "Cannot find paper abstract section!"
+        assert (match_opt1 is not None) or (
+            match_opt2 is not None
+        ), "Cannot find paper abstract section!"
    return main_file


@@ -395,6 +478,7 @@ The GPT-Academic program cannot find abstract section in this paper.
 \end{abstract}
 """

+
 def insert_abstract(tex_content):
    if "\\maketitle" in tex_content:
        # find the position of "\maketitle"
@@ -402,7 +486,13 @@ def insert_abstract(tex_content):
        # find the nearest ending line
        end_line_index = tex_content.find("\n", find_index)
        # insert "abs_str" on the next line
-        modified_tex = tex_content[:end_line_index+1] + '\n\n' + insert_missing_abs_str + '\n\n' + tex_content[end_line_index+1:]
+        modified_tex = (
+            tex_content[: end_line_index + 1]
+            + "\n\n"
+            + insert_missing_abs_str
+            + "\n\n"
+            + tex_content[end_line_index + 1 :]
+        )
        return modified_tex
    elif r"\begin{document}" in tex_content:
        # find the position of "\maketitle"
@@ -410,29 +500,39 @@ def insert_abstract(tex_content):
        # find the nearest ending line
        end_line_index = tex_content.find("\n", find_index)
        # insert "abs_str" on the next line
-        modified_tex = tex_content[:end_line_index+1] + '\n\n' + insert_missing_abs_str + '\n\n' + tex_content[end_line_index+1:]
+        modified_tex = (
+            tex_content[: end_line_index + 1]
+            + "\n\n"
+            + insert_missing_abs_str
+            + "\n\n"
+            + tex_content[end_line_index + 1 :]
+        )
        return modified_tex
    else:
        return tex_content

+
 """
 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 Post process
 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 """
+
+
 def mod_inbraket(match):
    """
-    为啥chatgpt会把cite里面的逗号换成中文逗号呀 
+    为啥chatgpt会把cite里面的逗号换成中文逗号呀
    """
    # get the matched string
    cmd = match.group(1)
    str_to_modify = match.group(2)
    # modify the matched string
-    str_to_modify = str_to_modify.replace('：', ':')    # 前面是中文冒号，后面是英文冒号
-    str_to_modify = str_to_modify.replace('，', ',')    # 前面是中文逗号，后面是英文逗号
+    str_to_modify = str_to_modify.replace("：", ":")  # 前面是中文冒号，后面是英文冒号
+    str_to_modify = str_to_modify.replace("，", ",")  # 前面是中文逗号，后面是英文逗号
    # str_to_modify = 'BOOM'
    return "\\" + cmd + "{" + str_to_modify + "}"

+
 def fix_content(final_tex, node_string):
    """
    Fix common GPT errors to increase success rate
@@ -443,10 +543,10 @@ def fix_content(final_tex, node_string):
    final_tex = re.sub(r"\\([a-z]{2,10})\{([^\}]*?)\}", mod_inbraket, string=final_tex)

    if "Traceback" in final_tex and "[Local Message]" in final_tex:
-        final_tex = node_string # 出问题了，还原原文
-    if node_string.count('\\begin') != final_tex.count('\\begin'):
-        final_tex = node_string # 出问题了，还原原文
-    if node_string.count('\_') > 0 and node_string.count('\_') > final_tex.count('\_'):
+        final_tex = node_string  # 出问题了，还原原文
+    if node_string.count("\\begin") != final_tex.count("\\begin"):
+        final_tex = node_string  # 出问题了，还原原文
+    if node_string.count("\_") > 0 and node_string.count("\_") > final_tex.count("\_"):
        # walk and replace any _ without \
        final_tex = re.sub(r"(?<!\\)_", "\\_", final_tex)

@@ -454,24 +554,32 @@ def fix_content(final_tex, node_string):
        # this function count the number of { and }
        brace_level = 0
        for c in string:
-            if c == "{": brace_level += 1
-            elif c == "}": brace_level -= 1
+            if c == "{":
+                brace_level += 1
+            elif c == "}":
+                brace_level -= 1
        return brace_level
+
    def join_most(tex_t, tex_o):
        # this function join translated string and original string when something goes wrong
        p_t = 0
        p_o = 0
+
        def find_next(string, chars, begin):
            p = begin
            while p < len(string):
-                if string[p] in chars: return p, string[p]
+                if string[p] in chars:
+                    return p, string[p]
                p += 1
            return None, None
+
        while True:
-            res1, char = find_next(tex_o, ['{','}'], p_o)
-            if res1 is None: break
+            res1, char = find_next(tex_o, ["{", "}"], p_o)
+            if res1 is None:
+                break
            res2, char = find_next(tex_t, [char], p_t)
-            if res2 is None: break
+            if res2 is None:
+                break
            p_o = res1 + 1
            p_t = res2 + 1
        return tex_t[:p_t] + tex_o[p_o:]
@@ -480,10 +588,14 @@ def fix_content(final_tex, node_string):
        # 出问题了，还原部分原文，保证括号正确
        final_tex = join_most(final_tex, node_string)
    return final_tex
-    
+
+
 def compile_latex_with_timeout(command, cwd, timeout=60):
    import subprocess
-    process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=cwd)
+
+    process = subprocess.Popen(
+        command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=cwd
+    )
    try:
        stdout, stderr = process.communicate(timeout=timeout)
    except subprocess.TimeoutExpired:
@@ -493,43 +605,52 @@ def compile_latex_with_timeout(command, cwd, timeout=60):
        return False
    return True

+
 def run_in_subprocess_wrapper_func(func, args, kwargs, return_dict, exception_dict):
    import sys
+
    try:
        result = func(*args, **kwargs)
-        return_dict['result'] = result
+        return_dict["result"] = result
    except Exception as e:
        exc_info = sys.exc_info()
-        exception_dict['exception'] = exc_info
+        exception_dict["exception"] = exc_info
+

 def run_in_subprocess(func):
    import multiprocessing
+
    def wrapper(*args, **kwargs):
        return_dict = multiprocessing.Manager().dict()
        exception_dict = multiprocessing.Manager().dict()
-        process = multiprocessing.Process(target=run_in_subprocess_wrapper_func, 
-                                            args=(func, args, kwargs, return_dict, exception_dict))
+        process = multiprocessing.Process(
+            target=run_in_subprocess_wrapper_func,
+            args=(func, args, kwargs, return_dict, exception_dict),
+        )
        process.start()
        process.join()
        process.close()
-        if 'exception' in exception_dict:
+        if "exception" in exception_dict:
            # ooops, the subprocess ran into an exception
-            exc_info = exception_dict['exception']
+            exc_info = exception_dict["exception"]
            raise exc_info[1].with_traceback(exc_info[2])
-        if 'result' in return_dict.keys():
+        if "result" in return_dict.keys():
            # If the subprocess ran successfully, return the result
-            return return_dict['result']
+            return return_dict["result"]
+
    return wrapper

+
 def _merge_pdfs(pdf1_path, pdf2_path, output_path):
-    import PyPDF2   # PyPDF2这个库有严重的内存泄露问题，把它放到子进程中运行，从而方便内存的释放
+    import PyPDF2  # PyPDF2这个库有严重的内存泄露问题，把它放到子进程中运行，从而方便内存的释放
+
    Percent = 0.95
    # raise RuntimeError('PyPDF2 has a serious memory leak problem, please use other tools to merge PDF files.')
    # Open the first PDF file
-    with open(pdf1_path, 'rb') as pdf1_file:
+    with open(pdf1_path, "rb") as pdf1_file:
        pdf1_reader = PyPDF2.PdfFileReader(pdf1_file)
        # Open the second PDF file
-        with open(pdf2_path, 'rb') as pdf2_file:
+        with open(pdf2_path, "rb") as pdf2_file:
            pdf2_reader = PyPDF2.PdfFileReader(pdf2_file)
            # Create a new PDF file to store the merged pages
            output_writer = PyPDF2.PdfFileWriter()
@@ -549,14 +670,25 @@ def _merge_pdfs(pdf1_path, pdf2_path, output_path):
                    page2 = PyPDF2.PageObject.createBlankPage(pdf1_reader)
                # Create a new empty page with double width
                new_page = PyPDF2.PageObject.createBlankPage(
-                    width = int(int(page1.mediaBox.getWidth()) + int(page2.mediaBox.getWidth()) * Percent),
-                    height = max(page1.mediaBox.getHeight(), page2.mediaBox.getHeight())
+                    width=int(
+                        int(page1.mediaBox.getWidth())
+                        + int(page2.mediaBox.getWidth()) * Percent
+                    ),
+                    height=max(page1.mediaBox.getHeight(), page2.mediaBox.getHeight()),
                )
                new_page.mergeTranslatedPage(page1, 0, 0)
-                new_page.mergeTranslatedPage(page2, int(int(page1.mediaBox.getWidth())-int(page2.mediaBox.getWidth())* (1-Percent)), 0)
+                new_page.mergeTranslatedPage(
+                    page2,
+                    int(
+                        int(page1.mediaBox.getWidth())
+                        - int(page2.mediaBox.getWidth()) * (1 - Percent)
+                    ),
+                    0,
+                )
                output_writer.addPage(new_page)
            # Save the merged PDF file
-            with open(output_path, 'wb') as output_file:
+            with open(output_path, "wb") as output_file:
                output_writer.write(output_file)

-merge_pdfs = run_in_subprocess(_merge_pdfs) # PyPDF2这个库有严重的内存泄露问题，把它放到子进程中运行，从而方便内存的释放
+
+merge_pdfs = run_in_subprocess(_merge_pdfs)  # PyPDF2这个库有严重的内存泄露问题，把它放到子进程中运行，从而方便内存的释放
--- a/crazy_functions/pdf_fns/parse_word.py
+++ b/crazy_functions/pdf_fns/parse_word.py
@@ -0,0 +1,85 @@
+from crazy_functions.crazy_utils import read_and_clean_pdf_text, get_files_from_everything
+import os
+import re
+def extract_text_from_files(txt, chatbot, history):
+    """
+    查找pdf/md/word并获取文本内容并返回状态以及文本
+
+    输入参数 Args:
+        chatbot: chatbot inputs and outputs （用户界面对话窗口句柄，用于数据流可视化）
+        history (list): List of chat history （历史，对话历史列表）
+
+    输出 Returns:
+        文件是否存在(bool)
+        final_result(list):文本内容
+        page_one(list):第一页内容/摘要
+        file_manifest(list):文件路径
+        excption(string):需要用户手动处理的信息,如没出错则保持为空
+    """
+
+    final_result = []
+    page_one = []
+    file_manifest = []
+    excption = ""
+
+    if txt == "": 
+        final_result.append(txt)
+        return False, final_result, page_one, file_manifest, excption   #如输入区内容不是文件则直接返回输入区内容
+    
+    #查找输入区内容中的文件
+    file_pdf,pdf_manifest,folder_pdf = get_files_from_everything(txt, '.pdf')
+    file_md,md_manifest,folder_md = get_files_from_everything(txt, '.md')
+    file_word,word_manifest,folder_word = get_files_from_everything(txt, '.docx')
+    file_doc,doc_manifest,folder_doc = get_files_from_everything(txt, '.doc')
+
+    if file_doc:
+        excption = "word"
+        return False, final_result, page_one, file_manifest, excption
+    
+    file_num = len(pdf_manifest) + len(md_manifest) + len(word_manifest)
+    if file_num == 0:
+        final_result.append(txt)
+        return False, final_result, page_one, file_manifest, excption   #如输入区内容不是文件则直接返回输入区内容
+    
+    if file_pdf:
+        try:    # 尝试导入依赖，如果缺少依赖，则给出安装建议
+            import fitz
+        except:
+            excption = "pdf"
+            return False, final_result, page_one, file_manifest, excption
+        for index, fp in enumerate(pdf_manifest):
+            file_content, pdf_one = read_and_clean_pdf_text(fp) # （尝试）按照章节切割PDF
+            file_content = file_content.encode('utf-8', 'ignore').decode()   # avoid reading non-utf8 chars
+            pdf_one = str(pdf_one).encode('utf-8', 'ignore').decode()  # avoid reading non-utf8 chars
+            final_result.append(file_content)
+            page_one.append(pdf_one)
+            file_manifest.append(os.path.relpath(fp, folder_pdf))
+
+    if file_md:
+        for index, fp in enumerate(md_manifest):
+            with open(fp, 'r', encoding='utf-8', errors='replace') as f:
+                file_content = f.read()
+            file_content = file_content.encode('utf-8', 'ignore').decode()
+            headers = re.findall(r'^#\s(.*)$', file_content, re.MULTILINE)  #接下来提取md中的一级/二级标题作为摘要
+            if len(headers) > 0: 
+                page_one.append("\n".join(headers)) #合并所有的标题,以换行符分割
+            else:
+                page_one.append("")
+            final_result.append(file_content)
+            file_manifest.append(os.path.relpath(fp, folder_md))
+
+    if file_word:
+        try:    # 尝试导入依赖，如果缺少依赖，则给出安装建议
+            from docx import Document
+        except:
+            excption = "word_pip"
+            return False, final_result, page_one, file_manifest, excption
+        for index, fp in enumerate(word_manifest):
+            doc = Document(fp)
+            file_content = '\n'.join([p.text for p in doc.paragraphs])
+            file_content = file_content.encode('utf-8', 'ignore').decode()
+            page_one.append(file_content[:200])
+            final_result.append(file_content)
+            file_manifest.append(os.path.relpath(fp, folder_word))
+            
+    return True, final_result, page_one, file_manifest, excption
--- a/crazy_functions/下载arxiv论文翻译摘要.py
+++ b/crazy_functions/下载arxiv论文翻译摘要.py
@@ -130,7 +130,7 @@ def get_name(_url_):


@CatchException
-def 下载arxiv论文并翻译摘要(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 下载arxiv论文并翻译摘要(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):

    CRAZY_FUNCTION_INFO = "下载arxiv论文并翻译摘要，函数插件作者[binary-husky]。正在提取摘要并下载PDF文档……"
    import glob
--- a/crazy_functions/互动小游戏.py
+++ b/crazy_functions/互动小游戏.py
@@ -5,7 +5,7 @@ from request_llms.bridge_all import predict_no_ui_long_connection
 from crazy_functions.game_fns.game_utils import get_code_block, is_same_thing

@CatchException
-def 随机小游戏(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 随机小游戏(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    from crazy_functions.game_fns.game_interactive_story import MiniGame_ResumeStory
    # 清空历史
    history = []
@@ -23,7 +23,7 @@ def 随机小游戏(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_


@CatchException
-def 随机小游戏1(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 随机小游戏1(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    from crazy_functions.game_fns.game_ascii_art import MiniGame_ASCII_Art
    # 清空历史
    history = []
--- a/crazy_functions/交互功能函数模板.py
+++ b/crazy_functions/交互功能函数模板.py
@@ -3,7 +3,7 @@ from .crazy_utils import request_gpt_model_in_new_thread_with_ui_alive


@CatchException
-def 交互功能模板函数(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 交互功能模板函数(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    """
    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
    llm_kwargs      gpt模型参数, 如温度和top_p等, 一般原样传递下去就行
@@ -11,7 +11,7 @@ def 交互功能模板函数(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
    chatbot         聊天显示框的句柄，用于显示给用户
    history         聊天历史，前情提要
    system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
    """
    history = []    # 清空历史，以免输入溢出
    chatbot.append(("这是什么功能？", "交互功能函数模板。在执行完成之后, 可以将自身的状态存储到cookie中, 等待用户的再次调用。"))
--- a/crazy_functions/函数动态生成.py
+++ b/crazy_functions/函数动态生成.py
@@ -139,7 +139,7 @@ def get_recent_file_prompt_support(chatbot):
    return path

@CatchException
-def 函数动态生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 函数动态生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    """
    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -147,7 +147,7 @@ def 函数动态生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_
    chatbot         聊天显示框的句柄，用于显示给用户
    history         聊天历史，前情提要
    system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
    """

    # 清空历史
--- a/crazy_functions/命令行助手.py
+++ b/crazy_functions/命令行助手.py
@@ -4,7 +4,7 @@ from .crazy_utils import input_clipping
 import copy, json

@CatchException
-def 命令行助手(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 命令行助手(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    """
    txt             输入栏用户输入的文本, 例如需要翻译的一段话, 再例如一个包含了待处理文件的路径
    llm_kwargs      gpt模型参数, 如温度和top_p等, 一般原样传递下去就行
@@ -12,7 +12,7 @@ def 命令行助手(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_pro
    chatbot         聊天显示框的句柄, 用于显示给用户
    history         聊天历史, 前情提要
    system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
    """
    # 清空历史, 以免输入溢出
    history = []
--- a/crazy_functions/图片生成.py
+++ b/crazy_functions/图片生成.py
@@ -93,7 +93,7 @@ def edit_image(llm_kwargs, prompt, image_path, resolution="1024x1024", model="da


@CatchException
-def 图片生成_DALLE2(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 图片生成_DALLE2(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    """
    txt             输入栏用户输入的文本,例如需要翻译的一段话,再例如一个包含了待处理文件的路径
    llm_kwargs      gpt模型参数,如温度和top_p等,一般原样传递下去就行
@@ -101,7 +101,7 @@ def 图片生成_DALLE2(prompt, llm_kwargs, plugin_kwargs, chatbot, history, sys
    chatbot         聊天显示框的句柄,用于显示给用户
    history         聊天历史,前情提要
    system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
    """
    history = []    # 清空历史,以免输入溢出
    if prompt.strip() == "":
@@ -123,7 +123,7 @@ def 图片生成_DALLE2(prompt, llm_kwargs, plugin_kwargs, chatbot, history, sys


@CatchException
-def 图片生成_DALLE3(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 图片生成_DALLE3(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    history = []    # 清空历史,以免输入溢出
    if prompt.strip() == "":
        chatbot.append((prompt, "[Local Message] 图像生成提示为空白，请在“输入区”输入图像生成提示。"))
@@ -209,7 +209,7 @@ class ImageEditState(GptAcademicState):
        return all([x['value'] is not None for x in self.req])

@CatchException
-def 图片修改_DALLE2(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 图片修改_DALLE2(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    # 尚未完成
    history = []    # 清空历史
    state = ImageEditState.get_state(chatbot, ImageEditState)
--- a/crazy_functions/多智能体.py
+++ b/crazy_functions/多智能体.py
@@ -21,7 +21,7 @@ def remove_model_prefix(llm):


@CatchException
-def 多智能体终端(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 多智能体终端(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    """
    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -29,7 +29,7 @@ def 多智能体终端(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_
    chatbot         聊天显示框的句柄，用于显示给用户
    history         聊天历史，前情提要
    system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
    """
    # 检查当前的模型是否符合要求
    supported_llms = [
@@ -50,14 +50,7 @@ def 多智能体终端(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_
        return
    if model_info[llm_kwargs['llm_model']]["endpoint"] is not None: # 如果不是本地模型，加载API_KEY
        llm_kwargs['api_key'] = select_api_key(llm_kwargs['api_key'], llm_kwargs['llm_model'])
-    
-    # 检查当前的模型是否符合要求
-    API_URL_REDIRECT = get_conf('API_URL_REDIRECT')
-    if len(API_URL_REDIRECT) > 0:
-        chatbot.append([f"处理任务: {txt}", f"暂不支持中转."])
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        return
-    
+
    # 尝试导入依赖，如果缺少依赖，则给出安装建议
    try:
        import autogen
@@ -96,7 +89,7 @@ def 多智能体终端(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_
        history = []
        chatbot.append(["正在启动: 多智能体终端", "插件动态生成, 执行开始, 作者 Microsoft & Binary-Husky."])
        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        executor = AutoGenMath(llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port)
+        executor = AutoGenMath(llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request)
        persistent_class_multi_user_manager.set(persistent_key, executor)
        exit_reason = yield from executor.main_process_ui_control(txt, create_or_resume="create")

--- a/crazy_functions/对话历史存档.py
+++ b/crazy_functions/对话历史存档.py
@@ -69,7 +69,7 @@ def read_file_to_chat(chatbot, history, file_name):
    return chatbot, history    

@CatchException
-def 对话历史存档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 对话历史存档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    """
    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -77,7 +77,7 @@ def 对话历史存档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_
    chatbot         聊天显示框的句柄，用于显示给用户
    history         聊天历史，前情提要
    system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
    """

    chatbot.append(("保存当前对话", 
@@ -91,7 +91,7 @@ def hide_cwd(str):
    return str.replace(current_path, replace_path)

@CatchException
-def 载入对话历史存档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 载入对话历史存档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    """
    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -99,7 +99,7 @@ def 载入对话历史存档(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
    chatbot         聊天显示框的句柄，用于显示给用户
    history         聊天历史，前情提要
    system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
    """
    from .crazy_utils import get_files_from_everything
    success, file_manifest, _ = get_files_from_everything(txt, type='.html')
@@ -126,7 +126,7 @@ def 载入对话历史存档(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
        return

@CatchException
-def 删除所有本地对话历史记录(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 删除所有本地对话历史记录(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    """
    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -134,7 +134,7 @@ def 删除所有本地对话历史记录(txt, llm_kwargs, plugin_kwargs, chatbot
    chatbot         聊天显示框的句柄，用于显示给用户
    history         聊天历史，前情提要
    system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
    """

    import glob, os
--- a/crazy_functions/总结word文档.py
+++ b/crazy_functions/总结word文档.py
@@ -79,7 +79,7 @@ def 解析docx(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot


@CatchException
-def 总结word文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 总结word文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    import glob, os

    # 基本信息：功能、贡献者
--- a/crazy_functions/批量Markdown翻译.py
+++ b/crazy_functions/批量Markdown翻译.py
@@ -153,7 +153,7 @@ def get_files_from_everything(txt, preference=''):


@CatchException
-def Markdown英译中(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def Markdown英译中(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    # 基本信息：功能、贡献者
    chatbot.append([
        "函数插件功能？",
@@ -193,7 +193,7 @@ def Markdown英译中(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_p


@CatchException
-def Markdown中译英(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def Markdown中译英(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    # 基本信息：功能、贡献者
    chatbot.append([
        "函数插件功能？",
@@ -226,7 +226,7 @@ def Markdown中译英(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_p


@CatchException
-def Markdown翻译指定语言(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def Markdown翻译指定语言(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    # 基本信息：功能、贡献者
    chatbot.append([
        "函数插件功能？",
--- a/crazy_functions/批量总结PDF文档.py
+++ b/crazy_functions/批量总结PDF文档.py
@@ -101,7 +101,7 @@ do not have too much repetitive information, numerical values using the original


@CatchException
-def 批量总结PDF文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 批量总结PDF文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    import glob, os

    # 基本信息：功能、贡献者
--- a/crazy_functions/批量总结PDF文档pdfminer.py
+++ b/crazy_functions/批量总结PDF文档pdfminer.py
@@ -124,7 +124,7 @@ def 解析Paper(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbo


@CatchException
-def 批量总结PDF文档pdfminer(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 批量总结PDF文档pdfminer(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    history = []    # 清空历史，以免输入溢出
    import glob, os

--- a/crazy_functions/批量翻译PDF文档_NOUGAT.py
+++ b/crazy_functions/批量翻译PDF文档_NOUGAT.py
@@ -48,7 +48,7 @@ def markdown_to_dict(article_content):


@CatchException
-def 批量翻译PDF文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 批量翻译PDF文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):

    disable_auto_promotion(chatbot)
    # 基本信息：功能、贡献者
--- a/crazy_functions/批量翻译PDF文档_多线程.py
+++ b/crazy_functions/批量翻译PDF文档_多线程.py
@@ -10,7 +10,7 @@ import os


@CatchException
-def 批量翻译PDF文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 批量翻译PDF文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):

    disable_auto_promotion(chatbot)
    # 基本信息：功能、贡献者
--- a/crazy_functions/数学动画生成manim.py
+++ b/crazy_functions/数学动画生成manim.py
@@ -1,6 +1,7 @@
-from toolbox import CatchException, update_ui, gen_time_str
-from .crazy_utils import request_gpt_model_in_new_thread_with_ui_alive
-from .crazy_utils import input_clipping
+import os
+from toolbox import CatchException, update_ui, gen_time_str, promote_file_to_downloadzone
+from crazy_functions.crazy_utils import request_gpt_model_in_new_thread_with_ui_alive
+from crazy_functions.crazy_utils import input_clipping

 def inspect_dependency(chatbot, history):
    # 尝试导入依赖，如果缺少依赖，则给出安装建议
@@ -27,9 +28,10 @@ def eval_manim(code):
    class_name = get_class_name(code)

    try: 
+        time_str = gen_time_str()
        subprocess.check_output([sys.executable, '-c', f"from gpt_log.MyAnimation import {class_name}; {class_name}().render()"])
-        shutil.move('media/videos/1080p60/{class_name}.mp4', f'gpt_log/{class_name}-{gen_time_str()}.mp4')
-        return f'gpt_log/{gen_time_str()}.mp4'
+        shutil.move(f'media/videos/1080p60/{class_name}.mp4', f'gpt_log/{class_name}-{time_str}.mp4')
+        return f'gpt_log/{time_str}.mp4'
    except subprocess.CalledProcessError as e:
        output = e.output.decode()
        print(f"Command returned non-zero exit status {e.returncode}: {output}.")
@@ -48,7 +50,7 @@ def get_code_block(reply):
    return matches[0].strip('python') #  code block

@CatchException
-def 动画生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 动画生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    """
    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -56,7 +58,7 @@ def 动画生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt
    chatbot         聊天显示框的句柄，用于显示给用户
    history         聊天历史，前情提要
    system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
    """
    # 清空历史，以免输入溢出
    history = []    
@@ -94,6 +96,8 @@ def 动画生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt
    res = eval_manim(code)

    chatbot.append(("生成的视频文件路径", res))
+    if os.path.exists(res):
+        promote_file_to_downloadzone(res, chatbot=chatbot)
    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 界面更新

 # 在这里放一些网上搜集的demo，辅助gpt生成代码
--- a/crazy_functions/理解PDF文档内容.py
+++ b/crazy_functions/理解PDF文档内容.py
@@ -63,7 +63,7 @@ def 解析PDF(file_name, llm_kwargs, plugin_kwargs, chatbot, history, system_pro


@CatchException
-def 理解PDF文档内容标准文件输入(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 理解PDF文档内容标准文件输入(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    import glob, os

    # 基本信息：功能、贡献者
--- a/crazy_functions/生成函数注释.py
+++ b/crazy_functions/生成函数注释.py
@@ -36,7 +36,7 @@ def 生成函数注释(file_manifest, project_folder, llm_kwargs, plugin_kwargs,


@CatchException
-def 批量生成函数注释(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 批量生成函数注释(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    history = []    # 清空历史，以免输入溢出
    import glob, os
    if os.path.exists(txt):
--- a/crazy_functions/生成多种Mermaid图表.py
+++ b/crazy_functions/生成多种Mermaid图表.py
@@ -0,0 +1,296 @@
+from toolbox import CatchException, update_ui, report_exception
+from .crazy_utils import request_gpt_model_in_new_thread_with_ui_alive
+import datetime
+
+#以下是每类图表的PROMPT
+SELECT_PROMPT = """
+“{subject}”
+=============
+以上是从文章中提取的摘要,将会使用这些摘要绘制图表。请你选择一个合适的图表类型:
+1 流程图
+2 序列图
+3 类图
+4 饼图
+5 甘特图
+6 状态图
+7 实体关系图
+8 象限提示图
+不需要解释原因，仅需要输出单个不带任何标点符号的数字。
+"""
+#没有思维导图!!!测试发现模型始终会优先选择思维导图
+#流程图
+PROMPT_1 = """
+请你给出围绕“{subject}”的逻辑关系图，使用mermaid语法，mermaid语法举例：
+```mermaid
+graph TD
+    P(编程) --> L1(Python)
+    P(编程) --> L2(C)
+    P(编程) --> L3(C++)
+    P(编程) --> L4(Javascipt)
+    P(编程) --> L5(PHP)
+```
+"""
+#序列图
+PROMPT_2 = """
+请你给出围绕“{subject}”的序列图，使用mermaid语法，mermaid语法举例：
+```mermaid
+sequenceDiagram
+    participant A as 用户
+    participant B as 系统
+    A->>B: 登录请求
+    B->>A: 登录成功
+    A->>B: 获取数据
+    B->>A: 返回数据
+```
+"""
+#类图
+PROMPT_3 = """
+请你给出围绕“{subject}”的类图，使用mermaid语法，mermaid语法举例：
+```mermaid
+classDiagram
+    Class01 <|-- AveryLongClass : Cool
+    Class03 *-- Class04
+    Class05 o-- Class06
+    Class07 .. Class08
+    Class09 --> C2 : Where am i?
+    Class09 --* C3
+    Class09 --|> Class07
+    Class07 : equals()
+    Class07 : Object[] elementData
+    Class01 : size()
+    Class01 : int chimp
+    Class01 : int gorilla
+    Class08 <--> C2: Cool label
+```
+"""
+#饼图
+PROMPT_4 = """
+请你给出围绕“{subject}”的饼图，使用mermaid语法，mermaid语法举例：
+```mermaid
+pie title Pets adopted by volunteers
+    "狗" : 386
+    "猫" : 85
+    "兔子" : 15
+```
+"""
+#甘特图
+PROMPT_5 = """
+请你给出围绕“{subject}”的甘特图，使用mermaid语法，mermaid语法举例：
+```mermaid
+gantt
+    title 项目开发流程
+    dateFormat  YYYY-MM-DD
+    section 设计
+    需求分析 :done, des1, 2024-01-06,2024-01-08
+    原型设计 :active, des2, 2024-01-09, 3d
+    UI设计 : des3, after des2, 5d
+    section 开发
+    前端开发 :2024-01-20, 10d
+    后端开发 :2024-01-20, 10d
+```
+"""
+#状态图
+PROMPT_6 = """
+请你给出围绕“{subject}”的状态图，使用mermaid语法，mermaid语法举例：
+```mermaid
+stateDiagram-v2
+   [*] --> Still
+    Still --> [*]
+    Still --> Moving
+    Moving --> Still
+    Moving --> Crash
+    Crash --> [*]
+```
+"""
+#实体关系图
+PROMPT_7 = """
+请你给出围绕“{subject}”的实体关系图，使用mermaid语法，mermaid语法举例：
+```mermaid
+erDiagram
+    CUSTOMER ||--o{ ORDER : places
+    ORDER ||--|{ LINE-ITEM : contains
+    CUSTOMER {
+        string name
+        string id
+    }
+    ORDER {
+        string orderNumber
+        date orderDate
+        string customerID
+    }
+    LINE-ITEM {
+        number quantity
+        string productID
+    }
+```
+"""
+#象限提示图
+PROMPT_8 = """
+请你给出围绕“{subject}”的象限图，使用mermaid语法，mermaid语法举例：
+```mermaid
+graph LR
+    A[Hard skill] --> B(Programming)
+    A[Hard skill] --> C(Design)
+    D[Soft skill] --> E(Coordination)
+    D[Soft skill] --> F(Communication)
+```
+"""
+#思维导图
+PROMPT_9 = """
+{subject}
+==========
+请给出上方内容的思维导图，充分考虑其之间的逻辑，使用mermaid语法，mermaid语法举例：
+```mermaid
+mindmap
+  root((mindmap))
+    Origins
+      Long history
+      ::icon(fa fa-book)
+      Popularisation
+        British popular psychology author Tony Buzan
+    Research
+      On effectiveness<br/>and features
+      On Automatic creation
+        Uses
+            Creative techniques
+            Strategic planning
+            Argument mapping
+    Tools
+      Pen and paper
+      Mermaid
+```
+"""
+
+def 解析历史输入(history,llm_kwargs,file_manifest,chatbot,plugin_kwargs):
+    ############################## <第 0 步，切割输入> ##################################
+    # 借用PDF切割中的函数对文本进行切割
+    TOKEN_LIMIT_PER_FRAGMENT = 2500
+    txt = str(history).encode('utf-8', 'ignore').decode()   # avoid reading non-utf8 chars
+    from crazy_functions.pdf_fns.breakdown_txt import breakdown_text_to_satisfy_token_limit
+    txt = breakdown_text_to_satisfy_token_limit(txt=txt, limit=TOKEN_LIMIT_PER_FRAGMENT, llm_model=llm_kwargs['llm_model'])
+    ############################## <第 1 步，迭代地历遍整个文章，提取精炼信息> ##################################
+    results = []
+    MAX_WORD_TOTAL = 4096
+    n_txt = len(txt)
+    last_iteration_result = "从以下文本中提取摘要。"
+    if n_txt >= 20: print('文章极长，不能达到预期效果')
+    for i in range(n_txt):
+        NUM_OF_WORD = MAX_WORD_TOTAL // n_txt
+        i_say = f"Read this section, recapitulate the content of this section with less than {NUM_OF_WORD} words in Chinese: {txt[i]}"
+        i_say_show_user = f"[{i+1}/{n_txt}] Read this section, recapitulate the content of this section with less than {NUM_OF_WORD} words: {txt[i][:200]} ...."
+        gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive(i_say, i_say_show_user,  # i_say=真正给chatgpt的提问， i_say_show_user=给用户看的提问
+                                                                           llm_kwargs, chatbot, 
+                                                                           history=["The main content of the previous section is?", last_iteration_result], # 迭代上一次的结果
+                                                                           sys_prompt="Extracts the main content from the text section where it is located for graphing purposes, answer me with Chinese."  # 提示
+                                                                        ) 
+        results.append(gpt_say)
+        last_iteration_result = gpt_say
+    ############################## <第 2 步，根据整理的摘要选择图表类型> ##################################
+    if ("advanced_arg" in plugin_kwargs) and (plugin_kwargs["advanced_arg"] == ""): plugin_kwargs.pop("advanced_arg")
+    gpt_say = plugin_kwargs.get("advanced_arg", "")     #将图表类型参数赋值为插件参数  
+    results_txt = '\n'.join(results)    #合并摘要
+    if gpt_say not in ['1','2','3','4','5','6','7','8','9']:    #如插件参数不正确则使用对话模型判断
+        i_say_show_user = f'接下来将判断适合的图表类型,如连续3次判断失败将会使用流程图进行绘制'; gpt_say = "[Local Message] 收到。"   # 用户提示
+        chatbot.append([i_say_show_user, gpt_say]); yield from update_ui(chatbot=chatbot, history=[])    # 更新UI
+        i_say = SELECT_PROMPT.format(subject=results_txt)
+        i_say_show_user = f'请判断适合使用的流程图类型,其中数字对应关系为:1-流程图,2-序列图,3-类图,4-饼图,5-甘特图,6-状态图,7-实体关系图,8-象限提示图。由于不管提供文本是什么,模型大概率认为"思维导图"最合适,因此思维导图仅能通过参数调用。'
+        for i in range(3):
+            gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive(
+                inputs=i_say,
+                inputs_show_user=i_say_show_user,
+                llm_kwargs=llm_kwargs, chatbot=chatbot, history=[], 
+                sys_prompt=""
+            )
+            if gpt_say in ['1','2','3','4','5','6','7','8','9']:     #判断返回是否正确
+                break
+        if gpt_say not in ['1','2','3','4','5','6','7','8','9']:
+            gpt_say = '1'
+    ############################## <第 3 步，根据选择的图表类型绘制图表> ##################################
+    if gpt_say == '1':
+        i_say = PROMPT_1.format(subject=results_txt)
+    elif gpt_say == '2':
+        i_say = PROMPT_2.format(subject=results_txt)
+    elif gpt_say == '3':
+        i_say = PROMPT_3.format(subject=results_txt)
+    elif gpt_say == '4':
+        i_say = PROMPT_4.format(subject=results_txt)
+    elif gpt_say == '5':
+        i_say = PROMPT_5.format(subject=results_txt)
+    elif gpt_say == '6':
+        i_say = PROMPT_6.format(subject=results_txt)
+    elif gpt_say == '7':
+        i_say = PROMPT_7.replace("{subject}", results_txt)      #由于实体关系图用到了{}符号
+    elif gpt_say == '8':
+        i_say = PROMPT_8.format(subject=results_txt)
+    elif gpt_say == '9':
+        i_say = PROMPT_9.format(subject=results_txt)
+    i_say_show_user = f'请根据判断结果绘制相应的图表。如需绘制思维导图请使用参数调用,同时过大的图表可能需要复制到在线编辑器中进行渲染。'
+    gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive(
+        inputs=i_say,
+        inputs_show_user=i_say_show_user,
+        llm_kwargs=llm_kwargs, chatbot=chatbot, history=[], 
+        sys_prompt=""
+    )
+    history.append(gpt_say)
+    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 界面更新
+    
+@CatchException
+def 生成多种Mermaid图表(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+    """
+    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
+    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
+    plugin_kwargs   插件模型的参数，用于灵活调整复杂功能的各种参数
+    chatbot         聊天显示框的句柄，用于显示给用户
+    history         聊天历史，前情提要
+    system_prompt   给gpt的静默提醒
+    web_port        当前软件运行的端口号
+    """
+    import os
+
+    # 基本信息：功能、贡献者
+    chatbot.append([
+        "函数插件功能？", 
+        "根据当前聊天历史或指定的路径文件(文件内容优先)绘制多种mermaid图表，将会由对话模型首先判断适合的图表类型，随后绘制图表。\
+        \n您也可以使用插件参数指定绘制的图表类型,函数插件贡献者: Menghuan1918"])
+    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
+    
+    if os.path.exists(txt):     #如输入区无内容则直接解析历史记录
+        from crazy_functions.pdf_fns.parse_word import extract_text_from_files
+        file_exist, final_result, page_one, file_manifest, excption = extract_text_from_files(txt, chatbot, history)
+    else:
+        file_exist = False
+        excption = ""
+        file_manifest = []
+
+    if excption != "":
+        if excption == "word":
+            report_exception(chatbot, history, 
+                a = f"解析项目: {txt}", 
+                b = f"找到了.doc文件，但是该文件格式不被支持，请先转化为.docx格式。")
+            
+        elif excption == "pdf":
+            report_exception(chatbot, history, 
+                a = f"解析项目: {txt}", 
+                b = f"导入软件依赖失败。使用该模块需要额外依赖，安装方法```pip install --upgrade pymupdf```。")
+        
+        elif excption == "word_pip":
+                report_exception(chatbot, history,
+                    a=f"解析项目: {txt}",
+                    b=f"导入软件依赖失败。使用该模块需要额外依赖，安装方法```pip install --upgrade python-docx pywin32```。")
+
+        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
+
+    else:
+        if not file_exist:
+            history.append(txt)     #如输入区不是文件则将输入区内容加入历史记录
+            i_say_show_user = f'首先你从历史记录中提取摘要。'; gpt_say = "[Local Message] 收到。"   # 用户提示
+            chatbot.append([i_say_show_user, gpt_say]); yield from update_ui(chatbot=chatbot, history=history)    # 更新UI
+            yield from 解析历史输入(history,llm_kwargs,file_manifest,chatbot,plugin_kwargs)
+        else:
+            file_num = len(file_manifest)
+            for i in range(file_num):     #依次处理文件
+                i_say_show_user = f"[{i+1}/{file_num}]处理文件{file_manifest[i]}"; gpt_say = "[Local Message] 收到。"   # 用户提示
+                chatbot.append([i_say_show_user, gpt_say]); yield from update_ui(chatbot=chatbot, history=history)    # 更新UI
+                history = []    #如输入区内容为文件则清空历史记录
+                history.append(final_result[i])
+                yield from 解析历史输入(history,llm_kwargs,file_manifest,chatbot,plugin_kwargs)
--- a/crazy_functions/知识库问答.py
+++ b/crazy_functions/知识库问答.py
@@ -13,7 +13,7 @@ install_msg ="""
 """

@CatchException
-def 知识库文件注入(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 知识库文件注入(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    """
    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
    llm_kwargs      gpt模型参数, 如温度和top_p等, 一般原样传递下去就行
@@ -21,7 +21,7 @@ def 知识库文件注入(txt, llm_kwargs, plugin_kwargs, chatbot, history, syst
    chatbot         聊天显示框的句柄，用于显示给用户
    history         聊天历史，前情提要
    system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
    """
    history = []    # 清空历史，以免输入溢出

@@ -84,7 +84,7 @@ def 知识库文件注入(txt, llm_kwargs, plugin_kwargs, chatbot, history, syst
    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 由于请求gpt需要一段时间，我们先及时地做一次界面更新

@CatchException
-def 读取知识库作答(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port=-1):
+def 读取知识库作答(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request=-1):
    # resolve deps
    try:
        # from zh_langchain import construct_vector_store
--- a/crazy_functions/联网的ChatGPT.py
+++ b/crazy_functions/联网的ChatGPT.py
@@ -55,7 +55,7 @@ def scrape_text(url, proxies) -> str:
    return text

@CatchException
-def 连接网络回答问题(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 连接网络回答问题(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    """
    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -63,7 +63,7 @@ def 连接网络回答问题(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
    chatbot         聊天显示框的句柄，用于显示给用户
    history         聊天历史，前情提要
    system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
    """
    history = []    # 清空历史，以免输入溢出
    chatbot.append((f"请结合互联网信息回答以下问题：{txt}", 
--- a/crazy_functions/联网的ChatGPT_bing版.py
+++ b/crazy_functions/联网的ChatGPT_bing版.py
@@ -55,7 +55,7 @@ def scrape_text(url, proxies) -> str:
    return text

@CatchException
-def 连接bing搜索回答问题(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 连接bing搜索回答问题(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    """
    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -63,7 +63,7 @@ def 连接bing搜索回答问题(txt, llm_kwargs, plugin_kwargs, chatbot, histor
    chatbot         聊天显示框的句柄，用于显示给用户
    history         聊天历史，前情提要
    system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
    """
    history = []    # 清空历史，以免输入溢出
    chatbot.append((f"请结合互联网信息回答以下问题：{txt}",
--- a/crazy_functions/虚空终端.py
+++ b/crazy_functions/虚空终端.py
@@ -104,7 +104,7 @@ def analyze_intention_with_simple_rules(txt):


@CatchException
-def 虚空终端(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 虚空终端(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    disable_auto_promotion(chatbot=chatbot)
    # 获取当前虚空终端状态
    state = VoidTerminalState.get_state(chatbot)
@@ -121,7 +121,7 @@ def 虚空终端(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt
        state.set_state(chatbot=chatbot, key='has_provided_explaination', value=True)
        state.unlock_plugin(chatbot=chatbot)
        yield from update_ui(chatbot=chatbot, history=history)
-        yield from 虚空终端主路由(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port)
+        yield from 虚空终端主路由(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request)
        return
    else:
        # 如果意图模糊，提示
@@ -133,7 +133,7 @@ def 虚空终端(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt



-def 虚空终端主路由(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 虚空终端主路由(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    history = []
    chatbot.append(("虚空终端状态: ", f"正在执行任务: {txt}"))
    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
--- a/crazy_functions/解析JupyterNotebook.py
+++ b/crazy_functions/解析JupyterNotebook.py
@@ -12,6 +12,12 @@ class PaperFileGroup():
        self.sp_file_index = []
        self.sp_file_tag = []

+        # count_token
+        from request_llms.bridge_all import model_info
+        enc = model_info["gpt-3.5-turbo"]['tokenizer']
+        def get_token_num(txt): return len(enc.encode(txt, disallowed_special=()))
+        self.get_token_num = get_token_num
+
    def run_file_split(self, max_token_limit=1900):
        """
        将长文本分离开来
@@ -54,7 +60,7 @@ def parseNotebook(filename, enable_markdown=1):
        Code += f"This is {idx+1}th code block: \n"
        Code += code+"\n"

-    return Code 
+    return Code


 def ipynb解释(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt):
@@ -109,7 +115,7 @@ def ipynb解释(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbo
    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面

@CatchException
-def 解析ipynb文件(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析ipynb文件(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    chatbot.append([
        "函数插件功能？",
        "对IPynb文件进行解析。Contributor: codycjy."])
--- a/crazy_functions/解析项目源代码.py
+++ b/crazy_functions/解析项目源代码.py
@@ -83,7 +83,8 @@ def 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs,
            history=this_iteration_history_feed,   # 迭代之前的分析
            sys_prompt="你是一个程序架构分析师，正在分析一个项目的源代码。" + sys_prompt_additional)
        
-        summary = "请用一句话概括这些文件的整体功能"
+        diagram_code = make_diagram(this_iteration_files, result, this_iteration_history_feed)
+        summary = "请用一句话概括这些文件的整体功能。\n\n" + diagram_code
        summary_result = yield from request_gpt_model_in_new_thread_with_ui_alive(
            inputs=summary, 
            inputs_show_user=summary, 
@@ -104,9 +105,12 @@ def 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs,
    chatbot.append(("完成了吗？", res))
    yield from update_ui(chatbot=chatbot, history=history_to_return) # 刷新界面

+def make_diagram(this_iteration_files, result, this_iteration_history_feed):
+    from crazy_functions.diagram_fns.file_tree import build_file_tree_mermaid_diagram
+    return build_file_tree_mermaid_diagram(this_iteration_history_feed[0::2], this_iteration_history_feed[1::2], "项目示意图")

@CatchException
-def 解析项目本身(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析项目本身(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    history = []    # 清空历史，以免输入溢出
    import glob
    file_manifest = [f for f in glob.glob('./*.py')] + \
@@ -119,7 +123,7 @@ def 解析项目本身(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_
    yield from 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt)

@CatchException
-def 解析一个Python项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析一个Python项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    history = []    # 清空历史，以免输入溢出
    import glob, os
    if os.path.exists(txt):
@@ -137,7 +141,7 @@ def 解析一个Python项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
    yield from 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt)

@CatchException
-def 解析一个Matlab项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析一个Matlab项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    history = []    # 清空历史，以免输入溢出
    import glob, os
    if os.path.exists(txt):
@@ -155,7 +159,7 @@ def 解析一个Matlab项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
    yield from 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt)

@CatchException
-def 解析一个C项目的头文件(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析一个C项目的头文件(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    history = []    # 清空历史，以免输入溢出
    import glob, os
    if os.path.exists(txt):
@@ -175,7 +179,7 @@ def 解析一个C项目的头文件(txt, llm_kwargs, plugin_kwargs, chatbot, his
    yield from 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt)

@CatchException
-def 解析一个C项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析一个C项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    history = []    # 清空历史，以免输入溢出
    import glob, os
    if os.path.exists(txt):
@@ -197,7 +201,7 @@ def 解析一个C项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system


@CatchException
-def 解析一个Java项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析一个Java项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    history = []  # 清空历史，以免输入溢出
    import glob, os
    if os.path.exists(txt):
@@ -219,7 +223,7 @@ def 解析一个Java项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, sys


@CatchException
-def 解析一个前端项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析一个前端项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    history = []  # 清空历史，以免输入溢出
    import glob, os
    if os.path.exists(txt):
@@ -248,7 +252,7 @@ def 解析一个前端项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, s


@CatchException
-def 解析一个Golang项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析一个Golang项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    history = []  # 清空历史，以免输入溢出
    import glob, os
    if os.path.exists(txt):
@@ -269,7 +273,7 @@ def 解析一个Golang项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
    yield from 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt)

@CatchException
-def 解析一个Rust项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析一个Rust项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    history = []  # 清空历史，以免输入溢出
    import glob, os
    if os.path.exists(txt):
@@ -289,7 +293,7 @@ def 解析一个Rust项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, sys
    yield from 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt)

@CatchException
-def 解析一个Lua项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析一个Lua项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    history = []    # 清空历史，以免输入溢出
    import glob, os
    if os.path.exists(txt):
@@ -311,7 +315,7 @@ def 解析一个Lua项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, syst


@CatchException
-def 解析一个CSharp项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析一个CSharp项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    history = []    # 清空历史，以免输入溢出
    import glob, os
    if os.path.exists(txt):
@@ -331,7 +335,7 @@ def 解析一个CSharp项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, s


@CatchException
-def 解析任意code项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析任意code项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    txt_pattern = plugin_kwargs.get("advanced_arg")
    txt_pattern = txt_pattern.replace("，", ",")
    # 将要匹配的模式(例如: *.c, *.cpp, *.py, config.toml)
--- a/crazy_functions/询问多个大语言模型.py
+++ b/crazy_functions/询问多个大语言模型.py
@@ -2,7 +2,7 @@ from toolbox import CatchException, update_ui, get_conf
 from .crazy_utils import request_gpt_model_in_new_thread_with_ui_alive
 import datetime
@CatchException
-def 同时问询(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 同时问询(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    """
    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -10,7 +10,7 @@ def 同时问询(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt
    chatbot         聊天显示框的句柄，用于显示给用户
    history         聊天历史，前情提要
    system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
    """
    history = []    # 清空历史，以免输入溢出
    MULTI_QUERY_LLM_MODELS = get_conf('MULTI_QUERY_LLM_MODELS')
@@ -32,7 +32,7 @@ def 同时问询(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt


@CatchException
-def 同时问询_指定模型(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 同时问询_指定模型(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    """
    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -40,7 +40,7 @@ def 同时问询_指定模型(txt, llm_kwargs, plugin_kwargs, chatbot, history,
    chatbot         聊天显示框的句柄，用于显示给用户
    history         聊天历史，前情提要
    system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
    """
    history = []    # 清空历史，以免输入溢出

--- a/crazy_functions/语音助手.py
+++ b/crazy_functions/语音助手.py
@@ -166,7 +166,7 @@ class InterviewAssistant(AliyunASR):


@CatchException
-def 语音助手(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 语音助手(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    # pip install -U openai-whisper
    chatbot.append(["对话助手函数插件：使用时，双手离开鼠标键盘吧", "音频助手, 正在听您讲话（点击“停止”键可终止程序）..."])
    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
--- a/crazy_functions/读文章写摘要.py
+++ b/crazy_functions/读文章写摘要.py
@@ -44,7 +44,7 @@ def 解析Paper(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbo


@CatchException
-def 读文章写摘要(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 读文章写摘要(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    history = []    # 清空历史，以免输入溢出
    import glob, os
    if os.path.exists(txt):
--- a/crazy_functions/谷歌检索小助手.py
+++ b/crazy_functions/谷歌检索小助手.py
@@ -132,7 +132,7 @@ def get_meta_information(url, chatbot, history):
    return profile

@CatchException
-def 谷歌检索小助手(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 谷歌检索小助手(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    disable_auto_promotion(chatbot=chatbot)
    # 基本信息：功能、贡献者
    chatbot.append([
--- a/crazy_functions/辅助功能.py
+++ b/crazy_functions/辅助功能.py
@@ -11,7 +11,7 @@ import os


@CatchException
-def 猜你想问(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 猜你想问(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    if txt:
        show_say = txt
        prompt = txt+'\n回答完问题后，再列出用户可能提出的三个问题。'
@@ -32,7 +32,7 @@ def 猜你想问(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt


@CatchException
-def 清除缓存(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 清除缓存(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    chatbot.append(['清除本地缓存数据', '执行中. 删除数据'])
    yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面

--- a/crazy_functions/高级功能函数模板.py
+++ b/crazy_functions/高级功能函数模板.py
@@ -1,19 +1,47 @@
 from toolbox import CatchException, update_ui
-from .crazy_utils import request_gpt_model_in_new_thread_with_ui_alive
+from crazy_functions.crazy_utils import request_gpt_model_in_new_thread_with_ui_alive
 import datetime
+
+高阶功能模板函数示意图 = f"""
+```mermaid
+flowchart TD
+    %% <gpt_academic_hide_mermaid_code> 一个特殊标记，用于在生成mermaid图表时隐藏代码块
+    subgraph 函数调用["函数调用过程"]
+        AA["输入栏用户输入的文本(txt)"] --> BB["gpt模型参数(llm_kwargs)"]
+        BB --> CC["插件模型参数(plugin_kwargs)"]
+        CC --> DD["对话显示框的句柄(chatbot)"]
+        DD --> EE["对话历史(history)"]
+        EE --> FF["系统提示词(system_prompt)"]
+        FF --> GG["当前用户信息(web_port)"]
+
+        A["开始(查询5天历史事件)"]
+        A --> B["获取当前月份和日期"]
+        B --> C["生成历史事件查询提示词"]
+        C --> D["调用大模型"]
+        D --> E["更新界面"]
+        E --> F["记录历史"]
+        F --> |"下一天"| B
+    end
+```
+"""
+
@CatchException
-def 高阶功能模板函数(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 高阶功能模板函数(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
    """
+    # 高阶功能模板函数示意图：https://mermaid.live/edit#pako:eNptk1tvEkEYhv8KmattQpvlvOyFCcdeeaVXuoYssBwie8gyhCIlqVoLhrbbtAWNUpEGUkyMEDW2Fmn_DDOL_8LZHdOwxrnamX3f7_3mmZk6yKhZCfAgV1KrmYKoQ9fDuKC4yChX0nld1Aou1JzjznQ5fWmejh8LYHW6vG2a47YAnlCLNSIRolnenKBXI_zRIBrcuqRT890u7jZx7zMDt-AaMbnW1--5olGiz2sQjwfoQxsZL0hxplSSU0-rop4vrzmKR6O2JxYjHmwcL2Y_HDatVMkXlf86YzHbGY9bO5j8XE7O8Nsbc3iNB3ukL2SMcH-XIQBgWoVOZzxuOxOJOyc63EPGV6ZQLENVrznViYStTiaJ2vw2M2d9bByRnOXkgCnXylCSU5quyto_IcmkbdvctELmJ-j1ASW3uB3g5xOmKqVTmqr_Na3AtuS_dtBFm8H90XJyHkDDT7S9xXWb4HGmRChx64AOL5HRpUm411rM5uh4H78Z4V7fCZzytjZz2seto9XaNPFue07clLaVZF8UNLygJ-VES8lah_n-O-5Ozc7-77NzJ0-K0yr0ZYrmHdqAk50t2RbA4qq9uNohBASw7YpSgaRkLWCCAtxAlnRZLGbJba9bPwUAC5IsCYAnn1kpJ1ZKUACC0iBSsQLVBzUlA3ioVyQ3qGhZEUrxokiehAz4nFgqk1VNVABfB1uAD_g2_AGPl-W8nMcbCvsDblADfNCz4feyobDPy3rYEMtxwYYbPFNVUoHdCPmDHBv2cP4AMfrCbiBli-Q-3afv0X6WdsIjW2-10fgDy1SAig
+
    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
    plugin_kwargs   插件模型的参数，用于灵活调整复杂功能的各种参数
    chatbot         聊天显示框的句柄，用于显示给用户
    history         聊天历史，前情提要
    system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
    """
    history = []    # 清空历史，以免输入溢出
-    chatbot.append(("这是什么功能？", "[Local Message] 请注意，您正在调用一个[函数插件]的模板，该函数面向希望实现更多有趣功能的开发者，它可以作为创建新功能函数的模板（该函数只有20多行代码）。此外我们也提供可同步处理大量文件的多线程Demo供您参考。您若希望分享新的功能模组，请不吝PR！"))
+    chatbot.append((
+        "您正在调用插件：历史上的今天", 
+        "[Local Message] 请注意，您正在调用一个[函数插件]的模板，该函数面向希望实现更多有趣功能的开发者，它可以作为创建新功能函数的模板（该函数只有20多行代码）。此外我们也提供可同步处理大量文件的多线程Demo供您参考。您若希望分享新的功能模组，请不吝PR！" + 高阶功能模板函数示意图))
    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 由于请求gpt需要一段时间，我们先及时地做一次界面更新
    for i in range(5):
        currentMonth = (datetime.date.today() + datetime.timedelta(days=i)).month
@@ -26,4 +54,46 @@ def 高阶功能模板函数(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
        )
        chatbot[-1] = (i_say, gpt_say)
        history.append(i_say);history.append(gpt_say)
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 界面更新
+        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 界面更新
+
+
+
+
+PROMPT = """
+请你给出围绕“{subject}”的逻辑关系图，使用mermaid语法，mermaid语法举例：
+```mermaid
+graph TD
+    P(编程) --> L1(Python)
+    P(编程) --> L2(C)
+    P(编程) --> L3(C++)
+    P(编程) --> L4(Javascipt)
+    P(编程) --> L5(PHP)
+```
+"""
+@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(("这是什么功能？", "一个测试mermaid绘制图表的功能，您可以在输入框中输入一些关键词，然后使用mermaid+llm绘制图表。"))
+    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 由于请求gpt需要一段时间，我们先及时地做一次界面更新
+    
+    if txt == "": txt = "空白的输入栏" # 调皮一下
+    
+    i_say_show_user = f'请绘制有关“{txt}”的逻辑关系图。'
+    i_say = PROMPT.format(subject=txt)
+    gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive(
+        inputs=i_say,
+        inputs_show_user=i_say_show_user,
+        llm_kwargs=llm_kwargs, chatbot=chatbot, history=[], 
+        sys_prompt=""
+    )
+    history.append(i_say); history.append(gpt_say)
+    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 界面更新
--- a/docs/GithubAction+NoLocal+AudioAssistant
+++ b/docs/GithubAction+NoLocal+AudioAssistant
@@ -13,7 +13,7 @@ COPY . .
 RUN pip3 install -r requirements.txt

 # 安装语音插件的额外依赖
-RUN pip3 install pyOpenSSL scipy git+https://github.com/aliyun/alibabacloud-nls-python-sdk.git
+RUN pip3 install aliyun-python-sdk-core==2.13.3 pyOpenSSL webrtcvad scipy git+https://github.com/aliyun/alibabacloud-nls-python-sdk.git

 # 可选步骤，用于预热模块
 RUN python3  -c 'from check_proxy import warm_up_modules; warm_up_modules()'
--- a/docs/gradio-3.32.6-py3-none-any.whl
+++ b/docs/gradio-3.32.6-py3-none-any.whl
--- a/docs/self_analysis.md
+++ b/docs/self_analysis.md
@@ -165,7 +165,7 @@ toolbox.py是一个工具类库，其中主要包含了一些函数装饰器和

 3. read_file_to_chat(chatbot, history, file_name)：从传入的文件中读取内容，解析出对话历史记录并更新聊天显示框。

-4. 对话历史存档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port)：一个主要函数，用于保存当前对话记录并提醒用户。如果用户希望加载历史记录，则调用read_file_to_chat()来更新聊天显示框。如果用户希望删除历史记录，调用删除所有本地对话历史记录()函数完成删除操作。
+4. 对话历史存档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request)：一个主要函数，用于保存当前对话记录并提醒用户。如果用户希望加载历史记录，则调用read_file_to_chat()来更新聊天显示框。如果用户希望删除历史记录，调用删除所有本地对话历史记录()函数完成删除操作。

 ## [19/48] 请对下面的程序文件做一个概述: crazy_functions\总结word文档.py

--- a/docs/translate_english.json
+++ b/docs/translate_english.json
@@ -1668,7 +1668,7 @@
    "Markdown翻译指定语言": "TranslateMarkdownToSpecifiedLanguage",
    "Langchain知识库": "LangchainKnowledgeBase",
    "Latex英文纠错加PDF对比": "CorrectEnglishInLatexWithPDFComparison",
-    "Latex输出PDF结果": "OutputPDFFromLatex",
+    "Latex输出PDF": "OutputPDFFromLatex",
    "Latex翻译中文并重新编译PDF": "TranslateChineseToEnglishInLatexAndRecompilePDF",
    "sprint亮靛": "SprintIndigo",
    "寻找Latex主文件": "FindLatexMainFile",
@@ -3004,5 +3004,7 @@
    "1. 上传图片": "TranslatedText",
    "保存状态": "TranslatedText",
    "GPT-Academic对话存档": "TranslatedText",
-    "Arxiv论文精细翻译": "TranslatedText"
+    "Arxiv论文精细翻译": "TranslatedText",
+    "from crazy_functions.AdvancedFunctionTemplate import 测试图表渲染": "from crazy_functions.AdvancedFunctionTemplate import test_chart_rendering",
+    "测试图表渲染": "test_chart_rendering"
 }
--- a/docs/translate_japanese.json
+++ b/docs/translate_japanese.json
@@ -1492,7 +1492,7 @@
    "交互功能模板函数": "InteractiveFunctionTemplateFunction",
    "交互功能函数模板": "InteractiveFunctionFunctionTemplate",
    "Latex英文纠错加PDF对比": "LatexEnglishErrorCorrectionWithPDFComparison",
-    "Latex输出PDF结果": "LatexOutputPDFResult",
+    "Latex输出PDF": "LatexOutputPDFResult",
    "Latex翻译中文并重新编译PDF": "TranslateChineseAndRecompilePDF",
    "语音助手": "VoiceAssistant",
    "微调数据集生成": "FineTuneDatasetGeneration",
--- a/docs/translate_std.json
+++ b/docs/translate_std.json
@@ -16,7 +16,7 @@
    "批量Markdown翻译": "BatchTranslateMarkdown",
    "连接bing搜索回答问题": "ConnectBingSearchAnswerQuestion",
    "Langchain知识库": "LangchainKnowledgeBase",
-    "Latex输出PDF结果": "OutputPDFFromLatex",
+    "Latex输出PDF": "OutputPDFFromLatex",
    "把字符太少的块清除为回车": "ClearBlocksWithTooFewCharactersToNewline",
    "Latex精细分解与转化": "DecomposeAndConvertLatex",
    "解析一个C项目的头文件": "ParseCProjectHeaderFiles",
@@ -97,5 +97,12 @@
    "多智能体": "MultiAgent",
    "图片生成_DALLE2": "ImageGeneration_DALLE2",
    "图片生成_DALLE3": "ImageGeneration_DALLE3",
-    "图片修改_DALLE2": "ImageModification_DALLE2"
-}
+    "图片修改_DALLE2": "ImageModification_DALLE2",
+    "生成多种Mermaid图表": "GenerateMultipleMermaidCharts",
+    "知识库文件注入": "InjectKnowledgeBaseFiles",
+    "PDF翻译中文并重新编译PDF": "TranslatePDFToChineseAndRecompilePDF",
+    "随机小游戏": "RandomMiniGame",
+    "互动小游戏": "InteractiveMiniGame",
+    "解析历史输入": "ParseHistoricalInput",
+    "高阶功能模板函数示意图": "HighOrderFunctionTemplateDiagram"
+}
--- a/docs/translate_traditionalchinese.json
+++ b/docs/translate_traditionalchinese.json
@@ -1468,7 +1468,7 @@
    "交互功能模板函数": "InteractiveFunctionTemplateFunctions",
    "交互功能函数模板": "InteractiveFunctionFunctionTemplates",
    "Latex英文纠错加PDF对比": "LatexEnglishCorrectionWithPDFComparison",
-    "Latex输出PDF结果": "OutputPDFFromLatex",
+    "Latex输出PDF": "OutputPDFFromLatex",
    "Latex翻译中文并重新编译PDF": "TranslateLatexToChineseAndRecompilePDF",
    "语音助手": "VoiceAssistant",
    "微调数据集生成": "FineTuneDatasetGeneration",
--- a/docs/use_audio.md
+++ b/docs/use_audio.md
@@ -3,7 +3,7 @@

 ## 1. 安装额外依赖
 ```
-pip install --upgrade pyOpenSSL scipy git+https://github.com/aliyun/alibabacloud-nls-python-sdk.git
+pip install --upgrade pyOpenSSL webrtcvad scipy git+https://github.com/aliyun/alibabacloud-nls-python-sdk.git
 ```

 如果因为特色网络问题导致上述命令无法执行：
--- a/docs/waifu_plugin/autoload.js
+++ b/docs/waifu_plugin/autoload.js
@@ -1,30 +0,0 @@
-try {
-    $("<link>").attr({href: "file=docs/waifu_plugin/waifu.css", rel: "stylesheet", type: "text/css"}).appendTo('head');
-    $('body').append('<div class="waifu"><div class="waifu-tips"></div><canvas id="live2d" class="live2d"></canvas><div class="waifu-tool"><span class="fui-home"></span> <span class="fui-chat"></span> <span class="fui-eye"></span> <span class="fui-user"></span> <span class="fui-photo"></span> <span class="fui-info-circle"></span> <span class="fui-cross"></span></div></div>');
-    $.ajax({url: "file=docs/waifu_plugin/waifu-tips.js", dataType:"script", cache: true, success: function() {
-        $.ajax({url: "file=docs/waifu_plugin/live2d.js", dataType:"script", cache: true, success: function() {
-            /* 可直接修改部分参数 */
-            live2d_settings['hitokotoAPI'] = "hitokoto.cn";  // 一言 API
-            live2d_settings['modelId'] = 5;                  // 默认模型 ID
-            live2d_settings['modelTexturesId'] = 1;          // 默认材质 ID
-            live2d_settings['modelStorage'] = false;         // 不储存模型 ID
-            live2d_settings['waifuSize']            = '210x187';
-            live2d_settings['waifuTipsSize']        = '187x52';
-            live2d_settings['canSwitchModel']       = true;
-            live2d_settings['canSwitchTextures']    = true;
-            live2d_settings['canSwitchHitokoto']    = false;
-            live2d_settings['canTakeScreenshot']    = false;
-            live2d_settings['canTurnToHomePage']    = false;
-            live2d_settings['canTurnToAboutPage']   = false;
-            live2d_settings['showHitokoto']         = false;         // 显示一言
-            live2d_settings['showF12Status']        = false;         // 显示加载状态
-            live2d_settings['showF12Message']       = false;        // 显示看板娘消息
-            live2d_settings['showF12OpenMsg']       = false;         // 显示控制台打开提示
-            live2d_settings['showCopyMessage']      = false;         // 显示 复制内容 提示
-            live2d_settings['showWelcomeMessage']   = true;         // 显示进入面页欢迎词
-
-            /* 在 initModel 前添加 */
-            initModel("file=docs/waifu_plugin/waifu-tips.json");
-        }});
-    }});
-} catch(err) { console.log("[Error] JQuery is not defined.") }
--- a/main.py
+++ b/main.py
@@ -1,9 +1,9 @@
 import os; os.environ['no_proxy'] = '*' # 避免代理网络产生意外污染

 help_menu_description = \
-"""Github源代码开源和更新[地址🚀](https://github.com/binary-husky/gpt_academic), 
+"""Github源代码开源和更新[地址🚀](https://github.com/binary-husky/gpt_academic),
 感谢热情的[开发者们❤️](https://github.com/binary-husky/gpt_academic/graphs/contributors).
-</br></br>常见问题请查阅[项目Wiki](https://github.com/binary-husky/gpt_academic/wiki), 
+</br></br>常见问题请查阅[项目Wiki](https://github.com/binary-husky/gpt_academic/wiki),
 如遇到Bug请前往[Bug反馈](https://github.com/binary-husky/gpt_academic/issues).
 </br></br>普通对话使用说明: 1. 输入问题; 2. 点击提交
 </br></br>基础功能区使用说明: 1. 输入文本; 2. 点击任意基础功能区按钮
@@ -15,25 +15,25 @@ help_menu_description = \

 def main():
    import gradio as gr
-    if gr.__version__ not in ['3.32.6', '3.32.7']: 
+    if gr.__version__ not in ['3.32.8']:
        raise ModuleNotFoundError("使用项目内置Gradio获取最优体验! 请运行 `pip install -r requirements.txt` 指令安装内置Gradio及其他依赖, 详情信息见requirements.txt.")
    from request_llms.bridge_all import predict
    from toolbox import format_io, find_free_port, on_file_uploaded, on_report_generated, get_conf, ArgsGeneralWrapper, load_chat_cookies, DummyWith
    # 建议您复制一个config_private.py放自己的秘密, 如API和代理网址
    proxies, WEB_PORT, LLM_MODEL, CONCURRENT_COUNT, AUTHENTICATION = get_conf('proxies', 'WEB_PORT', 'LLM_MODEL', 'CONCURRENT_COUNT', 'AUTHENTICATION')
    CHATBOT_HEIGHT, LAYOUT, AVAIL_LLM_MODELS, AUTO_CLEAR_TXT = get_conf('CHATBOT_HEIGHT', 'LAYOUT', 'AVAIL_LLM_MODELS', 'AUTO_CLEAR_TXT')
-    ENABLE_AUDIO, AUTO_CLEAR_TXT, PATH_LOGGING, AVAIL_THEMES, THEME = get_conf('ENABLE_AUDIO', 'AUTO_CLEAR_TXT', 'PATH_LOGGING', 'AVAIL_THEMES', 'THEME')
+    ENABLE_AUDIO, AUTO_CLEAR_TXT, PATH_LOGGING, AVAIL_THEMES, THEME, ADD_WAIFU = get_conf('ENABLE_AUDIO', 'AUTO_CLEAR_TXT', 'PATH_LOGGING', 'AVAIL_THEMES', 'THEME', 'ADD_WAIFU')
    DARK_MODE, NUM_CUSTOM_BASIC_BTN, SSL_KEYFILE, SSL_CERTFILE = get_conf('DARK_MODE', 'NUM_CUSTOM_BASIC_BTN', 'SSL_KEYFILE', 'SSL_CERTFILE')
    INIT_SYS_PROMPT = get_conf('INIT_SYS_PROMPT')

    # 如果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
-    from themes.theme import js_code_for_css_changing, js_code_for_darkmode_init, js_code_for_toggle_darkmode, js_code_for_persistent_cookie_init
+    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_css_changing, js_code_for_toggle_darkmode, js_code_for_persistent_cookie_init
    from themes.theme import load_dynamic_theme, to_cookie_str, from_cookie_str, init_cookie
    title_html = f"<h1 align=\"center\">GPT 学术优化 {get_current_version()}</h1>{theme_declaration}"
-    
+
    # 问询记录, python 版本建议3.9+（越新越好）
    import logging, uuid
    os.makedirs(PATH_LOGGING, exist_ok=True)
@@ -65,7 +65,7 @@ def main():
    proxy_info = check_proxy(proxies)

    gr_L1 = lambda: gr.Row().style()
-    gr_L2 = lambda scale, elem_id: gr.Column(scale=scale, elem_id=elem_id)
+    gr_L2 = lambda scale, elem_id: gr.Column(scale=scale, elem_id=elem_id, min_width=400)
    if LAYOUT == "TOP-DOWN":
        gr_L1 = lambda: DummyWith()
        gr_L2 = lambda scale, elem_id: gr.Row()
@@ -76,7 +76,7 @@ def main():
    predefined_btns = {}
    with gr.Blocks(title="GPT 学术优化", theme=set_theme, analytics_enabled=False, css=advanced_css) as demo:
        gr.HTML(title_html)
-        secret_css, dark_mode, persistent_cookie = gr.Textbox(visible=False), gr.Textbox(DARK_MODE, visible=False), gr.Textbox(visible=False)
+        secret_css, dark_mode, py_pickle_cookie = gr.Textbox(visible=False), gr.Textbox(DARK_MODE, visible=False), gr.Textbox(visible=False)
        cookies = gr.State(load_chat_cookies())
        with gr_L1():
            with gr_L2(scale=2, elem_id="gpt-chat"):
@@ -93,11 +93,12 @@ def main():
                        resetBtn = gr.Button("重置", elem_id="elem_reset", variant="secondary"); resetBtn.style(size="sm")
                        stopBtn = gr.Button("停止", elem_id="elem_stop", variant="secondary"); stopBtn.style(size="sm")
                        clearBtn = gr.Button("清除", elem_id="elem_clear", variant="secondary", visible=False); clearBtn.style(size="sm")
-                    if ENABLE_AUDIO: 
+                    if ENABLE_AUDIO:
                        with gr.Row():
                            audio_mic = gr.Audio(source="microphone", type="numpy", elem_id="elem_audio", streaming=True, show_label=False).style(container=False)
                    with gr.Row():
                        status = gr.Markdown(f"Tip: 按Enter提交, 按Shift+Enter换行。当前模型: {LLM_MODEL} \n {proxy_info}", elem_id="state-panel")
+
                with gr.Accordion("基础功能区", open=True, elem_id="basic-panel") as area_basic_fn:
                    with gr.Row():
                        for k in range(NUM_CUSTOM_BASIC_BTN):
@@ -114,7 +115,7 @@ def main():
                    with gr.Row():
                        gr.Markdown("插件可读取“输入区”文本/路径作为参数（上传文件自动修正路径）")
                    with gr.Row(elem_id="input-plugin-group"):
-                        plugin_group_sel = gr.Dropdown(choices=all_plugin_groups, label='', show_label=False, value=DEFAULT_FN_GROUPS, 
+                        plugin_group_sel = gr.Dropdown(choices=all_plugin_groups, label='', show_label=False, value=DEFAULT_FN_GROUPS,
                                                      multiselect=True, interactive=True, elem_classes='normal_mut_select').style(container=False)
                    with gr.Row():
                        for k, plugin in plugins.items():
@@ -122,7 +123,7 @@ def main():
                            visible = True if match_group(plugin['Group'], DEFAULT_FN_GROUPS) else False
                            variant = plugins[k]["Color"] if "Color" in plugin else "secondary"
                            info = plugins[k].get("Info", k)
-                            plugin['Button'] = plugins[k]['Button'] = gr.Button(k, variant=variant, 
+                            plugin['Button'] = plugins[k]['Button'] = gr.Button(k, variant=variant,
                                visible=visible, info_str=f'函数插件区: {info}').style(size="sm")
                    with gr.Row():
                        with gr.Accordion("更多函数插件", open=True):
@@ -134,7 +135,7 @@ def main():
                            with gr.Row():
                                dropdown = gr.Dropdown(dropdown_fn_list, value=r"打开插件列表", label="", show_label=False).style(container=False)
                            with gr.Row():
-                                plugin_advanced_arg = gr.Textbox(show_label=True, label="高级参数输入区", visible=False, 
+                                plugin_advanced_arg = gr.Textbox(show_label=True, label="高级参数输入区", visible=False,
                                                                 placeholder="这里是特殊函数插件的高级参数输入区").style(container=False)
                            with gr.Row():
                                switchy_bt = gr.Button(r"请先从插件列表中选择", variant="secondary").style(size="sm")
@@ -142,13 +143,12 @@ 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")

-
        with gr.Floating(init_x="0%", init_y="0%", visible=True, width=None, drag="forbidden", elem_id="tooltip"):
            with gr.Row():
                with gr.Tab("上传文件", elem_id="interact-panel"):
                    gr.Markdown("请上传本地文件/压缩包供“函数插件区”功能调用。请注意: 上传文件后会自动把输入区修改为相应路径。")
                    file_upload_2 = gr.Files(label="任何文件, 推荐上传压缩文件(zip, tar)", file_count="multiple", elem_id="elem_upload_float")
-    
+
                with gr.Tab("更换模型", elem_id="interact-panel"):
                    md_dropdown = gr.Dropdown(AVAIL_LLM_MODELS, value=LLM_MODEL, label="更换LLM模型/请求源").style(container=False)
                    top_p = gr.Slider(minimum=-0, maximum=1.0, value=1.0, step=0.01,interactive=True, label="Top-p (nucleus sampling)",)
@@ -158,10 +158,11 @@ def main():

                with gr.Tab("界面外观", elem_id="interact-panel"):
                    theme_dropdown = gr.Dropdown(AVAIL_THEMES, value=THEME, label="更换UI主题").style(container=False)
-                    checkboxes = gr.CheckboxGroup(["基础功能区", "函数插件区", "浮动输入区", "输入清除键", "插件参数区"], 
-                                                  value=["基础功能区", "函数插件区"], label="显示/隐藏功能区", elem_id='cbs').style(container=False)
-                    checkboxes_2 = gr.CheckboxGroup(["自定义菜单"], 
-                                                  value=[], label="显示/隐藏自定义菜单", elem_id='cbsc').style(container=False)
+                    checkboxes = gr.CheckboxGroup(["基础功能区", "函数插件区", "浮动输入区", "输入清除键", "插件参数区"], value=["基础功能区", "函数插件区"], label="显示/隐藏功能区", elem_id='cbs').style(container=False)
+                    opt = ["自定义菜单"]
+                    value=[]
+                    if ADD_WAIFU: opt += ["添加Live2D形象"]; value += ["添加Live2D形象"]
+                    checkboxes_2 = gr.CheckboxGroup(opt, value=value, label="显示/隐藏自定义菜单", elem_id='cbsc').style(container=False)
                    dark_mode_btn = gr.Button("切换界面明暗 ☀", variant="secondary").style(size="sm")
                    dark_mode_btn.click(None, None, None, _js=js_code_for_toggle_darkmode)
                with gr.Tab("帮助", elem_id="interact-panel"):
@@ -178,7 +179,7 @@ def main():
                        submitBtn2 = gr.Button("提交", variant="primary"); submitBtn2.style(size="sm")
                        resetBtn2 = gr.Button("重置", variant="secondary"); resetBtn2.style(size="sm")
                        stopBtn2 = gr.Button("停止", variant="secondary"); stopBtn2.style(size="sm")
-                        clearBtn2 = gr.Button("清除", variant="secondary", visible=False); clearBtn2.style(size="sm")
+                        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") as area_customize:
@@ -192,10 +193,12 @@ def main():
                        basic_fn_suffix = gr.Textbox(show_label=False, placeholder="输入新提示后缀", lines=4).style(container=False)
                    with gr.Column(scale=1, min_width=70):
                        basic_fn_confirm = gr.Button("确认并保存", variant="primary"); basic_fn_confirm.style(size="sm")
-                        basic_fn_load    = gr.Button("加载已保存", variant="primary"); basic_fn_load.style(size="sm")
-                        def assign_btn(persistent_cookie_, cookies_, basic_btn_dropdown_, basic_fn_title, basic_fn_prefix, basic_fn_suffix):
+                        basic_fn_clean   = gr.Button("恢复默认", variant="primary"); basic_fn_clean.style(size="sm")
+                        def assign_btn(persistent_cookie_, cookies_, basic_btn_dropdown_, basic_fn_title, basic_fn_prefix, basic_fn_suffix, clean_up=False):
                            ret = {}
+                            # 读取之前的自定义按钮
                            customize_fn_overwrite_ = cookies_['customize_fn_overwrite']
+                            # 更新新的自定义按钮
                            customize_fn_overwrite_.update({
                                basic_btn_dropdown_:
                                    {
@@ -205,27 +208,41 @@ def main():
                                    }
                                }
                            )
-                            cookies_.update(customize_fn_overwrite_)
+                            if clean_up:
+                                customize_fn_overwrite_ = {}
+                            cookies_.update(customize_fn_overwrite_)    # 更新cookie
+                            visible = (not clean_up) and (basic_fn_title != "")
                            if basic_btn_dropdown_ in customize_btns:
-                                ret.update({customize_btns[basic_btn_dropdown_]: gr.update(visible=True, value=basic_fn_title)})
+                                # 是自定义按钮，不是预定义按钮
+                                ret.update({customize_btns[basic_btn_dropdown_]: gr.update(visible=visible, value=basic_fn_title)})
                            else:
-                                ret.update({predefined_btns[basic_btn_dropdown_]: gr.update(visible=True, value=basic_fn_title)})
+                                # 是预定义按钮
+                                ret.update({predefined_btns[basic_btn_dropdown_]: gr.update(visible=visible, value=basic_fn_title)})
                            ret.update({cookies: cookies_})
                            try: persistent_cookie_ = from_cookie_str(persistent_cookie_)   # persistent cookie to dict
                            except: persistent_cookie_ = {}
                            persistent_cookie_["custom_bnt"] = customize_fn_overwrite_      # dict update new value
                            persistent_cookie_ = to_cookie_str(persistent_cookie_)          # persistent cookie to dict
-                            ret.update({persistent_cookie: persistent_cookie_})             # write persistent cookie
+                            ret.update({py_pickle_cookie: persistent_cookie_})             # write persistent cookie
                            return ret
-                        
-                        def reflesh_btn(persistent_cookie_, cookies_):
+
+                        # update btn
+                        h = basic_fn_confirm.click(assign_btn, [py_pickle_cookie, cookies, basic_btn_dropdown, basic_fn_title, basic_fn_prefix, basic_fn_suffix],
+                                                   [py_pickle_cookie, cookies, *customize_btns.values(), *predefined_btns.values()])
+                        h.then(None, [py_pickle_cookie], None, _js="""(py_pickle_cookie)=>{setCookie("py_pickle_cookie", py_pickle_cookie, 365);}""")
+                        # clean up btn
+                        h2 = basic_fn_clean.click(assign_btn, [py_pickle_cookie, cookies, basic_btn_dropdown, basic_fn_title, basic_fn_prefix, basic_fn_suffix, gr.State(True)],
+                                                   [py_pickle_cookie, cookies, *customize_btns.values(), *predefined_btns.values()])
+                        h2.then(None, [py_pickle_cookie], None, _js="""(py_pickle_cookie)=>{setCookie("py_pickle_cookie", py_pickle_cookie, 365);}""")
+
+                        def persistent_cookie_reload(persistent_cookie_, cookies_):
                            ret = {}
                            for k in customize_btns:
                                ret.update({customize_btns[k]: gr.update(visible=False, value="")})

                            try: persistent_cookie_ = from_cookie_str(persistent_cookie_)    # persistent cookie to dict
                            except: return ret
-                            
+
                            customize_fn_overwrite_ = persistent_cookie_.get("custom_bnt", {})
                            cookies_['customize_fn_overwrite'] = customize_fn_overwrite_
                            ret.update({cookies: cookies_})
@@ -235,26 +252,17 @@ def main():
                                if k in customize_btns: ret.update({customize_btns[k]: gr.update(visible=True, value=v['Title'])})
                                else: ret.update({predefined_btns[k]: gr.update(visible=True, value=v['Title'])})
                            return ret
-                        
-                        basic_fn_load.click(reflesh_btn, [persistent_cookie, cookies], [cookies, *customize_btns.values(), *predefined_btns.values()])
-                        h = basic_fn_confirm.click(assign_btn, [persistent_cookie, cookies, basic_btn_dropdown, basic_fn_title, basic_fn_prefix, basic_fn_suffix], 
-                                                   [persistent_cookie, cookies, *customize_btns.values(), *predefined_btns.values()])
-                        # save persistent cookie
-                        h.then(None, [persistent_cookie], None, _js="""(persistent_cookie)=>{setCookie("persistent_cookie", persistent_cookie, 5);}""")

        # 功能区显示开关与功能区的互动
        def fn_area_visibility(a):
            ret = {}
-            ret.update({area_basic_fn: gr.update(visible=("基础功能区" in a))})
-            ret.update({area_crazy_fn: gr.update(visible=("函数插件区" in a))})
            ret.update({area_input_primary: gr.update(visible=("浮动输入区" not in a))})
            ret.update({area_input_secondary: gr.update(visible=("浮动输入区" in a))})
-            ret.update({clearBtn: gr.update(visible=("输入清除键" in a))})
-            ret.update({clearBtn2: gr.update(visible=("输入清除键" in a))})
            ret.update({plugin_advanced_arg: gr.update(visible=("插件参数区" in a))})
            if "浮动输入区" in a: ret.update({txt: gr.update(value="")})
            return ret
-        checkboxes.select(fn_area_visibility, [checkboxes], [area_basic_fn, area_crazy_fn, area_input_primary, area_input_secondary, txt, txt2, clearBtn, clearBtn2, plugin_advanced_arg] )
+        checkboxes.select(fn_area_visibility, [checkboxes], [area_basic_fn, area_crazy_fn, area_input_primary, area_input_secondary, txt, txt2, plugin_advanced_arg] )
+        checkboxes.select(None, [checkboxes], None, _js=js_code_show_or_hide)

        # 功能区显示开关与功能区的互动
        def fn_area_visibility_2(a):
@@ -262,6 +270,7 @@ def main():
            ret.update({area_customize: gr.update(visible=("自定义菜单" in a))})
            return ret
        checkboxes_2.select(fn_area_visibility_2, [checkboxes_2], [area_customize] )
+        checkboxes_2.select(None, [checkboxes_2], None, _js=js_code_show_or_hide_group2)

        # 整理反复出现的控件句柄组合
        input_combo = [cookies, max_length_sl, md_dropdown, txt, txt2, top_p, temperature, chatbot, history, system_prompt, plugin_advanced_arg]
@@ -272,15 +281,17 @@ def main():
        cancel_handles.append(txt2.submit(**predict_args))
        cancel_handles.append(submitBtn.click(**predict_args))
        cancel_handles.append(submitBtn2.click(**predict_args))
-        resetBtn.click(lambda: ([], [], "已重置"), None, [chatbot, history, status])
-        resetBtn2.click(lambda: ([], [], "已重置"), None, [chatbot, history, status])
-        clearBtn.click(lambda: ("",""), None, [txt, txt2])
-        clearBtn2.click(lambda: ("",""), None, [txt, txt2])
+        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
+        resetBtn.click(lambda: ([], [], "已重置"), None, [chatbot, history, status])    # 再在后端清除history
+        resetBtn2.click(lambda: ([], [], "已重置"), None, [chatbot, history, status])   # 再在后端清除history
+        clearBtn.click(None, None, [txt, txt2], _js=js_code_clear)
+        clearBtn2.click(None, None, [txt, txt2], _js=js_code_clear)
        if AUTO_CLEAR_TXT:
-            submitBtn.click(lambda: ("",""), None, [txt, txt2])
-            submitBtn2.click(lambda: ("",""), None, [txt, txt2])
-            txt.submit(lambda: ("",""), None, [txt, txt2])
-            txt2.submit(lambda: ("",""), None, [txt, txt2])
+            submitBtn.click(None, None, [txt, txt2], _js=js_code_clear)
+            submitBtn2.click(None, None, [txt, txt2], _js=js_code_clear)
+            txt.submit(None, None, [txt, txt2], _js=js_code_clear)
+            txt2.submit(None, None, [txt, txt2], _js=js_code_clear)
        # 基础功能区的回调函数注册
        for k in functional:
            if ("Visible" in functional[k]) and (not functional[k]["Visible"]): continue
@@ -321,7 +332,7 @@ def main():
            else:
                css_part2 = adjust_theme()._get_theme_css()
            return css_part2 + css_part1
-        
+
        theme_handle = theme_dropdown.select(on_theme_dropdown_changed, [theme_dropdown, secret_css], [secret_css])
        theme_handle.then(
            None,
@@ -346,13 +357,13 @@ def main():
            if not group_list: # 处理特殊情况：没有选择任何插件组
                return [*[plugin['Button'].update(visible=False) for _, plugin in plugins_as_btn.items()], gr.Dropdown.update(choices=[])]
            for k, plugin in plugins.items():
-                if plugin.get("AsButton", True): 
+                if plugin.get("AsButton", True):
                    btn_list.append(plugin['Button'].update(visible=match_group(plugin['Group'], group_list))) # 刷新按钮
                    if plugin.get('AdvancedArgs', False): dropdown_fn_list.append(k) # 对于需要高级参数的插件，亦在下拉菜单中显示
                elif match_group(plugin['Group'], group_list): fns_list.append(k) # 刷新下拉列表
            return [*btn_list, gr.Dropdown.update(choices=fns_list)]
        plugin_group_sel.select(fn=on_group_change, inputs=[plugin_group_sel], outputs=[*[plugin['Button'] for name, plugin in plugins_as_btn.items()], dropdown])
-        if ENABLE_AUDIO: 
+        if ENABLE_AUDIO:
            from crazy_functions.live_audio.audio_io import RealtimeAudioDistribution
            rad = RealtimeAudioDistribution()
            def deal_audio(audio, cookies):
@@ -360,12 +371,12 @@ def main():
            audio_mic.stream(deal_audio, inputs=[audio_mic, cookies])


-        demo.load(init_cookie, inputs=[cookies, chatbot], outputs=[cookies])
-        darkmode_js = js_code_for_darkmode_init
-        demo.load(None, inputs=None, outputs=[persistent_cookie], _js=js_code_for_persistent_cookie_init)
-        demo.load(None, inputs=[dark_mode], outputs=None, _js=darkmode_js)    # 配置暗色主题或亮色主题
+        demo.load(init_cookie, inputs=[cookies], outputs=[cookies])
+        demo.load(persistent_cookie_reload, inputs = [py_pickle_cookie, cookies],
+            outputs = [py_pickle_cookie, cookies, *customize_btns.values(), *predefined_btns.values()], _js=js_code_for_persistent_cookie_init)
+        demo.load(None, inputs=[dark_mode], outputs=None, _js="""(dark_mode)=>{apply_cookie_for_checkbox(dark_mode);}""")    # 配置暗色主题或亮色主题
        demo.load(None, inputs=[gr.Textbox(LAYOUT, visible=False)], outputs=None, _js='(LAYOUT)=>{GptAcademicJavaScriptInit(LAYOUT);}')
-        
+
    # gradio的inbrowser触发不太稳定，回滚代码到原始的浏览器打开函数
    def run_delayed_tasks():
        import threading, webbrowser, time
@@ -376,7 +387,7 @@ def main():
        def auto_updates(): time.sleep(0); auto_update()
        def open_browser(): time.sleep(2); webbrowser.open_new_tab(f"http://localhost:{PORT}")
        def warm_up_mods(): time.sleep(6); warm_up_modules()
-        
+
        threading.Thread(target=auto_updates, name="self-upgrade", daemon=True).start() # 查看自动更新
        threading.Thread(target=open_browser, name="open-browser", daemon=True).start() # 打开浏览器页面
        threading.Thread(target=warm_up_mods, name="warm-up", daemon=True).start()      # 预热tiktoken模块
@@ -384,21 +395,21 @@ def main():
    run_delayed_tasks()
    demo.queue(concurrency_count=CONCURRENT_COUNT).launch(
        quiet=True,
-        server_name="0.0.0.0", 
+        server_name="0.0.0.0",
        ssl_keyfile=None if SSL_KEYFILE == "" else SSL_KEYFILE,
        ssl_certfile=None if SSL_CERTFILE == "" else SSL_CERTFILE,
        ssl_verify=False,
        server_port=PORT,
-        favicon_path=os.path.join(os.path.dirname(__file__), "docs/logo.png"), 
+        favicon_path=os.path.join(os.path.dirname(__file__), "docs/logo.png"),
        auth=AUTHENTICATION if len(AUTHENTICATION) != 0 else None,
        blocked_paths=["config.py","config_private.py","docker-compose.yml","Dockerfile",f"{PATH_LOGGING}/admin"])

    # 如果需要在二级路径下运行
    # CUSTOM_PATH = get_conf('CUSTOM_PATH')
-    # if CUSTOM_PATH != "/": 
+    # if CUSTOM_PATH != "/":
    #     from toolbox import run_gradio_in_subpath
    #     run_gradio_in_subpath(demo, auth=AUTHENTICATION, port=PORT, custom_path=CUSTOM_PATH)
-    # else: 
+    # else:
    #     demo.launch(server_name="0.0.0.0", server_port=PORT, auth=AUTHENTICATION, favicon_path="docs/logo.png",
    #                 blocked_paths=["config.py","config_private.py","docker-compose.yml","Dockerfile",f"{PATH_LOGGING}/admin"])

--- a/multi_language.py
+++ b/multi_language.py
@@ -352,9 +352,9 @@ def step_1_core_key_translate():
        chinese_core_keys_norepeat_mapping.update({k:cached_translation[k]})
    chinese_core_keys_norepeat_mapping = dict(sorted(chinese_core_keys_norepeat_mapping.items(), key=lambda x: -len(x[0])))

-    # ===============================================
+    # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    # copy
-    # ===============================================
+    # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    def copy_source_code():

        from toolbox import get_conf
@@ -367,9 +367,9 @@ def step_1_core_key_translate():
        shutil.copytree('./', backup_dir, ignore=lambda x, y: blacklist)
    copy_source_code()

-    # ===============================================
+    # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    # primary key replace
-    # ===============================================
+    # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    directory_path = f'./multi-language/{LANG}/'
    for root, dirs, files in os.walk(directory_path):
        for file in files:
@@ -389,9 +389,9 @@ def step_1_core_key_translate():

 def step_2_core_key_translate():

-    # =================================================================================================
+    # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    # step2 
-    # =================================================================================================
+    # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

    def load_string(strings, string_input):
        string_ = string_input.strip().strip(',').strip().strip('.').strip()
@@ -492,9 +492,9 @@ def step_2_core_key_translate():
    cached_translation.update(read_map_from_json(language=LANG_STD))
    cached_translation = dict(sorted(cached_translation.items(), key=lambda x: -len(x[0])))

-    # ===============================================
+    # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    # literal key replace
-    # ===============================================
+    # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    directory_path = f'./multi-language/{LANG}/'
    for root, dirs, files in os.walk(directory_path):
        for file in files:
--- a/request_llms/bridge_all.py
+++ b/request_llms/bridge_all.py
@@ -11,7 +11,7 @@
 import tiktoken, copy
 from functools import lru_cache
 from concurrent.futures import ThreadPoolExecutor
-from toolbox import get_conf, trimmed_format_exc
+from toolbox import get_conf, trimmed_format_exc, apply_gpt_academic_string_mask

 from .bridge_chatgpt import predict_no_ui_long_connection as chatgpt_noui
 from .bridge_chatgpt import predict as chatgpt_ui
@@ -31,6 +31,9 @@ from .bridge_qianfan import predict as qianfan_ui
 from .bridge_google_gemini import predict as genai_ui
 from .bridge_google_gemini import predict_no_ui_long_connection  as genai_noui

+from .bridge_zhipu import predict_no_ui_long_connection as zhipu_noui
+from .bridge_zhipu import predict as zhipu_ui
+
 colors = ['#FF00FF', '#00FFFF', '#FF0000', '#990099', '#009999', '#990044']

 class LazyloadTiktoken(object):
@@ -44,13 +47,13 @@ class LazyloadTiktoken(object):
        tmp = tiktoken.encoding_for_model(model)
        print('加载tokenizer完毕')
        return tmp
-    
+
    def encode(self, *args, **kwargs):
-        encoder = self.get_encoder(self.model) 
+        encoder = self.get_encoder(self.model)
        return encoder.encode(*args, **kwargs)
-    
+
    def decode(self, *args, **kwargs):
-        encoder = self.get_encoder(self.model) 
+        encoder = self.get_encoder(self.model)
        return encoder.decode(*args, **kwargs)

 # Endpoint 重定向
@@ -63,7 +66,7 @@ azure_endpoint = AZURE_ENDPOINT + f'openai/deployments/{AZURE_ENGINE}/chat/compl
 # 兼容旧版的配置
 try:
    API_URL = get_conf("API_URL")
-    if API_URL != "https://api.openai.com/v1/chat/completions": 
+    if API_URL != "https://api.openai.com/v1/chat/completions":
        openai_endpoint = API_URL
        print("警告！API_URL配置选项将被弃用，请更换为API_URL_REDIRECT配置")
 except:
@@ -95,7 +98,7 @@ model_info = {
        "tokenizer": tokenizer_gpt35,
        "token_cnt": get_token_num_gpt35,
    },
-    
+
    "gpt-3.5-turbo-16k": {
        "fn_with_ui": chatgpt_ui,
        "fn_without_ui": chatgpt_noui,
@@ -150,6 +153,15 @@ model_info = {
        "token_cnt": get_token_num_gpt4,
    },

+    "gpt-4-turbo-preview": {
+        "fn_with_ui": chatgpt_ui,
+        "fn_without_ui": chatgpt_noui,
+        "endpoint": openai_endpoint,
+        "max_token": 128000,
+        "tokenizer": tokenizer_gpt4,
+        "token_cnt": get_token_num_gpt4,
+    },
+
    "gpt-4-1106-preview": {
        "fn_with_ui": chatgpt_ui,
        "fn_without_ui": chatgpt_noui,
@@ -159,6 +171,15 @@ model_info = {
        "token_cnt": get_token_num_gpt4,
    },

+    "gpt-4-0125-preview": {
+        "fn_with_ui": chatgpt_ui,
+        "fn_without_ui": chatgpt_noui,
+        "endpoint": openai_endpoint,
+        "max_token": 128000,
+        "tokenizer": tokenizer_gpt4,
+        "token_cnt": get_token_num_gpt4,
+    },
+
    "gpt-3.5-random": {
        "fn_with_ui": chatgpt_ui,
        "fn_without_ui": chatgpt_noui,
@@ -167,7 +188,7 @@ model_info = {
        "tokenizer": tokenizer_gpt4,
        "token_cnt": get_token_num_gpt4,
    },
-    
+
    "gpt-4-vision-preview": {
        "fn_with_ui": chatgpt_vision_ui,
        "fn_without_ui": chatgpt_vision_noui,
@@ -197,16 +218,25 @@ model_info = {
        "token_cnt": get_token_num_gpt4,
    },

-    # api_2d (此后不需要在此处添加api2d的接口了，因为下面的代码会自动添加)
-    "api2d-gpt-3.5-turbo": {
-        "fn_with_ui": chatgpt_ui,
-        "fn_without_ui": chatgpt_noui,
-        "endpoint": api2d_endpoint,
-        "max_token": 4096,
+    # 智谱AI
+    "glm-4": {
+        "fn_with_ui": zhipu_ui,
+        "fn_without_ui": zhipu_noui,
+        "endpoint": None,
+        "max_token": 10124 * 8,
+        "tokenizer": tokenizer_gpt35,
+        "token_cnt": get_token_num_gpt35,
+    },
+    "glm-3-turbo": {
+        "fn_with_ui": zhipu_ui,
+        "fn_without_ui": zhipu_noui,
+        "endpoint": None,
+        "max_token": 10124 * 4,
        "tokenizer": tokenizer_gpt35,
        "token_cnt": get_token_num_gpt35,
    },

+    # api_2d (此后不需要在此处添加api2d的接口了，因为下面的代码会自动添加)
    "api2d-gpt-4": {
        "fn_with_ui": chatgpt_ui,
        "fn_without_ui": chatgpt_noui,
@@ -530,7 +560,7 @@ if "sparkv2" in AVAIL_LLM_MODELS:   # 讯飞星火认知大模型
        })
    except:
        print(trimmed_format_exc())
-if "sparkv3" in AVAIL_LLM_MODELS:   # 讯飞星火认知大模型
+if "sparkv3" in AVAIL_LLM_MODELS or "sparkv3.5" in AVAIL_LLM_MODELS:   # 讯飞星火认知大模型
    try:
        from .bridge_spark import predict_no_ui_long_connection as spark_noui
        from .bridge_spark import predict as spark_ui
@@ -542,6 +572,14 @@ if "sparkv3" in AVAIL_LLM_MODELS:   # 讯飞星火认知大模型
                "max_token": 4096,
                "tokenizer": tokenizer_gpt35,
                "token_cnt": get_token_num_gpt35,
+            },
+            "sparkv3.5": {
+                "fn_with_ui": spark_ui,
+                "fn_without_ui": spark_noui,
+                "endpoint": None,
+                "max_token": 4096,
+                "tokenizer": tokenizer_gpt35,
+                "token_cnt": get_token_num_gpt35,
            }
        })
    except:
@@ -562,19 +600,17 @@ if "llama2" in AVAIL_LLM_MODELS:   # llama2
        })
    except:
        print(trimmed_format_exc())
-if "zhipuai" in AVAIL_LLM_MODELS:   # zhipuai
+if "zhipuai" in AVAIL_LLM_MODELS:   # zhipuai 是glm-4的别名，向后兼容配置
    try:
-        from .bridge_zhipu import predict_no_ui_long_connection as zhipu_noui
-        from .bridge_zhipu import predict as zhipu_ui
        model_info.update({
            "zhipuai": {
                "fn_with_ui": zhipu_ui,
                "fn_without_ui": zhipu_noui,
                "endpoint": None,
-                "max_token": 4096,
+                "max_token": 10124 * 8,
                "tokenizer": tokenizer_gpt35,
                "token_cnt": get_token_num_gpt35,
-            }
+            },
        })
    except:
        print(trimmed_format_exc())
@@ -594,13 +630,30 @@ if "deepseekcoder" in AVAIL_LLM_MODELS:   # deepseekcoder
        })
    except:
        print(trimmed_format_exc())
+# if "skylark" in AVAIL_LLM_MODELS:
+#     try:
+#         from .bridge_skylark2 import predict_no_ui_long_connection as skylark_noui
+#         from .bridge_skylark2 import predict as skylark_ui
+#         model_info.update({
+#             "skylark": {
+#                 "fn_with_ui": skylark_ui,
+#                 "fn_without_ui": skylark_noui,
+#                 "endpoint": None,
+#                 "max_token": 4096,
+#                 "tokenizer": tokenizer_gpt35,
+#                 "token_cnt": get_token_num_gpt35,
+#             }
+#         })
+#     except:
+#         print(trimmed_format_exc())
+

 # <-- 用于定义和切换多个azure模型 -->
 AZURE_CFG_ARRAY = get_conf("AZURE_CFG_ARRAY")
 if len(AZURE_CFG_ARRAY) > 0:
    for azure_model_name, azure_cfg_dict in AZURE_CFG_ARRAY.items():
        # 可能会覆盖之前的配置，但这是意料之中的
-        if not azure_model_name.startswith('azure'): 
+        if not azure_model_name.startswith('azure'):
            raise ValueError("AZURE_CFG_ARRAY中配置的模型必须以azure开头")
        endpoint_ = azure_cfg_dict["AZURE_ENDPOINT"] + \
            f'openai/deployments/{azure_cfg_dict["AZURE_ENGINE"]}/chat/completions?api-version=2023-05-15'
@@ -651,6 +704,7 @@ def predict_no_ui_long_connection(inputs, llm_kwargs, history, sys_prompt, obser
    """
    import threading, time, copy

+    inputs = apply_gpt_academic_string_mask(inputs, mode="show_llm")
    model = llm_kwargs['llm_model']
    n_model = 1
    if '&' not in model:
@@ -665,7 +719,7 @@ def predict_no_ui_long_connection(inputs, llm_kwargs, history, sys_prompt, obser
        executor = ThreadPoolExecutor(max_workers=4)
        models = model.split('&')
        n_model = len(models)
-        
+
        window_len = len(observe_window)
        assert window_len==3
        window_mutex = [["", time.time(), ""] for _ in range(n_model)] + [True]
@@ -684,7 +738,7 @@ def predict_no_ui_long_connection(inputs, llm_kwargs, history, sys_prompt, obser
                time.sleep(0.25)
                if not window_mutex[-1]: break
                # 看门狗（watchdog）
-                for i in range(n_model): 
+                for i in range(n_model):
                    window_mutex[i][1] = observe_window[1]
                # 观察窗（window）
                chat_string = []
@@ -724,6 +778,7 @@ def predict(inputs, llm_kwargs, *args, **kwargs):
    additional_fn代表点击的哪个按钮，按钮见functional.py
    """

+    inputs = apply_gpt_academic_string_mask(inputs, mode="show_llm")
    method = model_info[llm_kwargs['llm_model']]["fn_with_ui"]  # 如果这里报错，检查config中的AVAIL_LLM_MODELS选项
    yield from method(inputs, llm_kwargs, *args, **kwargs)

--- a/request_llms/bridge_chatgpt.py
+++ b/request_llms/bridge_chatgpt.py
@@ -113,6 +113,8 @@ def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="",
            error_msg = get_full_error(chunk, stream_response).decode()
            if "reduce the length" in error_msg:
                raise ConnectionAbortedError("OpenAI拒绝了请求:" + error_msg)
+            elif """type":"upstream_error","param":"307""" in error_msg:
+                raise ConnectionAbortedError("正常结束，但显示Token不足，导致输出不完整，请削减单次输入的文本量。")
            else:
                raise RuntimeError("OpenAI拒绝了请求：" + error_msg)
        if ('data: [DONE]' in chunk_decoded): break # api2d 正常完成
@@ -244,6 +246,9 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
                    if has_choices and not choice_valid:
                        # 一些垃圾第三方接口的出现这样的错误
                        continue
+                    if ('data: [DONE]' not in chunk_decoded) and len(chunk_decoded) > 0 and (chunkjson is None):
+                        # 传递进来一些奇怪的东西
+                        raise ValueError(f'无法读取以下数据，请检查配置。\n\n{chunk_decoded}')
                    # 前者是API2D的结束条件，后者是OPENAI的结束条件
                    if ('data: [DONE]' in chunk_decoded) or (len(chunkjson['choices'][0]["delta"]) == 0):
                        # 判定为数据流的结束，gpt_replying_buffer也写完了
--- a/request_llms/bridge_google_gemini.py
+++ b/request_llms/bridge_google_gemini.py
@@ -19,7 +19,7 @@ def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="",
    # 检查API_KEY
    if get_conf("GEMINI_API_KEY") == "":
        raise ValueError(f"请配置 GEMINI_API_KEY。")
-    
+
    genai = GoogleChatInit()
    watch_dog_patience = 5  # 看门狗的耐心, 设置5秒即可
    gpt_replying_buffer = ''
@@ -50,8 +50,17 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
        yield from update_ui_lastest_msg(f"请配置 GEMINI_API_KEY。", chatbot=chatbot, history=history, delay=0)
        return

+    # 适配润色区域
+    if additional_fn is not None:
+        from core_functional import handle_core_functionality
+        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
+
    if "vision" in llm_kwargs["llm_model"]:
        have_recent_file, image_paths = have_any_recent_upload_image_files(chatbot)
+        if not have_recent_file:
+            chatbot.append((inputs, "没有检测到任何近期上传的图像文件，请上传jpg格式的图片，此外，请注意拓展名需要小写"))
+            yield from update_ui(chatbot=chatbot, history=history, msg="等待图片") # 刷新界面
+            return
        def make_media_input(inputs, image_paths): 
            for image_path in image_paths:
                inputs = inputs + f'<br/><br/><div align="center"><img src="file={os.path.abspath(image_path)}"></div>'
--- a/request_llms/bridge_newbingfree.py
+++ b/request_llms/bridge_newbingfree.py
@@ -1,16 +1,17 @@
 """
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 第一部分：来自EdgeGPT.py
 https://github.com/acheong08/EdgeGPT
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 """
 from .edge_gpt_free import Chatbot as NewbingChatbot
+
 load_message = "等待NewBing响应。"

 """
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 第二部分：子进程Worker（调用主体）
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 """
 import time
 import json
@@ -22,19 +23,30 @@ import threading
 from toolbox import update_ui, get_conf, trimmed_format_exc
 from multiprocessing import Process, Pipe

+
 def preprocess_newbing_out(s):
-    pattern = r'\^(\d+)\^' # 匹配^数字^
-    sub = lambda m: '('+m.group(1)+')' # 将匹配到的数字作为替换值
-    result = re.sub(pattern, sub, s) # 替换操作
-    if '[1]' in result:
-        result += '\n\n```reference\n' + "\n".join([r for r in result.split('\n') if r.startswith('[')]) + '\n```\n'
+    pattern = r"\^(\d+)\^"  # 匹配^数字^
+    sub = lambda m: "(" + m.group(1) + ")"  # 将匹配到的数字作为替换值
+    result = re.sub(pattern, sub, s)  # 替换操作
+    if "[1]" in result:
+        result += (
+            "\n\n```reference\n"
+            + "\n".join([r for r in result.split("\n") if r.startswith("[")])
+            + "\n```\n"
+        )
    return result

+
 def preprocess_newbing_out_simple(result):
-    if '[1]' in result:
-        result += '\n\n```reference\n' + "\n".join([r for r in result.split('\n') if r.startswith('[')]) + '\n```\n'
+    if "[1]" in result:
+        result += (
+            "\n\n```reference\n"
+            + "\n".join([r for r in result.split("\n") if r.startswith("[")])
+            + "\n```\n"
+        )
    return result

+
 class NewBingHandle(Process):
    def __init__(self):
        super().__init__(daemon=True)
@@ -46,11 +58,12 @@ class NewBingHandle(Process):
        self.check_dependency()
        self.start()
        self.threadLock = threading.Lock()
-        
+
    def check_dependency(self):
        try:
            self.success = False
            import certifi, httpx, rich
+
            self.info = "依赖检测通过，等待NewBing响应。注意目前不能多人同时调用NewBing接口（有线程锁），否则将导致每个人的NewBing问询历史互相渗透。调用NewBing时，会自动使用已配置的代理。"
            self.success = True
        except:
@@ -62,18 +75,19 @@ class NewBingHandle(Process):

    async def async_run(self):
        # 读取配置
-        NEWBING_STYLE = get_conf('NEWBING_STYLE')
+        NEWBING_STYLE = get_conf("NEWBING_STYLE")
        from request_llms.bridge_all import model_info
-        endpoint = model_info['newbing']['endpoint']
+
+        endpoint = model_info["newbing"]["endpoint"]
        while True:
            # 等待
            kwargs = self.child.recv()
-            question=kwargs['query']
-            history=kwargs['history']
-            system_prompt=kwargs['system_prompt']
+            question = kwargs["query"]
+            history = kwargs["history"]
+            system_prompt = kwargs["system_prompt"]

            # 是否重置
-            if len(self.local_history) > 0 and len(history)==0:
+            if len(self.local_history) > 0 and len(history) == 0:
                await self.newbing_model.reset()
                self.local_history = []

@@ -81,34 +95,33 @@ class NewBingHandle(Process):
            prompt = ""
            if system_prompt not in self.local_history:
                self.local_history.append(system_prompt)
-                prompt += system_prompt + '\n'
+                prompt += system_prompt + "\n"

            # 追加历史
            for ab in history:
                a, b = ab
                if a not in self.local_history:
                    self.local_history.append(a)
-                    prompt += a + '\n'
+                    prompt += a + "\n"

            # 问题
            prompt += question
            self.local_history.append(question)
-            print('question:', prompt)
+            print("question:", prompt)
            # 提交
            async for final, response in self.newbing_model.ask_stream(
                prompt=question,
-                conversation_style=NEWBING_STYLE,     # ["creative", "balanced", "precise"]
-                wss_link=endpoint,                    # "wss://sydney.bing.com/sydney/ChatHub"
+                conversation_style=NEWBING_STYLE,  # ["creative", "balanced", "precise"]
+                wss_link=endpoint,  # "wss://sydney.bing.com/sydney/ChatHub"
            ):
                if not final:
                    print(response)
                    self.child.send(str(response))
                else:
-                    print('-------- receive final ---------')
-                    self.child.send('[Finish]')
+                    print("-------- receive final ---------")
+                    self.child.send("[Finish]")
                    # self.local_history.append(response)

-    
    def run(self):
        """
        这个函数运行在子进程
@@ -118,32 +131,37 @@ class NewBingHandle(Process):
        self.local_history = []
        if (self.newbing_model is None) or (not self.success):
            # 代理设置
-            proxies, NEWBING_COOKIES = get_conf('proxies', 'NEWBING_COOKIES')
-            if proxies is None: 
+            proxies, NEWBING_COOKIES = get_conf("proxies", "NEWBING_COOKIES")
+            if proxies is None:
                self.proxies_https = None
-            else: 
-                self.proxies_https = proxies['https']
+            else:
+                self.proxies_https = proxies["https"]

            if (NEWBING_COOKIES is not None) and len(NEWBING_COOKIES) > 100:
                try:
                    cookies = json.loads(NEWBING_COOKIES)
                except:
                    self.success = False
-                    tb_str = '\n```\n' + trimmed_format_exc() + '\n```\n'
-                    self.child.send(f'[Local Message] NEWBING_COOKIES未填写或有格式错误。')
-                    self.child.send('[Fail]'); self.child.send('[Finish]')
+                    tb_str = "\n```\n" + trimmed_format_exc() + "\n```\n"
+                    self.child.send(f"[Local Message] NEWBING_COOKIES未填写或有格式错误。")
+                    self.child.send("[Fail]")
+                    self.child.send("[Finish]")
                    raise RuntimeError(f"NEWBING_COOKIES未填写或有格式错误。")
            else:
                cookies = None

            try:
-                self.newbing_model = NewbingChatbot(proxy=self.proxies_https, cookies=cookies)
+                self.newbing_model = NewbingChatbot(
+                    proxy=self.proxies_https, cookies=cookies
+                )
            except:
                self.success = False
-                tb_str = '\n```\n' + trimmed_format_exc() + '\n```\n'
-                self.child.send(f'[Local Message] 不能加载Newbing组件，请注意Newbing组件已不再维护。{tb_str}')
-                self.child.send('[Fail]')
-                self.child.send('[Finish]')
+                tb_str = "\n```\n" + trimmed_format_exc() + "\n```\n"
+                self.child.send(
+                    f"[Local Message] 不能加载Newbing组件，请注意Newbing组件已不再维护。{tb_str}"
+                )
+                self.child.send("[Fail]")
+                self.child.send("[Finish]")
                raise RuntimeError(f"不能加载Newbing组件，请注意Newbing组件已不再维护。")

        self.success = True
@@ -151,66 +169,100 @@ class NewBingHandle(Process):
            # 进入任务等待状态
            asyncio.run(self.async_run())
        except Exception:
-            tb_str = '\n```\n' + trimmed_format_exc() + '\n```\n'
-            self.child.send(f'[Local Message] Newbing 请求失败，报错信息如下. 如果是与网络相关的问题，建议更换代理协议（推荐http）或代理节点 {tb_str}.')
-            self.child.send('[Fail]')
-            self.child.send('[Finish]')
-        
+            tb_str = "\n```\n" + trimmed_format_exc() + "\n```\n"
+            self.child.send(
+                f"[Local Message] Newbing 请求失败，报错信息如下. 如果是与网络相关的问题，建议更换代理协议（推荐http）或代理节点 {tb_str}."
+            )
+            self.child.send("[Fail]")
+            self.child.send("[Finish]")
+
    def stream_chat(self, **kwargs):
        """
        这个函数运行在主进程
        """
-        self.threadLock.acquire()   # 获取线程锁
-        self.parent.send(kwargs)    # 请求子进程
+        self.threadLock.acquire()  # 获取线程锁
+        self.parent.send(kwargs)  # 请求子进程
        while True:
-            res = self.parent.recv()                            # 等待newbing回复的片段
-            if res == '[Finish]': break                         # 结束
-            elif res == '[Fail]': self.success = False; break   # 失败
-            else: yield res                                     # newbing回复的片段
-        self.threadLock.release()   # 释放线程锁
+            res = self.parent.recv()  # 等待newbing回复的片段
+            if res == "[Finish]":
+                break  # 结束
+            elif res == "[Fail]":
+                self.success = False
+                break  # 失败
+            else:
+                yield res  # newbing回复的片段
+        self.threadLock.release()  # 释放线程锁


 """
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 第三部分：主进程统一调用函数接口
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 """
 global newbingfree_handle
 newbingfree_handle = None

-def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="", observe_window=[], console_slience=False):
+
+def predict_no_ui_long_connection(
+    inputs,
+    llm_kwargs,
+    history=[],
+    sys_prompt="",
+    observe_window=[],
+    console_slience=False,
+):
    """
-        多线程方法
-        函数的说明请见 request_llms/bridge_all.py
+    多线程方法
+    函数的说明请见 request_llms/bridge_all.py
    """
    global newbingfree_handle
    if (newbingfree_handle is None) or (not newbingfree_handle.success):
        newbingfree_handle = NewBingHandle()
-        if len(observe_window) >= 1: observe_window[0] = load_message + "\n\n" + newbingfree_handle.info
-        if not newbingfree_handle.success: 
+        if len(observe_window) >= 1:
+            observe_window[0] = load_message + "\n\n" + newbingfree_handle.info
+        if not newbingfree_handle.success:
            error = newbingfree_handle.info
            newbingfree_handle = None
            raise RuntimeError(error)

    # 没有 sys_prompt 接口，因此把prompt加入 history
    history_feedin = []
-    for i in range(len(history)//2):
-        history_feedin.append([history[2*i], history[2*i+1]] )
+    for i in range(len(history) // 2):
+        history_feedin.append([history[2 * i], history[2 * i + 1]])

-    watch_dog_patience = 5 # 看门狗 (watchdog) 的耐心, 设置5秒即可
+    watch_dog_patience = 5  # 看门狗 (watchdog) 的耐心, 设置5秒即可
    response = ""
-    if len(observe_window) >= 1: observe_window[0] = "[Local Message] 等待NewBing响应中 ..."
-    for response in newbingfree_handle.stream_chat(query=inputs, history=history_feedin, system_prompt=sys_prompt, max_length=llm_kwargs['max_length'], top_p=llm_kwargs['top_p'], temperature=llm_kwargs['temperature']):
-        if len(observe_window) >= 1:  observe_window[0] = preprocess_newbing_out_simple(response)
-        if len(observe_window) >= 2:  
-            if (time.time()-observe_window[1]) > watch_dog_patience:
+    if len(observe_window) >= 1:
+        observe_window[0] = "[Local Message] 等待NewBing响应中 ..."
+    for response in newbingfree_handle.stream_chat(
+        query=inputs,
+        history=history_feedin,
+        system_prompt=sys_prompt,
+        max_length=llm_kwargs["max_length"],
+        top_p=llm_kwargs["top_p"],
+        temperature=llm_kwargs["temperature"],
+    ):
+        if len(observe_window) >= 1:
+            observe_window[0] = preprocess_newbing_out_simple(response)
+        if len(observe_window) >= 2:
+            if (time.time() - observe_window[1]) > watch_dog_patience:
                raise RuntimeError("程序终止。")
    return preprocess_newbing_out_simple(response)

-def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_prompt='', stream = True, additional_fn=None):
+
+def predict(
+    inputs,
+    llm_kwargs,
+    plugin_kwargs,
+    chatbot,
+    history=[],
+    system_prompt="",
+    stream=True,
+    additional_fn=None,
+):
    """
-        单线程方法
-        函数的说明请见 request_llms/bridge_all.py
+    单线程方法
+    函数的说明请见 request_llms/bridge_all.py
    """
    chatbot.append((inputs, "[Local Message] 等待NewBing响应中 ..."))

@@ -219,27 +271,41 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
        newbingfree_handle = NewBingHandle()
        chatbot[-1] = (inputs, load_message + "\n\n" + newbingfree_handle.info)
        yield from update_ui(chatbot=chatbot, history=[])
-        if not newbingfree_handle.success: 
+        if not newbingfree_handle.success:
            newbingfree_handle = None
            return

    if additional_fn is not None:
        from core_functional import handle_core_functionality
-        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
+
+        inputs, history = handle_core_functionality(
+            additional_fn, inputs, history, chatbot
+        )

    history_feedin = []
-    for i in range(len(history)//2):
-        history_feedin.append([history[2*i], history[2*i+1]] )
+    for i in range(len(history) // 2):
+        history_feedin.append([history[2 * i], history[2 * i + 1]])

    chatbot[-1] = (inputs, "[Local Message] 等待NewBing响应中 ...")
    response = "[Local Message] 等待NewBing响应中 ..."
-    yield from update_ui(chatbot=chatbot, history=history, msg="NewBing响应缓慢，尚未完成全部响应，请耐心完成后再提交新问题。")
-    for response in newbingfree_handle.stream_chat(query=inputs, history=history_feedin, system_prompt=system_prompt, max_length=llm_kwargs['max_length'], top_p=llm_kwargs['top_p'], temperature=llm_kwargs['temperature']):
+    yield from update_ui(
+        chatbot=chatbot, history=history, msg="NewBing响应缓慢，尚未完成全部响应，请耐心完成后再提交新问题。"
+    )
+    for response in newbingfree_handle.stream_chat(
+        query=inputs,
+        history=history_feedin,
+        system_prompt=system_prompt,
+        max_length=llm_kwargs["max_length"],
+        top_p=llm_kwargs["top_p"],
+        temperature=llm_kwargs["temperature"],
+    ):
        chatbot[-1] = (inputs, preprocess_newbing_out(response))
-        yield from update_ui(chatbot=chatbot, history=history, msg="NewBing响应缓慢，尚未完成全部响应，请耐心完成后再提交新问题。")
-    if response == "[Local Message] 等待NewBing响应中 ...": response = "[Local Message] NewBing响应异常，请刷新界面重试 ..."
+        yield from update_ui(
+            chatbot=chatbot, history=history, msg="NewBing响应缓慢，尚未完成全部响应，请耐心完成后再提交新问题。"
+        )
+    if response == "[Local Message] 等待NewBing响应中 ...":
+        response = "[Local Message] NewBing响应异常，请刷新界面重试 ..."
    history.extend([inputs, response])
-    logging.info(f'[raw_input] {inputs}')
-    logging.info(f'[response] {response}')
+    logging.info(f"[raw_input] {inputs}")
+    logging.info(f"[response] {response}")
    yield from update_ui(chatbot=chatbot, history=history, msg="完成全部响应，请提交新问题。")
-
--- a/request_llms/bridge_qianfan.py
+++ b/request_llms/bridge_qianfan.py
@@ -146,21 +146,17 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
    yield from update_ui(chatbot=chatbot, history=history)
    # 开始接收回复
    try:
+        response = f"[Local Message] 等待{model_name}响应中 ..."
        for response in generate_from_baidu_qianfan(inputs, llm_kwargs, history, system_prompt):
            chatbot[-1] = (inputs, response)
            yield from update_ui(chatbot=chatbot, history=history)
+        history.extend([inputs, response])
+        yield from update_ui(chatbot=chatbot, history=history)
    except ConnectionAbortedError as e:
        from .bridge_all import model_info
        if len(history) >= 2: history[-1] = ""; history[-2] = "" # 清除当前溢出的输入：history[-2] 是本次输入, history[-1] 是本次输出
-        history = clip_history(inputs=inputs, history=history, tokenizer=model_info[llm_kwargs['llm_model']]['tokenizer'], 
+        history = clip_history(inputs=inputs, history=history, tokenizer=model_info[llm_kwargs['llm_model']]['tokenizer'],
                    max_token_limit=(model_info[llm_kwargs['llm_model']]['max_token'])) # history至少释放二分之一
        chatbot[-1] = (chatbot[-1][0], "[Local Message] Reduce the length. 本次输入过长, 或历史数据过长. 历史缓存数据已部分释放, 您可以请再次尝试. (若再次失败则更可能是因为输入过长.)")
        yield from update_ui(chatbot=chatbot, history=history, msg="异常") # 刷新界面
        return
-    
-    # 总结输出
-    response = f"[Local Message] {model_name}响应异常 ..."
-    if response == f"[Local Message] 等待{model_name}响应中 ...":
-        response = f"[Local Message] {model_name}响应异常 ..."
-    history.extend([inputs, response])
-    yield from update_ui(chatbot=chatbot, history=history)
--- a/request_llms/bridge_qwen.py
+++ b/request_llms/bridge_qwen.py
@@ -51,6 +51,7 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
    # 开始接收回复
    from .com_qwenapi import QwenRequestInstance
    sri = QwenRequestInstance()
+    response = f"[Local Message] 等待{model_name}响应中 ..."
    for response in sri.generate(inputs, llm_kwargs, history, system_prompt):
        chatbot[-1] = (inputs, response)
        yield from update_ui(chatbot=chatbot, history=history)
--- a/request_llms/bridge_skylark2.py
+++ b/request_llms/bridge_skylark2.py
@@ -0,0 +1,68 @@
+import time
+from toolbox import update_ui, get_conf, update_ui_lastest_msg
+from toolbox import check_packages, report_exception
+
+model_name = '云雀大模型'
+
+def validate_key():
+    YUNQUE_SECRET_KEY = get_conf("YUNQUE_SECRET_KEY")
+    if YUNQUE_SECRET_KEY == '': return False
+    return True
+
+def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="", observe_window=[], console_slience=False):
+    """
+        ⭐ 多线程方法
+        函数的说明请见 request_llms/bridge_all.py
+    """
+    watch_dog_patience = 5
+    response = ""
+
+    if validate_key() is False:
+        raise RuntimeError('请配置YUNQUE_SECRET_KEY')
+
+    from .com_skylark2api import YUNQUERequestInstance
+    sri = YUNQUERequestInstance()
+    for response in sri.generate(inputs, llm_kwargs, history, sys_prompt):
+        if len(observe_window) >= 1:
+            observe_window[0] = response
+        if len(observe_window) >= 2:
+            if (time.time()-observe_window[1]) > watch_dog_patience: raise RuntimeError("程序终止。")
+    return response
+
+def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_prompt='', stream = True, additional_fn=None):
+    """
+        ⭐ 单线程方法
+        函数的说明请见 request_llms/bridge_all.py
+    """
+    chatbot.append((inputs, ""))
+    yield from update_ui(chatbot=chatbot, history=history)
+
+    # 尝试导入依赖，如果缺少依赖，则给出安装建议
+    try:
+        check_packages(["zhipuai"])
+    except:
+        yield from update_ui_lastest_msg(f"导入软件依赖失败。使用该模型需要额外依赖，安装方法```pip install --upgrade zhipuai```。",
+                                         chatbot=chatbot, history=history, delay=0)
+        return
+
+    if validate_key() is False:
+        yield from update_ui_lastest_msg(lastmsg="[Local Message] 请配置HUOSHAN_API_KEY", chatbot=chatbot, history=history, delay=0)
+        return
+
+    if additional_fn is not None:
+        from core_functional import handle_core_functionality
+        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
+
+    # 开始接收回复
+    from .com_skylark2api import YUNQUERequestInstance
+    sri = YUNQUERequestInstance()
+    response = f"[Local Message] 等待{model_name}响应中 ..."
+    for response in sri.generate(inputs, llm_kwargs, history, system_prompt):
+        chatbot[-1] = (inputs, response)
+        yield from update_ui(chatbot=chatbot, history=history)
+
+    # 总结输出
+    if response == f"[Local Message] 等待{model_name}响应中 ...":
+        response = f"[Local Message] {model_name}响应异常 ..."
+    history.extend([inputs, response])
+    yield from update_ui(chatbot=chatbot, history=history)
--- a/request_llms/bridge_spark.py
+++ b/request_llms/bridge_spark.py
@@ -9,7 +9,7 @@ model_name = '星火认知大模型'

 def validate_key():
    XFYUN_APPID = get_conf('XFYUN_APPID')
-    if XFYUN_APPID == '00000000' or XFYUN_APPID == '': 
+    if XFYUN_APPID == '00000000' or XFYUN_APPID == '':
        return False
    return True

@@ -49,9 +49,10 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
        from core_functional import handle_core_functionality
        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)

-    # 开始接收回复    
+    # 开始接收回复
    from .com_sparkapi import SparkRequestInstance
    sri = SparkRequestInstance()
+    response = f"[Local Message] 等待{model_name}响应中 ..."
    for response in sri.generate(inputs, llm_kwargs, history, system_prompt, use_image_api=True):
        chatbot[-1] = (inputs, response)
        yield from update_ui(chatbot=chatbot, history=history)
--- a/request_llms/bridge_stackclaude.py
+++ b/request_llms/bridge_stackclaude.py
@@ -7,14 +7,15 @@ import logging
 import time
 from toolbox import get_conf
 import asyncio
+
 load_message = "正在加载Claude组件，请稍候..."

 try:
    """
-    ========================================================================
+    =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    第一部分：Slack API Client
    https://github.com/yokonsan/claude-in-slack-api
-    ========================================================================
+    =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    """

    from slack_sdk.errors import SlackApiError
@@ -23,20 +24,23 @@ try:
    class SlackClient(AsyncWebClient):
        """SlackClient类用于与Slack API进行交互，实现消息发送、接收等功能。

-            属性：
-            - CHANNEL_ID：str类型，表示频道ID。
+        属性：
+        - CHANNEL_ID：str类型，表示频道ID。

-            方法：
-            - open_channel()：异步方法。通过调用conversations_open方法打开一个频道，并将返回的频道ID保存在属性CHANNEL_ID中。
-            - chat(text: str)：异步方法。向已打开的频道发送一条文本消息。
-            - get_slack_messages()：异步方法。获取已打开频道的最新消息并返回消息列表，目前不支持历史消息查询。
-            - get_reply()：异步方法。循环监听已打开频道的消息，如果收到"Typing…_"结尾的消息说明Claude还在继续输出，否则结束循环。
+        方法：
+        - open_channel()：异步方法。通过调用conversations_open方法打开一个频道，并将返回的频道ID保存在属性CHANNEL_ID中。
+        - chat(text: str)：异步方法。向已打开的频道发送一条文本消息。
+        - get_slack_messages()：异步方法。获取已打开频道的最新消息并返回消息列表，目前不支持历史消息查询。
+        - get_reply()：异步方法。循环监听已打开频道的消息，如果收到"Typing…_"结尾的消息说明Claude还在继续输出，否则结束循环。

        """
+
        CHANNEL_ID = None

        async def open_channel(self):
-            response = await self.conversations_open(users=get_conf('SLACK_CLAUDE_BOT_ID'))
+            response = await self.conversations_open(
+                users=get_conf("SLACK_CLAUDE_BOT_ID")
+            )
            self.CHANNEL_ID = response["channel"]["id"]

        async def chat(self, text):
@@ -49,33 +53,39 @@ try:
        async def get_slack_messages(self):
            try:
                # TODO：暂时不支持历史消息，因为在同一个频道里存在多人使用时历史消息渗透问题
-                resp = await self.conversations_history(channel=self.CHANNEL_ID, oldest=self.LAST_TS, limit=1)
-                msg = [msg for msg in resp["messages"]
-                    if msg.get("user") == get_conf('SLACK_CLAUDE_BOT_ID')]
+                resp = await self.conversations_history(
+                    channel=self.CHANNEL_ID, oldest=self.LAST_TS, limit=1
+                )
+                msg = [
+                    msg
+                    for msg in resp["messages"]
+                    if msg.get("user") == get_conf("SLACK_CLAUDE_BOT_ID")
+                ]
                return msg
            except (SlackApiError, KeyError) as e:
                raise RuntimeError(f"获取Slack消息失败。")
-        
+
        async def get_reply(self):
            while True:
                slack_msgs = await self.get_slack_messages()
                if len(slack_msgs) == 0:
                    await asyncio.sleep(0.5)
                    continue
-                
+
                msg = slack_msgs[-1]
                if msg["text"].endswith("Typing…_"):
                    yield False, msg["text"]
                else:
                    yield True, msg["text"]
                    break
+
 except:
    pass

 """
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 第二部分：子进程Worker（调用主体）
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 """


@@ -88,7 +98,7 @@ class ClaudeHandle(Process):
        self.success = True
        self.local_history = []
        self.check_dependency()
-        if self.success: 
+        if self.success:
            self.start()
            self.threadLock = threading.Lock()

@@ -96,6 +106,7 @@ class ClaudeHandle(Process):
        try:
            self.success = False
            import slack_sdk
+
            self.info = "依赖检测通过，等待Claude响应。注意目前不能多人同时调用Claude接口（有线程锁），否则将导致每个人的Claude问询历史互相渗透。调用Claude时，会自动使用已配置的代理。"
            self.success = True
        except:
@@ -103,40 +114,44 @@ class ClaudeHandle(Process):
            self.success = False

    def ready(self):
-        return self.claude_model is not None    
-    
+        return self.claude_model is not None
+
    async def async_run(self):
        await self.claude_model.open_channel()
        while True:
            # 等待
            kwargs = self.child.recv()
-            question = kwargs['query']
-            history = kwargs['history']
+            question = kwargs["query"]
+            history = kwargs["history"]

            # 开始问问题
            prompt = ""

            # 问题
            prompt += question
-            print('question:', prompt)
+            print("question:", prompt)

            # 提交
            await self.claude_model.chat(prompt)
-            
+
            # 获取回复
-            async for final, response in self.claude_model.get_reply():                
+            async for final, response in self.claude_model.get_reply():
                if not final:
                    print(response)
                    self.child.send(str(response))
                else:
                    # 防止丢失最后一条消息
                    slack_msgs = await self.claude_model.get_slack_messages()
-                    last_msg = slack_msgs[-1]["text"] if slack_msgs and len(slack_msgs) > 0 else ""
+                    last_msg = (
+                        slack_msgs[-1]["text"]
+                        if slack_msgs and len(slack_msgs) > 0
+                        else ""
+                    )
                    if last_msg:
                        self.child.send(last_msg)
-                    print('-------- receive final ---------')
-                    self.child.send('[Finish]')
-                    
+                    print("-------- receive final ---------")
+                    self.child.send("[Finish]")
+
    def run(self):
        """
        这个函数运行在子进程
@@ -146,22 +161,24 @@ class ClaudeHandle(Process):
        self.local_history = []
        if (self.claude_model is None) or (not self.success):
            # 代理设置
-            proxies = get_conf('proxies')
+            proxies = get_conf("proxies")
            if proxies is None:
                self.proxies_https = None
            else:
-                self.proxies_https = proxies['https']
+                self.proxies_https = proxies["https"]

            try:
-                SLACK_CLAUDE_USER_TOKEN = get_conf('SLACK_CLAUDE_USER_TOKEN')
-                self.claude_model = SlackClient(token=SLACK_CLAUDE_USER_TOKEN, proxy=self.proxies_https)
-                print('Claude组件初始化成功。')
+                SLACK_CLAUDE_USER_TOKEN = get_conf("SLACK_CLAUDE_USER_TOKEN")
+                self.claude_model = SlackClient(
+                    token=SLACK_CLAUDE_USER_TOKEN, proxy=self.proxies_https
+                )
+                print("Claude组件初始化成功。")
            except:
                self.success = False
-                tb_str = '\n```\n' + trimmed_format_exc() + '\n```\n'
-                self.child.send(f'[Local Message] 不能加载Claude组件。{tb_str}')
-                self.child.send('[Fail]')
-                self.child.send('[Finish]')
+                tb_str = "\n```\n" + trimmed_format_exc() + "\n```\n"
+                self.child.send(f"[Local Message] 不能加载Claude组件。{tb_str}")
+                self.child.send("[Fail]")
+                self.child.send("[Finish]")
                raise RuntimeError(f"不能加载Claude组件。")

        self.success = True
@@ -169,42 +186,49 @@ class ClaudeHandle(Process):
            # 进入任务等待状态
            asyncio.run(self.async_run())
        except Exception:
-            tb_str = '\n```\n' + trimmed_format_exc() + '\n```\n'
-            self.child.send(f'[Local Message] Claude失败 {tb_str}.')
-            self.child.send('[Fail]')
-            self.child.send('[Finish]')
+            tb_str = "\n```\n" + trimmed_format_exc() + "\n```\n"
+            self.child.send(f"[Local Message] Claude失败 {tb_str}.")
+            self.child.send("[Fail]")
+            self.child.send("[Finish]")

    def stream_chat(self, **kwargs):
        """
        这个函数运行在主进程
        """
        self.threadLock.acquire()
-        self.parent.send(kwargs)    # 发送请求到子进程
+        self.parent.send(kwargs)  # 发送请求到子进程
        while True:
-            res = self.parent.recv()    # 等待Claude回复的片段
-            if res == '[Finish]':
-                break       # 结束
-            elif res == '[Fail]':
+            res = self.parent.recv()  # 等待Claude回复的片段
+            if res == "[Finish]":
+                break  # 结束
+            elif res == "[Fail]":
                self.success = False
                break
            else:
-                yield res   # Claude回复的片段
+                yield res  # Claude回复的片段
        self.threadLock.release()


 """
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 第三部分：主进程统一调用函数接口
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 """
 global claude_handle
 claude_handle = None


-def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="", observe_window=None, console_slience=False):
+def predict_no_ui_long_connection(
+    inputs,
+    llm_kwargs,
+    history=[],
+    sys_prompt="",
+    observe_window=None,
+    console_slience=False,
+):
    """
-        多线程方法
-        函数的说明请见 request_llms/bridge_all.py
+    多线程方法
+    函数的说明请见 request_llms/bridge_all.py
    """
    global claude_handle
    if (claude_handle is None) or (not claude_handle.success):
@@ -217,24 +241,40 @@ def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="",

    # 没有 sys_prompt 接口，因此把prompt加入 history
    history_feedin = []
-    for i in range(len(history)//2):
-        history_feedin.append([history[2*i], history[2*i+1]])
+    for i in range(len(history) // 2):
+        history_feedin.append([history[2 * i], history[2 * i + 1]])

    watch_dog_patience = 5  # 看门狗 (watchdog) 的耐心, 设置5秒即可
    response = ""
    observe_window[0] = "[Local Message] 等待Claude响应中 ..."
-    for response in claude_handle.stream_chat(query=inputs, history=history_feedin, system_prompt=sys_prompt, max_length=llm_kwargs['max_length'], top_p=llm_kwargs['top_p'], temperature=llm_kwargs['temperature']):
+    for response in claude_handle.stream_chat(
+        query=inputs,
+        history=history_feedin,
+        system_prompt=sys_prompt,
+        max_length=llm_kwargs["max_length"],
+        top_p=llm_kwargs["top_p"],
+        temperature=llm_kwargs["temperature"],
+    ):
        observe_window[0] = preprocess_newbing_out_simple(response)
        if len(observe_window) >= 2:
-            if (time.time()-observe_window[1]) > watch_dog_patience:
+            if (time.time() - observe_window[1]) > watch_dog_patience:
                raise RuntimeError("程序终止。")
    return preprocess_newbing_out_simple(response)


-def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_prompt='', stream=True, additional_fn=None):
+def predict(
+    inputs,
+    llm_kwargs,
+    plugin_kwargs,
+    chatbot,
+    history=[],
+    system_prompt="",
+    stream=True,
+    additional_fn=None,
+):
    """
-        单线程方法
-        函数的说明请见 request_llms/bridge_all.py
+    单线程方法
+    函数的说明请见 request_llms/bridge_all.py
    """
    chatbot.append((inputs, "[Local Message] 等待Claude响应中 ..."))

@@ -249,21 +289,30 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp

    if additional_fn is not None:
        from core_functional import handle_core_functionality
-        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
+
+        inputs, history = handle_core_functionality(
+            additional_fn, inputs, history, chatbot
+        )

    history_feedin = []
-    for i in range(len(history)//2):
-        history_feedin.append([history[2*i], history[2*i+1]])
+    for i in range(len(history) // 2):
+        history_feedin.append([history[2 * i], history[2 * i + 1]])

    chatbot[-1] = (inputs, "[Local Message] 等待Claude响应中 ...")
    response = "[Local Message] 等待Claude响应中 ..."
-    yield from update_ui(chatbot=chatbot, history=history, msg="Claude响应缓慢，尚未完成全部响应，请耐心完成后再提交新问题。")
-    for response in claude_handle.stream_chat(query=inputs, history=history_feedin, system_prompt=system_prompt):
+    yield from update_ui(
+        chatbot=chatbot, history=history, msg="Claude响应缓慢，尚未完成全部响应，请耐心完成后再提交新问题。"
+    )
+    for response in claude_handle.stream_chat(
+        query=inputs, history=history_feedin, system_prompt=system_prompt
+    ):
        chatbot[-1] = (inputs, preprocess_newbing_out(response))
-        yield from update_ui(chatbot=chatbot, history=history, msg="Claude响应缓慢，尚未完成全部响应，请耐心完成后再提交新问题。")
+        yield from update_ui(
+            chatbot=chatbot, history=history, msg="Claude响应缓慢，尚未完成全部响应，请耐心完成后再提交新问题。"
+        )
    if response == "[Local Message] 等待Claude响应中 ...":
        response = "[Local Message] Claude响应异常，请刷新界面重试 ..."
    history.extend([inputs, response])
-    logging.info(f'[raw_input] {inputs}')
-    logging.info(f'[response] {response}')
+    logging.info(f"[raw_input] {inputs}")
+    logging.info(f"[response] {response}")
    yield from update_ui(chatbot=chatbot, history=history, msg="完成全部响应，请提交新问题。")
--- a/request_llms/bridge_zhipu.py
+++ b/request_llms/bridge_zhipu.py
@@ -1,15 +1,21 @@
-
 import time
+import os
 from toolbox import update_ui, get_conf, update_ui_lastest_msg
-from toolbox import check_packages, report_exception
+from toolbox import check_packages, report_exception, have_any_recent_upload_image_files

 model_name = '智谱AI大模型'
+zhipuai_default_model = 'glm-4'

 def validate_key():
    ZHIPUAI_API_KEY = get_conf("ZHIPUAI_API_KEY")
    if ZHIPUAI_API_KEY == '': return False
    return True

+def make_media_input(inputs, image_paths):
+    for image_path in image_paths:
+        inputs = inputs + f'<br/><br/><div align="center"><img src="file={os.path.abspath(image_path)}"></div>'
+    return inputs
+
 def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="", observe_window=[], console_slience=False):
    """
        ⭐多线程方法
@@ -18,24 +24,30 @@ def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="",
    watch_dog_patience = 5
    response = ""

+    if llm_kwargs["llm_model"] == "zhipuai":
+        llm_kwargs["llm_model"] = zhipuai_default_model
+
    if validate_key() is False:
        raise RuntimeError('请配置ZHIPUAI_API_KEY')

-    from .com_zhipuapi import ZhipuRequestInstance
-    sri = ZhipuRequestInstance()
-    for response in sri.generate(inputs, llm_kwargs, history, sys_prompt):
+    # 开始接收回复
+    from .com_zhipuglm import ZhipuChatInit
+    zhipu_bro_init = ZhipuChatInit()
+    for chunk, response in zhipu_bro_init.generate_chat(inputs, llm_kwargs, history, sys_prompt):
        if len(observe_window) >= 1:
            observe_window[0] = response
        if len(observe_window) >= 2:
-            if (time.time()-observe_window[1]) > watch_dog_patience: raise RuntimeError("程序终止。")
+            if (time.time() - observe_window[1]) > watch_dog_patience:
+                raise RuntimeError("程序终止。")
    return response

-def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_prompt='', stream = True, additional_fn=None):
+
+def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_prompt='', stream=True, additional_fn=None):
    """
        ⭐单线程方法
        函数的说明请见 request_llms/bridge_all.py
    """
-    chatbot.append((inputs, ""))
+    chatbot.append([inputs, ""])
    yield from update_ui(chatbot=chatbot, history=history)

    # 尝试导入依赖，如果缺少依赖，则给出安装建议
@@ -43,9 +55,9 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
        check_packages(["zhipuai"])
    except:
        yield from update_ui_lastest_msg(f"导入软件依赖失败。使用该模型需要额外依赖，安装方法```pip install --upgrade zhipuai```。",
-                                         chatbot=chatbot, history=history, delay=0)
+            chatbot=chatbot, history=history, delay=0)
        return
-    
+
    if validate_key() is False:
        yield from update_ui_lastest_msg(lastmsg="[Local Message] 请配置ZHIPUAI_API_KEY", chatbot=chatbot, history=history, delay=0)
        return
@@ -53,16 +65,29 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
    if additional_fn is not None:
        from core_functional import handle_core_functionality
        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
-
-    # 开始接收回复    
-    from .com_zhipuapi import ZhipuRequestInstance
-    sri = ZhipuRequestInstance()
-    for response in sri.generate(inputs, llm_kwargs, history, system_prompt):
-        chatbot[-1] = (inputs, response)
+        chatbot[-1] = [inputs, ""]
        yield from update_ui(chatbot=chatbot, history=history)

-    # 总结输出
-    if response == f"[Local Message] 等待{model_name}响应中 ...":
-        response = f"[Local Message] {model_name}响应异常 ..."
+    if llm_kwargs["llm_model"] == "zhipuai":
+        llm_kwargs["llm_model"] = zhipuai_default_model
+
+    if llm_kwargs["llm_model"] in ["glm-4v"]:
+        have_recent_file, image_paths = have_any_recent_upload_image_files(chatbot)
+        if not have_recent_file:
+            chatbot.append((inputs, "没有检测到任何近期上传的图像文件，请上传jpg格式的图片，此外，请注意拓展名需要小写"))
+            yield from update_ui(chatbot=chatbot, history=history, msg="等待图片") # 刷新界面
+            return
+        if have_recent_file:
+            inputs = make_media_input(inputs, image_paths)
+            chatbot[-1] = [inputs, ""]
+            yield from update_ui(chatbot=chatbot, history=history)
+
+
+    # 开始接收回复
+    from .com_zhipuglm import ZhipuChatInit
+    zhipu_bro_init = ZhipuChatInit()
+    for chunk, response in zhipu_bro_init.generate_chat(inputs, llm_kwargs, history, system_prompt):
+        chatbot[-1] = [inputs, response]
+        yield from update_ui(chatbot=chatbot, history=history)
    history.extend([inputs, response])
    yield from update_ui(chatbot=chatbot, history=history)
--- a/request_llms/com_google.py
+++ b/request_llms/com_google.py
@@ -7,12 +7,12 @@ import os
 import re
 import requests
 from typing import List, Dict, Tuple
-from toolbox import get_conf, encode_image, get_pictures_list
+from toolbox import get_conf, encode_image, get_pictures_list, to_markdown_tabs

 proxies, TIMEOUT_SECONDS = get_conf("proxies", "TIMEOUT_SECONDS")

 """
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 第五部分 一些文件处理方法
 files_filter_handler 根据type过滤文件
 input_encode_handler 提取input中的文件，并解析
@@ -21,6 +21,7 @@ link_mtime_to_md 文件增加本地时间参数，避免下载到缓存文件
 html_view_blank 超链接
 html_local_file 本地文件取相对路径
 to_markdown_tabs 文件list 转换为 md tab
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 """


@@ -111,34 +112,6 @@ def html_local_img(__file, layout="left", max_width=None, max_height=None, md=Tr
    return a


-def to_markdown_tabs(head: list, tabs: list, alignment=":---:", column=False):
-    """
-    Args:
-        head: 表头：[]
-        tabs: 表值：[[列1], [列2], [列3], [列4]]
-        alignment: :--- 左对齐， :---: 居中对齐， ---: 右对齐
-        column: True to keep data in columns, False to keep data in rows (default).
-    Returns:
-        A string representation of the markdown table.
-    """
-    if column:
-        transposed_tabs = list(map(list, zip(*tabs)))
-    else:
-        transposed_tabs = tabs
-    # Find the maximum length among the columns
-    max_len = max(len(column) for column in transposed_tabs)
-
-    tab_format = "| %s "
-    tabs_list = "".join([tab_format % i for i in head]) + "|\n"
-    tabs_list += "".join([tab_format % alignment for i in head]) + "|\n"
-
-    for i in range(max_len):
-        row_data = [tab[i] if i < len(tab) else "" for tab in transposed_tabs]
-        row_data = file_manifest_filter_html(row_data, filter_=None)
-        tabs_list += "".join([tab_format % i for i in row_data]) + "|\n"
-
-    return tabs_list
-

 class GoogleChatInit:
    def __init__(self):
--- a/request_llms/com_skylark2api.py
+++ b/request_llms/com_skylark2api.py
@@ -0,0 +1,95 @@
+from toolbox import get_conf
+import threading
+import logging
+import os
+
+timeout_bot_msg = '[Local Message] Request timeout. Network error.'
+#os.environ['VOLC_ACCESSKEY'] = ''
+#os.environ['VOLC_SECRETKEY'] = ''
+
+class YUNQUERequestInstance():
+    def __init__(self):
+
+        self.time_to_yield_event = threading.Event()
+        self.time_to_exit_event = threading.Event()
+
+        self.result_buf = ""
+
+    def generate(self, inputs, llm_kwargs, history, system_prompt):
+        # import _thread as thread
+        from volcengine.maas import MaasService, MaasException
+
+        maas = MaasService('maas-api.ml-platform-cn-beijing.volces.com', 'cn-beijing')
+
+        YUNQUE_SECRET_KEY, YUNQUE_ACCESS_KEY,YUNQUE_MODEL = get_conf("YUNQUE_SECRET_KEY", "YUNQUE_ACCESS_KEY","YUNQUE_MODEL")
+        maas.set_ak(YUNQUE_ACCESS_KEY) #填写 VOLC_ACCESSKEY
+        maas.set_sk(YUNQUE_SECRET_KEY) #填写 'VOLC_SECRETKEY'
+
+        self.result_buf = ""
+
+        req = {
+        "model": {
+            "name": YUNQUE_MODEL,
+            "version": "1.0", # use default version if not specified.
+        },
+        "parameters": {
+            "max_new_tokens": 4000,  # 输出文本的最大tokens限制
+            "min_new_tokens": 1,  # 输出文本的最小tokens限制
+            "temperature": llm_kwargs['temperature'],  # 用于控制生成文本的随机性和创造性，Temperature值越大随机性越大，取值范围0~1
+            "top_p": llm_kwargs['top_p'],  # 用于控制输出tokens的多样性，TopP值越大输出的tokens类型越丰富，取值范围0~1
+            "top_k": 0,  # 选择预测值最大的k个token进行采样，取值范围0-1000，0表示不生效
+            "max_prompt_tokens": 4000,  # 最大输入 token 数，如果给出的 prompt 的 token 长度超过此限制，取最后 max_prompt_tokens 个 token 输入模型。
+        },
+            "messages": self.generate_message_payload(inputs, llm_kwargs, history, system_prompt)
+        }
+
+        response = maas.stream_chat(req)
+
+        for resp in response:
+            self.result_buf += resp.choice.message.content
+            yield self.result_buf
+        '''
+        for event in response.events():
+            if event.event == "add":
+                self.result_buf += event.data
+                yield self.result_buf
+            elif event.event == "error" or event.event == "interrupted":
+                raise RuntimeError("Unknown error:" + event.data)
+            elif event.event == "finish":
+                yield self.result_buf
+                break
+            else:
+                raise RuntimeError("Unknown error:" + str(event))
+
+        logging.info(f'[raw_input] {inputs}')
+        logging.info(f'[response] {self.result_buf}')
+        '''
+        return self.result_buf
+
+    def generate_message_payload(inputs, llm_kwargs, history, system_prompt):
+        from volcengine.maas import ChatRole
+        conversation_cnt = len(history) // 2
+        messages = [{"role": ChatRole.USER, "content": system_prompt},
+                    {"role": ChatRole.ASSISTANT, "content": "Certainly!"}]
+        if conversation_cnt:
+            for index in range(0, 2 * conversation_cnt, 2):
+                what_i_have_asked = {}
+                what_i_have_asked["role"] = ChatRole.USER
+                what_i_have_asked["content"] = history[index]
+                what_gpt_answer = {}
+                what_gpt_answer["role"] = ChatRole.ASSISTANT
+                what_gpt_answer["content"] = history[index + 1]
+                if what_i_have_asked["content"] != "":
+                    if what_gpt_answer["content"] == "":
+                        continue
+                    if what_gpt_answer["content"] == timeout_bot_msg:
+                        continue
+                    messages.append(what_i_have_asked)
+                    messages.append(what_gpt_answer)
+                else:
+                    messages[-1]['content'] = what_gpt_answer['content']
+        what_i_ask_now = {}
+        what_i_ask_now["role"] = ChatRole.USER
+        what_i_ask_now["content"] = inputs
+        messages.append(what_i_ask_now)
+        return messages
--- a/request_llms/com_sparkapi.py
+++ b/request_llms/com_sparkapi.py
@@ -65,6 +65,7 @@ class SparkRequestInstance():
        self.gpt_url = "ws://spark-api.xf-yun.com/v1.1/chat"
        self.gpt_url_v2 = "ws://spark-api.xf-yun.com/v2.1/chat"
        self.gpt_url_v3 = "ws://spark-api.xf-yun.com/v3.1/chat"
+        self.gpt_url_v35 = "wss://spark-api.xf-yun.com/v3.5/chat"
        self.gpt_url_img = "wss://spark-api.cn-huabei-1.xf-yun.com/v2.1/image"

        self.time_to_yield_event = threading.Event()
@@ -91,6 +92,8 @@ class SparkRequestInstance():
            gpt_url = self.gpt_url_v2
        elif llm_kwargs['llm_model'] == 'sparkv3':
            gpt_url = self.gpt_url_v3
+        elif llm_kwargs['llm_model'] == 'sparkv3.5':
+            gpt_url = self.gpt_url_v35
        else:
            gpt_url = self.gpt_url
        file_manifest = []
@@ -190,6 +193,7 @@ def gen_params(appid, inputs, llm_kwargs, history, system_prompt, file_manifest)
        "spark": "general",
        "sparkv2": "generalv2",
        "sparkv3": "generalv3",
+        "sparkv3.5": "generalv3.5",
    }
    domains_select = domains[llm_kwargs['llm_model']]
    if file_manifest: domains_select = 'image'
--- a/request_llms/com_zhipuapi.py
+++ b/request_llms/com_zhipuapi.py
@@ -1,67 +0,0 @@
-from toolbox import get_conf
-import threading
-import logging
-
-timeout_bot_msg = '[Local Message] Request timeout. Network error.'
-
-class ZhipuRequestInstance():
-    def __init__(self):
-
-        self.time_to_yield_event = threading.Event()
-        self.time_to_exit_event = threading.Event()
-
-        self.result_buf = ""
-
-    def generate(self, inputs, llm_kwargs, history, system_prompt):
-        # import _thread as thread
-        import zhipuai
-        ZHIPUAI_API_KEY, ZHIPUAI_MODEL = get_conf("ZHIPUAI_API_KEY", "ZHIPUAI_MODEL")
-        zhipuai.api_key = ZHIPUAI_API_KEY
-        self.result_buf = ""
-        response = zhipuai.model_api.sse_invoke(
-            model=ZHIPUAI_MODEL,
-            prompt=generate_message_payload(inputs, llm_kwargs, history, system_prompt),
-            top_p=llm_kwargs['top_p'],
-            temperature=llm_kwargs['temperature'],
-        )
-        for event in response.events():
-            if event.event == "add":
-                self.result_buf += event.data
-                yield self.result_buf
-            elif event.event == "error" or event.event == "interrupted":
-                raise RuntimeError("Unknown error:" + event.data)
-            elif event.event == "finish":
-                yield self.result_buf
-                break
-            else:
-                raise RuntimeError("Unknown error:" + str(event))
-            
-        logging.info(f'[raw_input] {inputs}')
-        logging.info(f'[response] {self.result_buf}')
-        return self.result_buf
-
-def generate_message_payload(inputs, llm_kwargs, history, system_prompt):
-    conversation_cnt = len(history) // 2
-    messages = [{"role": "user", "content": system_prompt}, {"role": "assistant", "content": "Certainly!"}]
-    if conversation_cnt:
-        for index in range(0, 2*conversation_cnt, 2):
-            what_i_have_asked = {}
-            what_i_have_asked["role"] = "user"
-            what_i_have_asked["content"] = history[index]
-            what_gpt_answer = {}
-            what_gpt_answer["role"] = "assistant"
-            what_gpt_answer["content"] = history[index+1]
-            if what_i_have_asked["content"] != "":
-                if what_gpt_answer["content"] == "":
-                    continue
-                if what_gpt_answer["content"] == timeout_bot_msg:
-                    continue
-                messages.append(what_i_have_asked)
-                messages.append(what_gpt_answer)
-            else:
-                messages[-1]['content'] = what_gpt_answer['content']
-    what_i_ask_now = {}
-    what_i_ask_now["role"] = "user"
-    what_i_ask_now["content"] = inputs
-    messages.append(what_i_ask_now)
-    return messages
--- a/request_llms/com_zhipuglm.py
+++ b/request_llms/com_zhipuglm.py
@@ -0,0 +1,84 @@
+# encoding: utf-8
+# @Time   : 2024/1/22
+# @Author : Kilig947 & binary husky
+# @Descr   : 兼容最新的智谱Ai
+from toolbox import get_conf
+from zhipuai import ZhipuAI
+from toolbox import get_conf, encode_image, get_pictures_list
+import logging, os
+
+
+def input_encode_handler(inputs, llm_kwargs):        
+    if llm_kwargs["most_recent_uploaded"].get("path"):
+        image_paths = get_pictures_list(llm_kwargs["most_recent_uploaded"]["path"])
+    md_encode = []
+    for md_path in image_paths:
+        type_ = os.path.splitext(md_path)[1].replace(".", "")
+        type_ = "jpeg" if type_ == "jpg" else type_
+        md_encode.append({"data": encode_image(md_path), "type": type_})
+    return inputs, md_encode
+
+
+class ZhipuChatInit:
+
+    def __init__(self):
+        ZHIPUAI_API_KEY, ZHIPUAI_MODEL = get_conf("ZHIPUAI_API_KEY", "ZHIPUAI_MODEL")
+        if len(ZHIPUAI_MODEL) > 0:
+            logging.error('ZHIPUAI_MODEL 配置项选项已经弃用，请在LLM_MODEL中配置')
+        self.zhipu_bro = ZhipuAI(api_key=ZHIPUAI_API_KEY)
+        self.model = ''
+
+    def __conversation_user(self, user_input: str, llm_kwargs):
+        if self.model not in ["glm-4v"]:
+            return {"role": "user", "content": user_input}
+        else:
+            input_, encode_img = input_encode_handler(user_input, llm_kwargs=llm_kwargs)
+            what_i_have_asked = {"role": "user", "content": []}
+            what_i_have_asked['content'].append({"type": 'text', "text": user_input})
+            if encode_img:
+                img_d = {"type": "image_url",
+                         "image_url": {'url': encode_img}}
+                what_i_have_asked['content'].append(img_d)
+            return what_i_have_asked
+
+    def __conversation_history(self, history, llm_kwargs):
+        messages = []
+        conversation_cnt = len(history) // 2
+        if conversation_cnt:
+            for index in range(0, 2 * conversation_cnt, 2):
+                what_i_have_asked = self.__conversation_user(history[index], llm_kwargs)
+                what_gpt_answer = {
+                    "role": "assistant",
+                    "content": history[index + 1]
+                }
+                messages.append(what_i_have_asked)
+                messages.append(what_gpt_answer)
+        return messages
+
+    def __conversation_message_payload(self, inputs, llm_kwargs, history, system_prompt):
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        self.model = llm_kwargs['llm_model']
+        messages.extend(self.__conversation_history(history, llm_kwargs))  # 处理 history
+        messages.append(self.__conversation_user(inputs, llm_kwargs))  # 处理用户对话
+        response = self.zhipu_bro.chat.completions.create(
+            model=self.model, messages=messages, stream=True,
+            temperature=llm_kwargs.get('temperature', 0.95) * 0.95,  # 只能传默认的 temperature 和 top_p
+            top_p=llm_kwargs.get('top_p', 0.7) * 0.7,
+            max_tokens=llm_kwargs.get('max_tokens', 1024 * 4),  # 最大输出模型的一半
+        )
+        return response
+
+    def generate_chat(self, inputs, llm_kwargs, history, system_prompt):
+        self.model = llm_kwargs['llm_model']
+        response = self.__conversation_message_payload(inputs, llm_kwargs, history, system_prompt)
+        bro_results = ''
+        for chunk in response:
+            bro_results += chunk.choices[0].delta.content
+            yield chunk.choices[0].delta.content, bro_results
+
+
+if __name__ == '__main__':
+    zhipu = ZhipuChatInit()
+    zhipu.generate_chat('你好', {'llm_model': 'glm-4'}, [], '你是WPSAi')
--- a/request_llms/edge_gpt_free.py
+++ b/request_llms/edge_gpt_free.py
@@ -1,8 +1,8 @@
 """
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 第一部分：来自EdgeGPT.py
 https://github.com/acheong08/EdgeGPT
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 """
 """
 Main.py
@@ -196,9 +196,9 @@ class _ChatHubRequest:
        self,
        prompt: str,
        conversation_style: CONVERSATION_STYLE_TYPE,
-        options = None,
-        webpage_context = None,
-        search_result = False,
+        options=None,
+        webpage_context=None,
+        search_result=False,
    ) -> None:
        """
        Updates request object
@@ -294,9 +294,9 @@ class _Conversation:

    def __init__(
        self,
-        proxy = None,
-        async_mode = False,
-        cookies = None,
+        proxy=None,
+        async_mode=False,
+        cookies=None,
    ) -> None:
        if async_mode:
            return
@@ -350,8 +350,8 @@ class _Conversation:

    @staticmethod
    async def create(
-        proxy = None,
-        cookies = None,
+        proxy=None,
+        cookies=None,
    ):
        self = _Conversation(async_mode=True)
        self.struct = {
@@ -418,8 +418,8 @@ class _ChatHub:
    def __init__(
        self,
        conversation: _Conversation,
-        proxy = None,
-        cookies = None,
+        proxy=None,
+        cookies=None,
    ) -> None:
        self.session = None
        self.wss = None
@@ -441,7 +441,7 @@ class _ChatHub:
        conversation_style: CONVERSATION_STYLE_TYPE = None,
        raw: bool = False,
        options: dict = None,
-        webpage_context = None,
+        webpage_context=None,
        search_result: bool = False,
    ) -> Generator[str, None, None]:
        """
@@ -452,10 +452,12 @@ class _ChatHub:
            ws_cookies = []
            for cookie in self.cookies:
                ws_cookies.append(f"{cookie['name']}={cookie['value']}")
-            req_header.update({
-                'Cookie': ';'.join(ws_cookies),
-            })
-            
+            req_header.update(
+                {
+                    "Cookie": ";".join(ws_cookies),
+                }
+            )
+
        timeout = aiohttp.ClientTimeout(total=30)
        self.session = aiohttp.ClientSession(timeout=timeout)

@@ -521,9 +523,9 @@ class _ChatHub:
            msg = await self.wss.receive()
            try:
                objects = msg.data.split(DELIMITER)
-            except :
+            except:
                continue
-            
+
            for obj in objects:
                if obj is None or not obj:
                    continue
@@ -624,8 +626,8 @@ class Chatbot:

    def __init__(
        self,
-        proxy = None,
-        cookies = None,
+        proxy=None,
+        cookies=None,
    ) -> None:
        self.proxy = proxy
        self.chat_hub: _ChatHub = _ChatHub(
@@ -636,8 +638,8 @@ class Chatbot:

    @staticmethod
    async def create(
-        proxy = None,
-        cookies = None,
+        proxy=None,
+        cookies=None,
    ):
        self = Chatbot.__new__(Chatbot)
        self.proxy = proxy
@@ -654,7 +656,7 @@ class Chatbot:
        wss_link: str = "wss://sydney.bing.com/sydney/ChatHub",
        conversation_style: CONVERSATION_STYLE_TYPE = None,
        options: dict = None,
-        webpage_context = None,
+        webpage_context=None,
        search_result: bool = False,
    ) -> dict:
        """
@@ -680,7 +682,7 @@ class Chatbot:
        conversation_style: CONVERSATION_STYLE_TYPE = None,
        raw: bool = False,
        options: dict = None,
-        webpage_context = None,
+        webpage_context=None,
        search_result: bool = False,
    ) -> Generator[str, None, None]:
        """
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,12 +1,15 @@
-./docs/gradio-3.32.6-py3-none-any.whl
+https://public.agent-matrix.com/publish/gradio-3.32.8-py3-none-any.whl
+gradio-client==0.8
 pypdf2==2.12.1
+zhipuai>=2
 tiktoken>=0.3.3
 requests[socks]
-pydantic==1.10.11
+pydantic==2.5.2
 protobuf==3.18
 transformers>=4.27.1
 scipdf_parser>=0.52
 python-markdown-math
+pymdown-extensions
 websocket-client
 beautifulsoup4
 prompt_toolkit
--- a/shared_utils/advanced_markdown_format.py
+++ b/shared_utils/advanced_markdown_format.py
@@ -0,0 +1,361 @@
+import markdown
+import re
+import os
+import math
+from textwrap import dedent
+from functools import lru_cache
+from pymdownx.superfences import fence_code_format
+from latex2mathml.converter import convert as tex2mathml
+from shared_utils.config_loader import get_conf as get_conf
+from shared_utils.text_mask import apply_gpt_academic_string_mask
+
+markdown_extension_configs = {
+    "mdx_math": {
+        "enable_dollar_delimiter": True,
+        "use_gitlab_delimiters": False,
+    },
+}
+
+code_highlight_configs = {
+    "pymdownx.superfences": {
+        "css_class": "codehilite",
+        "custom_fences": [
+            {"name": "mermaid", "class": "mermaid", "format": fence_code_format}
+        ],
+    },
+    "pymdownx.highlight": {
+        "css_class": "codehilite",
+        "guess_lang": True,
+        # 'auto_title': True,
+        # 'linenums': True
+    },
+}
+
+code_highlight_configs_block_mermaid = {
+    "pymdownx.superfences": {
+        "css_class": "codehilite",
+        # "custom_fences": [
+        #     {"name": "mermaid", "class": "mermaid", "format": fence_code_format}
+        # ],
+    },
+    "pymdownx.highlight": {
+        "css_class": "codehilite",
+        "guess_lang": True,
+        # 'auto_title': True,
+        # 'linenums': True
+    },
+}
+
+def tex2mathml_catch_exception(content, *args, **kwargs):
+    try:
+        content = tex2mathml(content, *args, **kwargs)
+    except:
+        content = content
+    return content
+
+
+def replace_math_no_render(match):
+    content = match.group(1)
+    if "mode=display" in match.group(0):
+        content = content.replace("\n", "</br>")
+        return f'<font color="#00FF00">$$</font><font color="#FF00FF">{content}</font><font color="#00FF00">$$</font>'
+    else:
+        return f'<font color="#00FF00">$</font><font color="#FF00FF">{content}</font><font color="#00FF00">$</font>'
+
+
+def replace_math_render(match):
+    content = match.group(1)
+    if "mode=display" in match.group(0):
+        if "\\begin{aligned}" in content:
+            content = content.replace("\\begin{aligned}", "\\begin{array}")
+            content = content.replace("\\end{aligned}", "\\end{array}")
+            content = content.replace("&", " ")
+        content = tex2mathml_catch_exception(content, display="block")
+        return content
+    else:
+        return tex2mathml_catch_exception(content)
+
+
+def markdown_bug_hunt(content):
+    """
+    解决一个mdx_math的bug（单$包裹begin命令时多余<script>）
+    """
+    content = content.replace(
+        '<script type="math/tex">\n<script type="math/tex; mode=display">',
+        '<script type="math/tex; mode=display">',
+    )
+    content = content.replace("</script>\n</script>", "</script>")
+    return content
+
+
+def is_equation(txt):
+    """
+    判定是否为公式 | 测试1 写出洛伦兹定律，使用tex格式公式 测试2 给出柯西不等式，使用latex格式 测试3 写出麦克斯韦方程组
+    """
+    if "```" in txt and "```reference" not in txt:
+        return False
+    if "$" not in txt and "\\[" not in txt:
+        return False
+    mathpatterns = {
+        r"(?<!\\|\$)(\$)([^\$]+)(\$)": {"allow_multi_lines": False},  #  $...$
+        r"(?<!\\)(\$\$)([^\$]+)(\$\$)": {"allow_multi_lines": True},  # $$...$$
+        r"(?<!\\)(\\\[)(.+?)(\\\])": {"allow_multi_lines": False},  # \[...\]
+        # r'(?<!\\)(\\\()(.+?)(\\\))': {'allow_multi_lines': False},                       # \(...\)
+        # r'(?<!\\)(\\begin{([a-z]+?\*?)})(.+?)(\\end{\2})': {'allow_multi_lines': True},  # \begin...\end
+        # r'(?<!\\)(\$`)([^`]+)(`\$)': {'allow_multi_lines': False},                       # $`...`$
+    }
+    matches = []
+    for pattern, property in mathpatterns.items():
+        flags = re.ASCII | re.DOTALL if property["allow_multi_lines"] else re.ASCII
+        matches.extend(re.findall(pattern, txt, flags))
+    if len(matches) == 0:
+        return False
+    contain_any_eq = False
+    illegal_pattern = re.compile(r"[^\x00-\x7F]|echo")
+    for match in matches:
+        if len(match) != 3:
+            return False
+        eq_canidate = match[1]
+        if illegal_pattern.search(eq_canidate):
+            return False
+        else:
+            contain_any_eq = True
+    return contain_any_eq
+
+
+def fix_markdown_indent(txt):
+    # fix markdown indent
+    if (" - " not in txt) or (". " not in txt):
+        # do not need to fix, fast escape
+        return txt
+    # walk through the lines and fix non-standard indentation
+    lines = txt.split("\n")
+    pattern = re.compile(r"^\s+-")
+    activated = False
+    for i, line in enumerate(lines):
+        if line.startswith("- ") or line.startswith("1. "):
+            activated = True
+        if activated and pattern.match(line):
+            stripped_string = line.lstrip()
+            num_spaces = len(line) - len(stripped_string)
+            if (num_spaces % 4) == 3:
+                num_spaces_should_be = math.ceil(num_spaces / 4) * 4
+                lines[i] = " " * num_spaces_should_be + stripped_string
+    return "\n".join(lines)
+
+
+FENCED_BLOCK_RE = re.compile(
+    dedent(
+        r"""
+        (?P<fence>^[ \t]*(?:~{3,}|`{3,}))[ ]*                      # opening fence
+        ((\{(?P<attrs>[^\}\n]*)\})|                              # (optional {attrs} or
+        (\.?(?P<lang>[\w#.+-]*)[ ]*)?                            # optional (.)lang
+        (hl_lines=(?P<quot>"|')(?P<hl_lines>.*?)(?P=quot)[ ]*)?) # optional hl_lines)
+        \n                                                       # newline (end of opening fence)
+        (?P<code>.*?)(?<=\n)                                     # the code block
+        (?P=fence)[ ]*$                                          # closing fence
+    """
+    ),
+    re.MULTILINE | re.DOTALL | re.VERBOSE,
+)
+
+
+def get_line_range(re_match_obj, txt):
+    start_pos, end_pos = re_match_obj.regs[0]
+    num_newlines_before = txt[: start_pos + 1].count("\n")
+    line_start = num_newlines_before
+    line_end = num_newlines_before + txt[start_pos:end_pos].count("\n") + 1
+    return line_start, line_end
+
+
+def fix_code_segment_indent(txt):
+    lines = []
+    change_any = False
+    txt_tmp = txt
+    while True:
+        re_match_obj = FENCED_BLOCK_RE.search(txt_tmp)
+        if not re_match_obj:
+            break
+        if len(lines) == 0:
+            lines = txt.split("\n")
+
+        # 清空 txt_tmp 对应的位置方便下次搜索
+        start_pos, end_pos = re_match_obj.regs[0]
+        txt_tmp = txt_tmp[:start_pos] + " " * (end_pos - start_pos) + txt_tmp[end_pos:]
+        line_start, line_end = get_line_range(re_match_obj, txt)
+
+        # 获取公共缩进
+        shared_indent_cnt = 1e5
+        for i in range(line_start, line_end):
+            stripped_string = lines[i].lstrip()
+            num_spaces = len(lines[i]) - len(stripped_string)
+            if num_spaces < shared_indent_cnt:
+                shared_indent_cnt = num_spaces
+
+        # 修复缩进
+        if (shared_indent_cnt < 1e5) and (shared_indent_cnt % 4) == 3:
+            num_spaces_should_be = math.ceil(shared_indent_cnt / 4) * 4
+            for i in range(line_start, line_end):
+                add_n = num_spaces_should_be - shared_indent_cnt
+                lines[i] = " " * add_n + lines[i]
+            if not change_any:  # 遇到第一个
+                change_any = True
+
+    if change_any:
+        return "\n".join(lines)
+    else:
+        return txt
+
+
+@lru_cache(maxsize=128)  # 使用 lru缓存 加快转换速度
+def markdown_convertion(txt):
+    """
+    将Markdown格式的文本转换为HTML格式。如果包含数学公式，则先将公式转换为HTML格式。
+    """
+    pre = '<div class="markdown-body">'
+    suf = "</div>"
+    if txt.startswith(pre) and txt.endswith(suf):
+        # print('警告，输入了已经经过转化的字符串，二次转化可能出问题')
+        return txt  # 已经被转化过，不需要再次转化
+
+    find_equation_pattern = r'<script type="math/tex(?:.*?)>(.*?)</script>'
+
+    txt = fix_markdown_indent(txt)
+    # txt = fix_code_segment_indent(txt)
+    if is_equation(txt):  # 有$标识的公式符号，且没有代码段```的标识
+        # convert everything to html format
+        split = markdown.markdown(text="---")
+        convert_stage_1 = markdown.markdown(
+            text=txt,
+            extensions=[
+                "sane_lists",
+                "tables",
+                "mdx_math",
+                "pymdownx.superfences",
+                "pymdownx.highlight",
+            ],
+            extension_configs={**markdown_extension_configs, **code_highlight_configs},
+        )
+        convert_stage_1 = markdown_bug_hunt(convert_stage_1)
+        # 1. convert to easy-to-copy tex (do not render math)
+        convert_stage_2_1, n = re.subn(
+            find_equation_pattern,
+            replace_math_no_render,
+            convert_stage_1,
+            flags=re.DOTALL,
+        )
+        # 2. convert to rendered equation
+        convert_stage_2_2, n = re.subn(
+            find_equation_pattern, replace_math_render, convert_stage_1, flags=re.DOTALL
+        )
+        # cat them together
+        return pre + convert_stage_2_1 + f"{split}" + convert_stage_2_2 + suf
+    else:
+        return (
+            pre
+            + markdown.markdown(
+                txt,
+                extensions=[
+                    "sane_lists",
+                    "tables",
+                    "pymdownx.superfences",
+                    "pymdownx.highlight",
+                ],
+                extension_configs=code_highlight_configs,
+            )
+            + suf
+        )
+
+
+def close_up_code_segment_during_stream(gpt_reply):
+    """
+    在gpt输出代码的中途（输出了前面的```，但还没输出完后面的```），补上后面的```
+
+    Args:
+        gpt_reply (str): GPT模型返回的回复字符串。
+
+    Returns:
+        str: 返回一个新的字符串，将输出代码片段的“后面的```”补上。
+
+    """
+    if "```" not in gpt_reply:
+        return gpt_reply
+    if gpt_reply.endswith("```"):
+        return gpt_reply
+
+    # 排除了以上两个情况，我们
+    segments = gpt_reply.split("```")
+    n_mark = len(segments) - 1
+    if n_mark % 2 == 1:
+        return gpt_reply + "\n```"  # 输出代码片段中！
+    else:
+        return gpt_reply
+
+
+def special_render_issues_for_mermaid(text):
+    # 用不太优雅的方式处理一个core_functional.py中出现的mermaid渲染特例：
+    # 我不希望"总结绘制脑图"prompt中的mermaid渲染出来
+    @lru_cache(maxsize=1)
+    def get_special_case():
+        from core_functional import get_core_functions
+        special_case = get_core_functions()["总结绘制脑图"]["Suffix"]
+        return special_case
+    if text.endswith(get_special_case()): text = text.replace("```mermaid", "```")
+    return text
+
+
+def compat_non_markdown_input(text):
+    """
+    改善非markdown输入的显示效果，例如将空格转换为&nbsp;，将换行符转换为</br>等。
+    """
+    if "```" in text:
+        # careful input：markdown输入
+        text = special_render_issues_for_mermaid(text)  # 处理特殊的渲染问题
+        return text
+    elif "</div>" in text:
+        # careful input：html输入
+        return text
+    else:
+        # whatever input：非markdown输入
+        lines = text.split("\n")
+        for i, line in enumerate(lines):
+            lines[i] = lines[i].replace(" ", "&nbsp;")  # 空格转换为&nbsp;
+        text = "</br>".join(lines)  # 换行符转换为</br>
+        return text
+
+
+@lru_cache(maxsize=128)  # 使用lru缓存
+def simple_markdown_convertion(text):
+    pre = '<div class="markdown-body">'
+    suf = "</div>"
+    if text.startswith(pre) and text.endswith(suf):
+        return text  # 已经被转化过，不需要再次转化
+    text = compat_non_markdown_input(text)    # 兼容非markdown输入
+    text = markdown.markdown(
+        text,
+        extensions=["pymdownx.superfences", "tables", "pymdownx.highlight"],
+        extension_configs=code_highlight_configs,
+    )
+    return pre + text + suf
+
+
+def format_io(self, y):
+    """
+    将输入和输出解析为HTML格式。将y中最后一项的输入部分段落化，并将输出部分的Markdown和数学公式转换为HTML格式。
+    """
+    if y is None or y == []:
+        return []
+    i_ask, gpt_reply = y[-1]
+    i_ask = apply_gpt_academic_string_mask(i_ask, mode="show_render")
+    gpt_reply = apply_gpt_academic_string_mask(gpt_reply, mode="show_render")
+    # 当代码输出半截的时候，试着补上后个```
+    if gpt_reply is not None:
+        gpt_reply = close_up_code_segment_during_stream(gpt_reply)
+    # 处理提问与输出
+    y[-1] = (
+        # 输入部分
+        None if i_ask is None else simple_markdown_convertion(i_ask),
+        # 输出部分
+        None if gpt_reply is None else markdown_convertion(gpt_reply),
+    )
+    return y
--- a/shared_utils/config_loader.py
+++ b/shared_utils/config_loader.py
@@ -0,0 +1,131 @@
+import importlib
+import time
+import os
+from functools import lru_cache
+from colorful import print亮红, print亮绿, print亮蓝
+
+pj = os.path.join
+default_user_name = 'default_user'
+
+def read_env_variable(arg, default_value):
+    """
+    环境变量可以是 `GPT_ACADEMIC_CONFIG`(优先)，也可以直接是`CONFIG`
+    例如在windows cmd中，既可以写：
+        set USE_PROXY=True
+        set API_KEY=sk-j7caBpkRoxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+        set proxies={"http":"http://127.0.0.1:10085", "https":"http://127.0.0.1:10085",}
+        set AVAIL_LLM_MODELS=["gpt-3.5-turbo", "chatglm"]
+        set AUTHENTICATION=[("username", "password"), ("username2", "password2")]
+    也可以写：
+        set GPT_ACADEMIC_USE_PROXY=True
+        set GPT_ACADEMIC_API_KEY=sk-j7caBpkRoxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+        set GPT_ACADEMIC_proxies={"http":"http://127.0.0.1:10085", "https":"http://127.0.0.1:10085",}
+        set GPT_ACADEMIC_AVAIL_LLM_MODELS=["gpt-3.5-turbo", "chatglm"]
+        set GPT_ACADEMIC_AUTHENTICATION=[("username", "password"), ("username2", "password2")]
+    """
+    arg_with_prefix = "GPT_ACADEMIC_" + arg
+    if arg_with_prefix in os.environ:
+        env_arg = os.environ[arg_with_prefix]
+    elif arg in os.environ:
+        env_arg = os.environ[arg]
+    else:
+        raise KeyError
+    print(f"[ENV_VAR] 尝试加载{arg}，默认值：{default_value} --> 修正值：{env_arg}")
+    try:
+        if isinstance(default_value, bool):
+            env_arg = env_arg.strip()
+            if env_arg == 'True': r = True
+            elif env_arg == 'False': r = False
+            else: print('Enter True or False, but have:', env_arg); r = default_value
+        elif isinstance(default_value, int):
+            r = int(env_arg)
+        elif isinstance(default_value, float):
+            r = float(env_arg)
+        elif isinstance(default_value, str):
+            r = env_arg.strip()
+        elif isinstance(default_value, dict):
+            r = eval(env_arg)
+        elif isinstance(default_value, list):
+            r = eval(env_arg)
+        elif default_value is None:
+            assert arg == "proxies"
+            r = eval(env_arg)
+        else:
+            print亮红(f"[ENV_VAR] 环境变量{arg}不支持通过环境变量设置! ")
+            raise KeyError
+    except:
+        print亮红(f"[ENV_VAR] 环境变量{arg}加载失败! ")
+        raise KeyError(f"[ENV_VAR] 环境变量{arg}加载失败! ")
+
+    print亮绿(f"[ENV_VAR] 成功读取环境变量{arg}")
+    return r
+
+
+@lru_cache(maxsize=128)
+def read_single_conf_with_lru_cache(arg):
+    from shared_utils.key_pattern_manager import is_any_api_key
+    try:
+        # 优先级1. 获取环境变量作为配置
+        default_ref = getattr(importlib.import_module('config'), arg) # 读取默认值作为数据类型转换的参考
+        r = read_env_variable(arg, default_ref)
+    except:
+        try:
+            # 优先级2. 获取config_private中的配置
+            r = getattr(importlib.import_module('config_private'), arg)
+        except:
+            # 优先级3. 获取config中的配置
+            r = getattr(importlib.import_module('config'), arg)
+
+    # 在读取API_KEY时，检查一下是不是忘了改config
+    if arg == 'API_URL_REDIRECT':
+        oai_rd = r.get("https://api.openai.com/v1/chat/completions", None) # API_URL_REDIRECT填写格式是错误的，请阅读`https://github.com/binary-husky/gpt_academic/wiki/项目配置说明`
+        if oai_rd and not oai_rd.endswith('/completions'):
+            print亮红("\n\n[API_URL_REDIRECT] API_URL_REDIRECT填错了。请阅读`https://github.com/binary-husky/gpt_academic/wiki/项目配置说明`。如果您确信自己没填错，无视此消息即可。")
+            time.sleep(5)
+    if arg == 'API_KEY':
+        print亮蓝(f"[API_KEY] 本项目现已支持OpenAI和Azure的api-key。也支持同时填写多个api-key，如API_KEY=\"openai-key1,openai-key2,azure-key3\"")
+        print亮蓝(f"[API_KEY] 您既可以在config.py中修改api-key(s)，也可以在问题输入区输入临时的api-key(s)，然后回车键提交后即可生效。")
+        if is_any_api_key(r):
+            print亮绿(f"[API_KEY] 您的 API_KEY 是: {r[:15]}*** API_KEY 导入成功")
+        else:
+            print亮红("[API_KEY] 您的 API_KEY 不满足任何一种已知的密钥格式，请在config文件中修改API密钥之后再运行。")
+    if arg == 'proxies':
+        if not read_single_conf_with_lru_cache('USE_PROXY'): r = None # 检查USE_PROXY，防止proxies单独起作用
+        if r is None:
+            print亮红('[PROXY] 网络代理状态：未配置。无代理状态下很可能无法访问OpenAI家族的模型。建议：检查USE_PROXY选项是否修改。')
+        else:
+            print亮绿('[PROXY] 网络代理状态：已配置。配置信息如下：', r)
+            assert isinstance(r, dict), 'proxies格式错误，请注意proxies选项的格式，不要遗漏括号。'
+    return r
+
+
+@lru_cache(maxsize=128)
+def get_conf(*args):
+    """
+    本项目的所有配置都集中在config.py中。 修改配置有三种方法，您只需要选择其中一种即可：
+        - 直接修改config.py
+        - 创建并修改config_private.py
+        - 修改环境变量（修改docker-compose.yml等价于修改容器内部的环境变量）
+
+    注意：如果您使用docker-compose部署，请修改docker-compose（等价于修改容器内部的环境变量）
+    """
+    res = []
+    for arg in args:
+        r = read_single_conf_with_lru_cache(arg)
+        res.append(r)
+    if len(res) == 1: return res[0]
+    return res
+
+
+def set_conf(key, value):
+    from toolbox import read_single_conf_with_lru_cache
+    read_single_conf_with_lru_cache.cache_clear()
+    get_conf.cache_clear()
+    os.environ[key] = str(value)
+    altered = get_conf(key)
+    return altered
+
+
+def set_multi_conf(dic):
+    for k, v in dic.items(): set_conf(k, v)
+    return
--- a/shared_utils/connect_void_terminal.py
+++ b/shared_utils/connect_void_terminal.py
@@ -0,0 +1,91 @@
+import os
+
+"""
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+接驳void-terminal:
+    - set_conf:                     在运行过程中动态地修改配置
+    - set_multi_conf:               在运行过程中动态地修改多个配置
+    - get_plugin_handle:            获取插件的句柄
+    - get_plugin_default_kwargs:    获取插件的默认参数
+    - get_chat_handle:              获取简单聊天的句柄
+    - get_chat_default_kwargs:      获取简单聊天的默认参数
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+"""
+
+
+def get_plugin_handle(plugin_name):
+    """
+    e.g. plugin_name = 'crazy_functions.批量Markdown翻译->Markdown翻译指定语言'
+    """
+    import importlib
+
+    assert (
+        "->" in plugin_name
+    ), "Example of plugin_name: crazy_functions.批量Markdown翻译->Markdown翻译指定语言"
+    module, fn_name = plugin_name.split("->")
+    f_hot_reload = getattr(importlib.import_module(module, fn_name), fn_name)
+    return f_hot_reload
+
+
+def get_chat_handle():
+    """
+    Get chat function
+    """
+    from request_llms.bridge_all import predict_no_ui_long_connection
+
+    return predict_no_ui_long_connection
+
+
+def get_plugin_default_kwargs():
+    """
+    Get Plugin Default Arguments
+    """
+    from toolbox import ChatBotWithCookies, load_chat_cookies
+
+    cookies = load_chat_cookies()
+    llm_kwargs = {
+        "api_key": cookies["api_key"],
+        "llm_model": cookies["llm_model"],
+        "top_p": 1.0,
+        "max_length": None,
+        "temperature": 1.0,
+    }
+    chatbot = ChatBotWithCookies(llm_kwargs)
+
+    # txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request
+    DEFAULT_FN_GROUPS_kwargs = {
+        "main_input": "./README.md",
+        "llm_kwargs": llm_kwargs,
+        "plugin_kwargs": {},
+        "chatbot_with_cookie": chatbot,
+        "history": [],
+        "system_prompt": "You are a good AI.",
+        "user_request": None,
+    }
+    return DEFAULT_FN_GROUPS_kwargs
+
+
+def get_chat_default_kwargs():
+    """
+    Get Chat Default Arguments
+    """
+    from toolbox import load_chat_cookies
+
+    cookies = load_chat_cookies()
+    llm_kwargs = {
+        "api_key": cookies["api_key"],
+        "llm_model": cookies["llm_model"],
+        "top_p": 1.0,
+        "max_length": None,
+        "temperature": 1.0,
+    }
+    default_chat_kwargs = {
+        "inputs": "Hello there, are you ready?",
+        "llm_kwargs": llm_kwargs,
+        "history": [],
+        "sys_prompt": "You are AI assistant",
+        "observe_window": None,
+        "console_slience": False,
+    }
+
+    return default_chat_kwargs
--- a/shared_utils/handle_upload.py
+++ b/shared_utils/handle_upload.py
@@ -0,0 +1,137 @@
+import importlib
+import time
+import inspect
+import re
+import os
+import base64
+import gradio
+import shutil
+import glob
+from shared_utils.config_loader import get_conf
+
+def html_local_file(file):
+    base_path = os.path.dirname(__file__)  # 项目目录
+    if os.path.exists(str(file)):
+        file = f'file={file.replace(base_path, ".")}'
+    return file
+
+
+def html_local_img(__file, layout="left", max_width=None, max_height=None, md=True):
+    style = ""
+    if max_width is not None:
+        style += f"max-width: {max_width};"
+    if max_height is not None:
+        style += f"max-height: {max_height};"
+    __file = html_local_file(__file)
+    a = f'<div align="{layout}"><img src="{__file}" style="{style}"></div>'
+    if md:
+        a = f"![{__file}]({__file})"
+    return a
+
+
+def file_manifest_filter_type(file_list, filter_: list = None):
+    new_list = []
+    if not filter_:
+        filter_ = ["png", "jpg", "jpeg"]
+    for file in file_list:
+        if str(os.path.basename(file)).split(".")[-1] in filter_:
+            new_list.append(html_local_img(file, md=False))
+        else:
+            new_list.append(file)
+    return new_list
+
+
+def zip_extract_member_new(self, member, targetpath, pwd):
+    # 修复中文乱码的问题
+    """Extract the ZipInfo object 'member' to a physical
+        file on the path targetpath.
+    """
+    import zipfile
+    if not isinstance(member, zipfile.ZipInfo):
+        member = self.getinfo(member)
+
+    # build the destination pathname, replacing
+    # forward slashes to platform specific separators.
+    arcname = member.filename.replace('/', os.path.sep)
+    arcname = arcname.encode('cp437', errors='replace').decode('gbk', errors='replace')
+
+    if os.path.altsep:
+        arcname = arcname.replace(os.path.altsep, os.path.sep)
+    # interpret absolute pathname as relative, remove drive letter or
+    # UNC path, redundant separators, "." and ".." components.
+    arcname = os.path.splitdrive(arcname)[1]
+    invalid_path_parts = ('', os.path.curdir, os.path.pardir)
+    arcname = os.path.sep.join(x for x in arcname.split(os.path.sep)
+                                if x not in invalid_path_parts)
+    if os.path.sep == '\\':
+        # filter illegal characters on Windows
+        arcname = self._sanitize_windows_name(arcname, os.path.sep)
+
+    targetpath = os.path.join(targetpath, arcname)
+    targetpath = os.path.normpath(targetpath)
+
+    # Create all upper directories if necessary.
+    upperdirs = os.path.dirname(targetpath)
+    if upperdirs and not os.path.exists(upperdirs):
+        os.makedirs(upperdirs)
+
+    if member.is_dir():
+        if not os.path.isdir(targetpath):
+            os.mkdir(targetpath)
+        return targetpath
+
+    with self.open(member, pwd=pwd) as source, \
+            open(targetpath, "wb") as target:
+        shutil.copyfileobj(source, target)
+
+    return targetpath
+
+
+def extract_archive(file_path, dest_dir):
+    import zipfile
+    import tarfile
+    import os
+
+    # Get the file extension of the input file
+    file_extension = os.path.splitext(file_path)[1]
+
+    # Extract the archive based on its extension
+    if file_extension == ".zip":
+        with zipfile.ZipFile(file_path, "r") as zipobj:
+            zipobj._extract_member = lambda a,b,c: zip_extract_member_new(zipobj, a,b,c)    # 修复中文乱码的问题
+            zipobj.extractall(path=dest_dir)
+            print("Successfully extracted zip archive to {}".format(dest_dir))
+
+    elif file_extension in [".tar", ".gz", ".bz2"]:
+        with tarfile.open(file_path, "r:*") as tarobj:
+            tarobj.extractall(path=dest_dir)
+            print("Successfully extracted tar archive to {}".format(dest_dir))
+
+    # 第三方库，需要预先pip install rarfile
+    # 此外，Windows上还需要安装winrar软件，配置其Path环境变量，如"C:\Program Files\WinRAR"才可以
+    elif file_extension == ".rar":
+        try:
+            import rarfile
+
+            with rarfile.RarFile(file_path) as rf:
+                rf.extractall(path=dest_dir)
+                print("Successfully extracted rar archive to {}".format(dest_dir))
+        except:
+            print("Rar format requires additional dependencies to install")
+            return "\n\n解压失败! 需要安装pip install rarfile来解压rar文件。建议：使用zip压缩格式。"
+
+    # 第三方库，需要预先pip install py7zr
+    elif file_extension == ".7z":
+        try:
+            import py7zr
+
+            with py7zr.SevenZipFile(file_path, mode="r") as f:
+                f.extractall(path=dest_dir)
+                print("Successfully extracted 7z archive to {}".format(dest_dir))
+        except:
+            print("7z format requires additional dependencies to install")
+            return "\n\n解压失败! 需要安装pip install py7zr来解压7z文件"
+    else:
+        return ""
+    return ""
+
--- a/shared_utils/key_pattern_manager.py
+++ b/shared_utils/key_pattern_manager.py
@@ -0,0 +1,81 @@
+import re
+import os
+from functools import wraps, lru_cache
+from shared_utils.advanced_markdown_format import format_io
+from shared_utils.config_loader import get_conf as get_conf
+
+
+pj = os.path.join
+default_user_name = 'default_user'
+
+
+def is_openai_api_key(key):
+    CUSTOM_API_KEY_PATTERN = get_conf('CUSTOM_API_KEY_PATTERN')
+    if len(CUSTOM_API_KEY_PATTERN) != 0:
+        API_MATCH_ORIGINAL = re.match(CUSTOM_API_KEY_PATTERN, key)
+    else:
+        API_MATCH_ORIGINAL = re.match(r"sk-[a-zA-Z0-9]{48}$|sess-[a-zA-Z0-9]{40}$", key)
+    return bool(API_MATCH_ORIGINAL)
+
+
+def is_azure_api_key(key):
+    API_MATCH_AZURE = re.match(r"[a-zA-Z0-9]{32}$", key)
+    return bool(API_MATCH_AZURE)
+
+
+def is_api2d_key(key):
+    API_MATCH_API2D = re.match(r"fk[a-zA-Z0-9]{6}-[a-zA-Z0-9]{32}$", key)
+    return bool(API_MATCH_API2D)
+
+
+def is_any_api_key(key):
+    if ',' in key:
+        keys = key.split(',')
+        for k in keys:
+            if is_any_api_key(k): return True
+        return False
+    else:
+        return is_openai_api_key(key) or is_api2d_key(key) or is_azure_api_key(key)
+
+
+def what_keys(keys):
+    avail_key_list = {'OpenAI Key': 0, "Azure Key": 0, "API2D Key": 0}
+    key_list = keys.split(',')
+
+    for k in key_list:
+        if is_openai_api_key(k):
+            avail_key_list['OpenAI Key'] += 1
+
+    for k in key_list:
+        if is_api2d_key(k):
+            avail_key_list['API2D Key'] += 1
+
+    for k in key_list:
+        if is_azure_api_key(k):
+            avail_key_list['Azure Key'] += 1
+
+    return f"检测到： OpenAI Key {avail_key_list['OpenAI Key']} 个, Azure Key {avail_key_list['Azure Key']} 个, API2D Key {avail_key_list['API2D Key']} 个"
+
+
+def select_api_key(keys, llm_model):
+    import random
+    avail_key_list = []
+    key_list = keys.split(',')
+
+    if llm_model.startswith('gpt-'):
+        for k in key_list:
+            if is_openai_api_key(k): avail_key_list.append(k)
+
+    if llm_model.startswith('api2d-'):
+        for k in key_list:
+            if is_api2d_key(k): avail_key_list.append(k)
+
+    if llm_model.startswith('azure-'):
+        for k in key_list:
+            if is_azure_api_key(k): avail_key_list.append(k)
+
+    if len(avail_key_list) == 0:
+        raise RuntimeError(f"您提供的api-key不满足要求，不包含任何可用于{llm_model}的api-key。您可能选择了错误的模型或请求源（右下角更换模型菜单中可切换openai,azure,claude,api2d等请求源）。")
+
+    api_key = random.choice(avail_key_list) # 随机负载均衡
+    return api_key
--- a/shared_utils/text_mask.py
+++ b/shared_utils/text_mask.py
@@ -0,0 +1,107 @@
+import re
+from functools import lru_cache
+
+# 这段代码是使用Python编程语言中的re模块，即正则表达式库，来定义了一个正则表达式模式。
+# 这个模式被编译成一个正则表达式对象，存储在名为const_extract_exp的变量中，以便于后续快速的匹配和查找操作。
+# 这里解释一下正则表达式中的几个特殊字符：
+# - . 表示任意单一字符。
+# - * 表示前一个字符可以出现0次或多次。
+# - ? 在这里用作非贪婪匹配，也就是说它会匹配尽可能少的字符。在(.*?)中，它确保我们匹配的任意文本是尽可能短的，也就是说，它会在</show_llm>和</show_render>标签之前停止匹配。
+# - () 括号在正则表达式中表示捕获组。
+# - 在这个例子中，(.*?)表示捕获任意长度的文本，直到遇到括号外部最近的限定符，即</show_llm>和</show_render>。
+
+# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-==-=-=-=/1=-=-=-=-=-=-=-=-=-=-=-=-=-=/2-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+const_extract_re = re.compile(
+    r"<gpt_academic_string_mask><show_llm>(.*?)</show_llm><show_render>(.*?)</show_render></gpt_academic_string_mask>"
+)
+# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-==-=-=-=-=-=/1=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-/2-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+const_extract_langbased_re = re.compile(
+    r"<gpt_academic_string_mask><lang_english>(.*?)</lang_english><lang_chinese>(.*?)</lang_chinese></gpt_academic_string_mask>",
+    flags=re.DOTALL,
+)
+
+@lru_cache(maxsize=128)
+def apply_gpt_academic_string_mask(string, mode="show_all"):
+    """
+    当字符串中有掩码tag时（<gpt_academic_string_mask><show_...>），根据字符串要给谁看（大模型，还是web渲染），对字符串进行处理，返回处理后的字符串
+    示意图：https://mermaid.live/edit#pako:eNqlkUtLw0AUhf9KuOta0iaTplkIPlpduFJwoZEwJGNbzItpita2O6tF8QGKogXFtwu7cSHiq3-mk_oznFR8IYLgrGbuOd9hDrcCpmcR0GDW9ubNPKaBMDauuwI_A9M6YN-3y0bODwxsYos4BdMoBrTg5gwHF-d0mBH6-vqFQe58ed5m9XPW2uteX3Tubrj0ljLYcwxxR3h1zB43WeMs3G19yEM9uapDMe_NG9i2dagKw1Fee4c1D9nGEbtc-5n6HbNtJ8IyHOs8tbs7V2HrlDX2w2Y7XD_5haHEtQiNsOwfMVa_7TzsvrWIuJGo02qTrdwLk9gukQylHv3Afv1ML270s-HZUndrmW1tdA-WfvbM_jMFYuAQ6uCCxVdciTJ1CPLEITpo_GphypeouzXuw6XAmyi7JmgBLZEYlHwLB2S4gHMUO-9DH7tTnvf1CVoFFkBLSOk4QmlRTqpIlaWUHINyNFXjaQWpCYRURUKiWovBYo8X4ymEJFlECQUpqaQkJmuvWygPpg
+    """
+    if "<gpt_academic_string_mask>" not in string: # No need to process
+        return string
+
+    if mode == "show_all":
+        return string
+    if mode == "show_llm":
+        string = const_extract_re.sub(r"\1", string)
+    elif mode == "show_render":
+        string = const_extract_re.sub(r"\2", string)
+    else:
+        raise ValueError("Invalid mode")
+    return string
+
+
+@lru_cache(maxsize=128)
+def build_gpt_academic_masked_string(text_show_llm="", text_show_render=""):
+    """
+    根据字符串要给谁看（大模型，还是web渲染），生成带掩码tag的字符串
+    """
+    return f"<gpt_academic_string_mask><show_llm>{text_show_llm}</show_llm><show_render>{text_show_render}</show_render></gpt_academic_string_mask>"
+
+
+@lru_cache(maxsize=128)
+def apply_gpt_academic_string_mask_langbased(string, lang_reference):
+    """
+    当字符串中有掩码tag时（<gpt_academic_string_mask><lang_...>），根据语言，选择提示词，对字符串进行处理，返回处理后的字符串
+    例如，如果lang_reference是英文，那么就只显示英文提示词，中文提示词就不显示了
+    举例：
+        输入1
+            string = "注意，lang_reference这段文字是：<gpt_academic_string_mask><lang_english>英语</lang_english><lang_chinese>中文</lang_chinese></gpt_academic_string_mask>"
+            lang_reference = "hello world"
+        输出1
+            "注意，lang_reference这段文字是：英语"
+            
+        输入2
+            string = "注意，lang_reference这段文字是中文"   # 注意这里没有掩码tag，所以不会被处理
+            lang_reference = "hello world"
+        输出2
+            "注意，lang_reference这段文字是中文"            # 原样返回
+    """
+
+    if "<gpt_academic_string_mask>" not in string: # No need to process
+        return string
+
+    def contains_chinese(string):
+        chinese_regex = re.compile(u'[\u4e00-\u9fff]+')
+        return chinese_regex.search(string) is not None
+
+    mode = "english" if not contains_chinese(lang_reference) else "chinese"
+    if mode == "english":
+        string = const_extract_langbased_re.sub(r"\1", string)
+    elif mode == "chinese":
+        string = const_extract_langbased_re.sub(r"\2", string)
+    else:
+        raise ValueError("Invalid mode")
+    return string
+
+
+@lru_cache(maxsize=128)
+def build_gpt_academic_masked_string_langbased(text_show_english="", text_show_chinese=""):
+    """
+    根据语言，选择提示词，对字符串进行处理，返回处理后的字符串
+    """
+    return f"<gpt_academic_string_mask><lang_english>{text_show_english}</lang_english><lang_chinese>{text_show_chinese}</lang_chinese></gpt_academic_string_mask>"
+
+
+if __name__ == "__main__":
+    # Test
+    input_string = (
+        "你好\n"
+        + build_gpt_academic_masked_string(text_show_llm="mermaid", text_show_render="")
+        + "你好\n"
+    )
+    print(
+        apply_gpt_academic_string_mask(input_string, "show_llm")
+    )  # Should print the strings with 'abc' in place of the academic mask tags
+    print(
+        apply_gpt_academic_string_mask(input_string, "show_render")
+    )  # Should print the strings with 'xyz' in place of the academic mask tags
--- a/tests/test_key_pattern_manager.py
+++ b/tests/test_key_pattern_manager.py
@@ -0,0 +1,41 @@
+import unittest
+
+def validate_path():
+    import os, sys
+
+    os.path.dirname(__file__)
+    root_dir_assume = os.path.abspath(os.path.dirname(__file__) + "/..")
+    os.chdir(root_dir_assume)
+    sys.path.append(root_dir_assume)
+
+
+validate_path()  # validate path so you can run from base directory
+
+from shared_utils.key_pattern_manager import is_openai_api_key
+
+class TestKeyPatternManager(unittest.TestCase):
+    def test_is_openai_api_key_with_valid_key(self):
+        key = "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        self.assertTrue(is_openai_api_key(key))
+
+        key = "sx-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        self.assertFalse(is_openai_api_key(key))
+
+        key = "sess-wg61ZafYHpNz7FFwIH7HGZlbVqUVaeV5tatHCWpl"
+        self.assertTrue(is_openai_api_key(key))
+
+        key = "sess-wg61ZafYHpNz7FFwIH7HGZlbVqUVa5tatHCWpl"
+        self.assertFalse(is_openai_api_key(key))
+
+
+    def test_is_openai_api_key_with_invalid_key(self):
+        key = "invalid_key"
+        self.assertFalse(is_openai_api_key(key))
+
+    def test_is_openai_api_key_with_custom_pattern(self):
+        # Assuming you have set a custom pattern in your configuration
+        key = "custom-pattern-key"
+        self.assertFalse(is_openai_api_key(key))
+
+if __name__ == '__main__':
+    unittest.main()
--- a/tests/test_markdown.py
+++ b/tests/test_markdown.py
@@ -1,35 +1,37 @@
 md = """
-作为您的写作和编程助手，我可以为您提供以下服务：
+You can use the following Python script to rename files matching the pattern '* - 副本.tex' to '* - wushiguang.tex' in a directory:

-1. 写作：
-    - 帮助您撰写文章、报告、散文、故事等。
-    - 提供写作建议和技巧。
-    - 协助您进行文案策划和内容创作。
+```python
+import os

-2. 编程：
-    - 帮助您解决编程问题，提供编程思路和建议。
-    - 协助您编写代码，包括但不限于 Python、Java、C++ 等。
-    - 为您解释复杂的技术概念，让您更容易理解。
+# Directory containing the files
+directory = 'Tex/'

-3. 项目支持：
-    - 协助您规划项目进度和任务分配。
-    - 提供项目管理和协作建议。
-    - 在项目实施过程中提供支持，确保项目顺利进行。
+for filename in os.listdir(directory):
+    if filename.endswith(' - 副本.tex'):
+        new_filename = filename.replace(' - 副本.tex', ' - wushiguang.tex')
+        os.rename(os.path.join(directory, filename), os.path.join(directory, new_filename))
+```

-4. 学习辅导：
-    - 帮助您巩固编程基础，提高编程能力。
-    - 提供计算机科学、数据科学、人工智能等相关领域的学习资源和建议。
-    - 解答您在学习过程中遇到的问题，让您更好地掌握知识。
-
-5. 行业动态和趋势分析：
-    - 为您提供业界最新的新闻和技术趋势。
-    - 分析行业动态，帮助您了解市场发展和竞争态势。
-    - 为您制定技术战略提供参考和建议。
-
-请随时告诉我您的需求，我会尽力提供帮助。如果您有任何问题或需要解答的议题，请随时提问。
+Replace 'Tex/' with the actual directory path where your files are located before running the script.
 """


+md = """
+Following code including wrapper
+
+```mermaid
+graph TD
+    A[Enter Chart Definition] --> B(Preview)
+    B --> C{decide}
+    C --> D[Keep]
+    C --> E[Edit Definition]
+    E --> B
+    D --> F[Save Image and Code]
+    F --> B
+```
+
+"""
 def validate_path():
    import os, sys

@@ -43,6 +45,9 @@ validate_path()  # validate path so you can run from base directory
 from toolbox import markdown_convertion

 html = markdown_convertion(md)
-print(html)
+# print(html)
 with open("test.html", "w", encoding="utf-8") as f:
    f.write(html)
+
+
+# TODO: 列出10个经典名著
--- a/tests/test_plugins.py
+++ b/tests/test_plugins.py
@@ -20,10 +20,10 @@ if __name__ == "__main__":

    # plugin_test(plugin='crazy_functions.函数动态生成->函数动态生成', main_input='交换图像的蓝色通道和红色通道', advanced_arg={"file_path_arg": "./build/ants.jpg"})

-    # plugin_test(plugin='crazy_functions.Latex输出PDF结果->Latex翻译中文并重新编译PDF', main_input="2307.07522")
+    # plugin_test(plugin='crazy_functions.Latex输出PDF->Latex翻译中文并重新编译PDF', main_input="2307.07522")

    plugin_test(
-        plugin="crazy_functions.Latex输出PDF结果->Latex翻译中文并重新编译PDF",
+        plugin="crazy_functions.Latex输出PDF->Latex翻译中文并重新编译PDF",
        main_input="G:/SEAFILE_LOCAL/50503047/我的资料库/学位/paperlatex/aaai/Fu_8368_with_appendix",
    )

@@ -66,7 +66,7 @@ if __name__ == "__main__":

    # plugin_test(plugin='crazy_functions.知识库文件注入->读取知识库作答', main_input="远程云服务器部署？")

-    # plugin_test(plugin='crazy_functions.Latex输出PDF结果->Latex翻译中文并重新编译PDF', main_input="2210.03629")
+    # plugin_test(plugin='crazy_functions.Latex输出PDF->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)
--- a/themes/base64.mjs
+++ b/themes/base64.mjs
@@ -0,0 +1 @@
+// we have moved mermaid-related code to gradio-fix repository: binary-husky/gradio-fix@32150d0
--- a/themes/common.css
+++ b/themes/common.css
@@ -59,6 +59,7 @@

 /* Scrollbar Width */
 ::-webkit-scrollbar {
+    height: 12px;
    width: 12px;
 }

--- a/themes/common.js
+++ b/themes/common.js
@@ -109,7 +109,7 @@ function begin_loading_status() {
    C1.style.borderRadius = "50%";
    C1.style.margin = "-40px 0 0 -40px";
    C1.style.animation = "spinAndPulse 2s linear infinite";
-    
+
    C2.style.position = "fixed";
    C2.style.top = "50%";
    C2.style.left = "50%";
@@ -229,6 +229,33 @@ function addCopyButton(botElement) {
    botElement.appendChild(messageBtnColumn);
 }

+
+let timeoutID = null;
+let lastInvocationTime = 0;
+let lastArgs = null;
+function do_something_but_not_too_frequently(min_interval, func) {
+    return function (...args) {
+        lastArgs = args;
+        const now = Date.now();
+        if (!lastInvocationTime || (now - lastInvocationTime) >= min_interval) {
+            lastInvocationTime = now;
+            // 现在就执行
+            setTimeout(() => {
+                func.apply(this, lastArgs);
+            }, 0);
+        } else if (!timeoutID) {
+            // 等一会执行
+            timeoutID = setTimeout(() => {
+                timeoutID = null;
+                lastInvocationTime = Date.now();
+                func.apply(this, lastArgs);
+            }, min_interval - (now - lastInvocationTime));
+        } else {
+            // 压根不执行
+        }
+    }
+}
+
 function chatbotContentChanged(attempt = 1, force = false) {
    // https://github.com/GaiZhenbiao/ChuanhuChatGPT/tree/main/web_assets/javascript
    for (var i = 0; i < attempt; i++) {
@@ -236,6 +263,8 @@ function chatbotContentChanged(attempt = 1, force = false) {
            gradioApp().querySelectorAll('#gpt-chatbot .message-wrap .message.bot').forEach(addCopyButton);
        }, i === 0 ? 0 : 200);
    }
+    // we have moved mermaid-related code to gradio-fix repository: binary-husky/gradio-fix@32150d0
+
 }


@@ -270,8 +299,8 @@ function chatbotAutoHeight() {
    }
    monitoring_input_box()
    update_height();
-    window.addEventListener('resize', function() { update_height(); });
-    window.addEventListener('scroll', function() { update_height_slow(); });
+    window.addEventListener('resize', function () { update_height(); });
+    window.addEventListener('scroll', function () { update_height_slow(); });
    setInterval(function () { update_height_slow() }, 50); // 每50毫秒执行一次
 }

@@ -290,8 +319,8 @@ function swap_input_area() {
    // Swap the elements
    parent.insertBefore(element2, element1);
    parent.insertBefore(element1, nextSibling);
-    if (swapped) {swapped = false;}
-    else {swapped = true;}
+    if (swapped) { swapped = false; }
+    else { swapped = true; }
 }

 function get_elements(consider_state_panel = false) {
@@ -314,18 +343,18 @@ function get_elements(consider_state_panel = false) {
    var height_target = parseInt(height_target);
    var chatbot_height = chatbot.style.height;
    // 交换输入区位置，使得输入区始终可用
-    if (!swapped){
-        if (panel1.top!=0 && (panel1.bottom + panel1.top)/2 < 0){ swap_input_area(); }
+    if (!swapped) {
+        if (panel1.top != 0 && (0.9 * panel1.bottom + 0.1 * panel1.top) < 0) { swap_input_area(); }
    }
-    else if (swapped){
-        if (panel2.top!=0 && panel2.top > 0){ swap_input_area(); }
+    else if (swapped) {
+        if (panel2.top != 0 && panel2.top > 0) { swap_input_area(); }
    }
    // 调整高度
    const err_tor = 5;
-    if (Math.abs(panel1.left - chatbot.getBoundingClientRect().left) < err_tor){
+    if (Math.abs(panel1.left - chatbot.getBoundingClientRect().left) < err_tor) {
        // 是否处于窄屏模式
        height_target = window.innerHeight * 0.6;
-    }else{
+    } else {
        // 调整高度
        const chatbot_height_exceed = 15;
        const chatbot_height_exceed_m = 10;
@@ -356,7 +385,7 @@ var elem_upload_component_float = null;
 var elem_upload_component = null;
 var exist_file_msg = '⚠️请先删除上传区（左上方）中的历史文件，再尝试上传。'

-function locate_upload_elems(){
+function locate_upload_elems() {
    elem_upload = document.getElementById('elem_upload')
    elem_upload_float = document.getElementById('elem_upload_float')
    elem_input_main = document.getElementById('user_input_main')
@@ -386,7 +415,6 @@ async function upload_files(files) {
            Object.defineProperty(elem_upload_component_float, "files", { value: files, enumerable: true });
            elem_upload_component_float.dispatchEvent(event);
        } else {
-            console.log(exist_file_msg);
            toast_push(exist_file_msg, 3000);
        }
    }
@@ -500,7 +528,7 @@ function register_upload_event() {
            toast_push('正在上传中，请稍等。', 2000);
            begin_loading_status();
        });
-    }else{
+    } else {
        toast_push("oppps", 3000);
    }
 }
@@ -583,16 +611,16 @@ function minor_ui_adjustment() {
    function auto_hide_toolbar() {
        var qq = document.getElementById('tooltip');
        var tab_nav = qq.getElementsByClassName('tab-nav');
-        if (tab_nav.length == 0){ return; }
+        if (tab_nav.length == 0) { return; }
        var btn_list = tab_nav[0].getElementsByTagName('button')
-        if (btn_list.length == 0){ return; }
+        if (btn_list.length == 0) { return; }
        // 获取页面宽度
        var page_width = document.documentElement.clientWidth;
        // 总是保留的按钮数量
        const always_preserve = 2;
        // 获取最后一个按钮的右侧位置
-        var cur_right = btn_list[always_preserve-1].getBoundingClientRect().right;
-        if (bar_btn_width.length == 0){
+        var cur_right = btn_list[always_preserve - 1].getBoundingClientRect().right;
+        if (bar_btn_width.length == 0) {
            // 首次运行，记录每个按钮的宽度
            for (var i = 0; i < btn_list.length; i++) {
                bar_btn_width.push(btn_list[i].getBoundingClientRect().width);
@@ -602,14 +630,13 @@ function minor_ui_adjustment() {
        for (var i = always_preserve; i < btn_list.length; i++) {
            var element = btn_list[i];
            var element_right = element.getBoundingClientRect().right;
-            if (element_right!=0){ cur_right = element_right; }
+            if (element_right != 0) { cur_right = element_right; }
            if (element.style.display === 'none') {
                if ((cur_right + bar_btn_width[i]) < (page_width * 0.37)) {
                    // 恢复显示当前按钮
                    element.style.display = 'block';
-                    // console.log('show');
                    return;
-                }else{
+                } else {
                    return;
                }
            } else {
@@ -620,7 +647,6 @@ function minor_ui_adjustment() {
                            btn_list[j].style.display = 'none';
                        }
                    }
-                    // console.log('show');
                    return;
                }
            }
@@ -632,8 +658,41 @@ function minor_ui_adjustment() {
    }, 200); // 每50毫秒执行一次
 }

+
 // -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-//  第 6 部分: JS初始化函数
+//  第 6 部分: 避免滑动
+// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+let prevented_offset = 0;
+function limit_scroll_position() {
+    let scrollableDiv = document.querySelector('#gpt-chatbot > div.wrap');
+    scrollableDiv.addEventListener('wheel', function (e) {
+        let preventScroll = false;
+        if (e.deltaX != 0) { prevented_offset = 0; return; }
+        if (this.scrollHeight == this.clientHeight) { prevented_offset = 0; return; }
+        if (e.deltaY < 0) { prevented_offset = 0; return; }
+        if (e.deltaY > 0 && this.scrollHeight - this.clientHeight - this.scrollTop <= 1) { preventScroll = true; }
+
+        if (preventScroll) {
+            prevented_offset += e.deltaY;
+            if (Math.abs(prevented_offset) > 499) {
+                if (prevented_offset > 500) { prevented_offset = 500; }
+                if (prevented_offset < -500) { prevented_offset = -500; }
+                preventScroll = false;
+            }
+        } else {
+            prevented_offset = 0;
+        }
+        if (preventScroll) {
+            e.preventDefault();
+            return;
+        }
+    }, { passive: false }); // Passive event listener option should be false
+}
+
+
+
+// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+//  第 7 部分: JS初始化函数
 // -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

 function GptAcademicJavaScriptInit(LAYOUT = "LEFT-RIGHT") {
@@ -645,4 +704,165 @@ function GptAcademicJavaScriptInit(LAYOUT = "LEFT-RIGHT") {
    });
    chatbotObserver.observe(chatbotIndicator, { attributes: true, childList: true, subtree: true });
    if (LAYOUT === "LEFT-RIGHT") { chatbotAutoHeight(); }
+    if (LAYOUT === "LEFT-RIGHT") { limit_scroll_position(); }
+    // setInterval(function () { uml("mermaid") }, 5000); // 每50毫秒执行一次
+
 }
+
+
+function loadLive2D() {
+    try {
+        $("<link>").attr({ href: "file=themes/waifu_plugin/waifu.css", rel: "stylesheet", type: "text/css" }).appendTo('head');
+        $('body').append('<div class="waifu"><div class="waifu-tips"></div><canvas id="live2d" class="live2d"></canvas><div class="waifu-tool"><span class="fui-home"></span> <span class="fui-chat"></span> <span class="fui-eye"></span> <span class="fui-user"></span> <span class="fui-photo"></span> <span class="fui-info-circle"></span> <span class="fui-cross"></span></div></div>');
+        $.ajax({
+            url: "file=themes/waifu_plugin/waifu-tips.js", dataType: "script", cache: true, success: function () {
+                $.ajax({
+                    url: "file=themes/waifu_plugin/live2d.js", dataType: "script", cache: true, success: function () {
+                        /* 可直接修改部分参数 */
+                        live2d_settings['hitokotoAPI'] = "hitokoto.cn";  // 一言 API
+                        live2d_settings['modelId'] = 3;                  // 默认模型 ID
+                        live2d_settings['modelTexturesId'] = 44;          // 默认材质 ID
+                        live2d_settings['modelStorage'] = false;         // 不储存模型 ID
+                        live2d_settings['waifuSize'] = '210x187';
+                        live2d_settings['waifuTipsSize'] = '187x52';
+                        live2d_settings['canSwitchModel'] = true;
+                        live2d_settings['canSwitchTextures'] = true;
+                        live2d_settings['canSwitchHitokoto'] = false;
+                        live2d_settings['canTakeScreenshot'] = false;
+                        live2d_settings['canTurnToHomePage'] = false;
+                        live2d_settings['canTurnToAboutPage'] = false;
+                        live2d_settings['showHitokoto'] = false;         // 显示一言
+                        live2d_settings['showF12Status'] = false;         // 显示加载状态
+                        live2d_settings['showF12Message'] = false;        // 显示看板娘消息
+                        live2d_settings['showF12OpenMsg'] = false;         // 显示控制台打开提示
+                        live2d_settings['showCopyMessage'] = false;         // 显示 复制内容 提示
+                        live2d_settings['showWelcomeMessage'] = true;         // 显示进入面页欢迎词
+                        /* 在 initModel 前添加 */
+                        initModel("file=themes/waifu_plugin/waifu-tips.json");
+                    }
+                });
+            }
+        });
+    } catch (err) { console.log("[Error] JQuery is not defined.") }
+}
+
+function get_checkbox_selected_items(elem_id){
+    display_panel_arr = [];
+    document.getElementById(elem_id).querySelector('[data-testid="checkbox-group"]').querySelectorAll('label').forEach(label => {
+        // Get the span text
+        const spanText = label.querySelector('span').textContent;
+        // Get the input value
+        const checked = label.querySelector('input').checked;
+        if (checked) {
+            display_panel_arr.push(spanText)
+        }
+    });
+    return display_panel_arr;
+}
+
+function set_checkbox(key, bool, set_twice=false) {
+    set_success = false;
+    elem_ids = ["cbsc", "cbs"]
+    elem_ids.forEach(id => {
+        document.getElementById(id).querySelector('[data-testid="checkbox-group"]').querySelectorAll('label').forEach(label => {
+            // Get the span text
+            const spanText = label.querySelector('span').textContent;
+            if (spanText === key) {
+                if (bool){
+                    label.classList.add('selected');
+                } else {
+                    if (label.classList.contains('selected')) {
+                        label.classList.remove('selected');
+                    }
+                }
+                if (set_twice){
+                    setTimeout(() => {
+                        if (bool){
+                            label.classList.add('selected');
+                        } else {
+                            if (label.classList.contains('selected')) {
+                                label.classList.remove('selected');
+                            }
+                        }
+                    }, 5000);
+                }
+
+                label.querySelector('input').checked = bool;
+                set_success = true;
+                return
+            }
+        });
+    });
+
+    if (!set_success){
+        console.log("设置checkbox失败，没有找到对应的key")
+    }
+}
+
+function apply_cookie_for_checkbox(dark) {
+    // console.log("apply_cookie_for_checkboxes")
+    let searchString = "输入清除键";
+    let bool_value = "False";
+
+    //////////////////  darkmode  ///////////////////
+    if (getCookie("js_darkmode_cookie")) {
+        dark = getCookie("js_darkmode_cookie")
+    }
+    dark = dark == "True";
+    if (document.querySelectorAll('.dark').length) {
+        if (!dark) {
+            document.querySelectorAll('.dark').forEach(el => el.classList.remove('dark'));
+        }
+    } else {
+        if (dark) {
+            document.querySelector('body').classList.add('dark');
+        }
+    }
+
+    ////////////////////// clearButton ///////////////////////////
+    if (getCookie("js_clearbtn_show_cookie")) {
+        // have cookie
+        bool_value = getCookie("js_clearbtn_show_cookie")
+        bool_value = bool_value == "True";
+        searchString = "输入清除键";
+        if (bool_value) {
+            let clearButton = document.getElementById("elem_clear");
+            let clearButton2 = document.getElementById("elem_clear2");
+            clearButton.style.display = "block";
+            clearButton2.style.display = "block";
+            set_checkbox(searchString, true);
+        } else {
+            let clearButton = document.getElementById("elem_clear");
+            let clearButton2 = document.getElementById("elem_clear2");
+            clearButton.style.display = "none";
+            clearButton2.style.display = "none";
+            set_checkbox(searchString, false);
+        }
+    }
+
+    ////////////////////// live2d ///////////////////////////
+
+    if (getCookie("js_live2d_show_cookie")) {
+        // have cookie
+        searchString = "添加Live2D形象";
+        bool_value = getCookie("js_live2d_show_cookie");
+        bool_value = bool_value == "True";
+        if (bool_value) {
+            loadLive2D();
+            set_checkbox(searchString, true);
+        } else {
+            $('.waifu').hide();
+            set_checkbox(searchString, false);
+        }
+    } else {
+        // do not have cookie
+        // get conf
+        display_panel_arr = get_checkbox_selected_items("cbsc");
+        searchString = "添加Live2D形象";
+        if (display_panel_arr.includes(searchString)) {
+            loadLive2D();
+        } else {
+        }
+    }
+
+}
--- a/themes/common.py
+++ b/themes/common.py
@@ -0,0 +1,18 @@
+from toolbox import get_conf
+CODE_HIGHLIGHT, ADD_WAIFU, LAYOUT = get_conf("CODE_HIGHLIGHT", "ADD_WAIFU", "LAYOUT")
+
+def get_common_html_javascript_code():
+    js = "\n"
+    for jsf in [
+        "file=themes/common.js",
+    ]:
+        js += f"""<script src="{jsf}"></script>\n"""
+
+    # 添加Live2D
+    if ADD_WAIFU:
+        for jsf in [
+            "file=themes/waifu_plugin/jquery.min.js",
+            "file=themes/waifu_plugin/jquery-ui.min.js",
+        ]:
+            js += f"""<script src="{jsf}"></script>\n"""
+    return js
--- a/themes/contrast.py
+++ b/themes/contrast.py
@@ -67,16 +67,9 @@ def adjust_theme():
            button_cancel_text_color_dark="white",
        )

-        with open(os.path.join(theme_dir, "common.js"), "r", encoding="utf8") as f:
-            js = f"<script>{f.read()}</script>"
-
-        # 添加一个萌萌的看板娘
-        if ADD_WAIFU:
-            js += """
-                <script src="file=docs/waifu_plugin/jquery.min.js"></script>
-                <script src="file=docs/waifu_plugin/jquery-ui.min.js"></script>
-                <script src="file=docs/waifu_plugin/autoload.js"></script>
-            """
+        from themes.common import get_common_html_javascript_code
+        js = get_common_html_javascript_code()
+        
        if not hasattr(gr, "RawTemplateResponse"):
            gr.RawTemplateResponse = gr.routes.templates.TemplateResponse
        gradio_original_template_fn = gr.RawTemplateResponse
--- a/themes/default.py
+++ b/themes/default.py
@@ -67,16 +67,8 @@ def adjust_theme():
            button_cancel_text_color_dark="white",
        )

-        with open(os.path.join(theme_dir, "common.js"), "r", encoding="utf8") as f:
-            js = f"<script>{f.read()}</script>"
-
-        # 添加一个萌萌的看板娘
-        if ADD_WAIFU:
-            js += """
-                <script src="file=docs/waifu_plugin/jquery.min.js"></script>
-                <script src="file=docs/waifu_plugin/jquery-ui.min.js"></script>
-                <script src="file=docs/waifu_plugin/autoload.js"></script>
-            """
+        from themes.common import get_common_html_javascript_code
+        js = get_common_html_javascript_code()
        if not hasattr(gr, "RawTemplateResponse"):
            gr.RawTemplateResponse = gr.routes.templates.TemplateResponse
        gradio_original_template_fn = gr.RawTemplateResponse
--- a/themes/gradios.py
+++ b/themes/gradios.py
@@ -31,16 +31,9 @@ def adjust_theme():
                THEME = THEME.lstrip("huggingface-")
            set_theme = set_theme.from_hub(THEME.lower())

-        with open(os.path.join(theme_dir, "common.js"), "r", encoding="utf8") as f:
-            js = f"<script>{f.read()}</script>"
-
-        # 添加一个萌萌的看板娘
-        if ADD_WAIFU:
-            js += """
-                <script src="file=docs/waifu_plugin/jquery.min.js"></script>
-                <script src="file=docs/waifu_plugin/jquery-ui.min.js"></script>
-                <script src="file=docs/waifu_plugin/autoload.js"></script>
-            """
+        from themes.common import get_common_html_javascript_code
+        js = get_common_html_javascript_code()
+        
        if not hasattr(gr, "RawTemplateResponse"):
            gr.RawTemplateResponse = gr.routes.templates.TemplateResponse
        gradio_original_template_fn = gr.RawTemplateResponse
--- a/themes/green.py
+++ b/themes/green.py
@@ -76,16 +76,8 @@ def adjust_theme():
            chatbot_code_background_color_dark="*neutral_950",
        )

-        with open(os.path.join(theme_dir, "common.js"), "r", encoding="utf8") as f:
-            js = f"<script>{f.read()}</script>"
-
-        # 添加一个萌萌的看板娘
-        if ADD_WAIFU:
-            js += """
-                <script src="file=docs/waifu_plugin/jquery.min.js"></script>
-                <script src="file=docs/waifu_plugin/jquery-ui.min.js"></script>
-                <script src="file=docs/waifu_plugin/autoload.js"></script>
-            """
+        from themes.common import get_common_html_javascript_code
+        js = get_common_html_javascript_code()

        with open(os.path.join(theme_dir, "green.js"), "r", encoding="utf8") as f:
            js += f"<script>{f.read()}</script>"
--- a/themes/mermaid.min.js
+++ b/themes/mermaid.min.js
@@ -0,0 +1 @@
+// we have moved mermaid-related code to gradio-fix repository: binary-husky/gradio-fix@32150d0
--- a/themes/mermaid_editor.js
+++ b/themes/mermaid_editor.js
@@ -0,0 +1 @@
+// we have moved mermaid-related code to gradio-fix repository: binary-husky/gradio-fix@32150d0
--- a/themes/mermaid_loader.js
+++ b/themes/mermaid_loader.js
@@ -0,0 +1 @@
+// we have moved mermaid-related code to gradio-fix repository: binary-husky/gradio-fix@32150d0
--- a/themes/pako.esm.mjs
+++ b/themes/pako.esm.mjs
@@ -0,0 +1 @@
+// we have moved mermaid-related code to gradio-fix repository: binary-husky/gradio-fix@32150d0
--- a/themes/theme.py
+++ b/themes/theme.py
@@ -46,8 +46,7 @@ cookie相关工具函数
 -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 """

-
-def init_cookie(cookies, chatbot):
+def init_cookie(cookies):
    # 为每一位访问的用户赋予一个独一无二的uuid编码
    cookies.update({"uuid": uuid.uuid4()})
    return cookies
@@ -91,30 +90,107 @@ js_code_for_css_changing = """(css) => {
 }
 """

-js_code_for_darkmode_init = """(dark) => {
-    dark = dark == "True";
-    if (document.querySelectorAll('.dark').length) {
-        if (!dark){
-            document.querySelectorAll('.dark').forEach(el => el.classList.remove('dark'));
-        }
-    } else {
-        if (dark){
-            document.querySelector('body').classList.add('dark');
-        }
-    }
-}
-"""

 js_code_for_toggle_darkmode = """() => {
    if (document.querySelectorAll('.dark').length) {
+        setCookie("js_darkmode_cookie", "False", 365);
        document.querySelectorAll('.dark').forEach(el => el.classList.remove('dark'));
    } else {
+        setCookie("js_darkmode_cookie", "True", 365);
        document.querySelector('body').classList.add('dark');
    }
+    document.querySelectorAll('code_pending_render').forEach(code => {code.remove();})
 }"""


-js_code_for_persistent_cookie_init = """(persistent_cookie) => {
-    return getCookie("persistent_cookie");
+js_code_for_persistent_cookie_init = """(py_pickle_cookie, cookie) => {
+    return [getCookie("py_pickle_cookie"), cookie];
+}
+"""
+
+
+js_code_reset = """
+(a,b,c)=>{
+    return [[], [], "已重置"];
+}
+"""
+
+
+js_code_clear = """
+(a,b)=>{
+    return ["", ""];
+}
+"""
+
+
+js_code_show_or_hide = """
+(display_panel_arr)=>{
+setTimeout(() => {
+    // get conf
+    display_panel_arr = get_checkbox_selected_items("cbs");
+
+    ////////////////////// 输入清除键 ///////////////////////////
+    let searchString = "输入清除键";
+    let ele = "none";
+    if (display_panel_arr.includes(searchString)) {
+        let clearButton = document.getElementById("elem_clear");
+        let clearButton2 = document.getElementById("elem_clear2");
+        clearButton.style.display = "block";
+        clearButton2.style.display = "block";
+        setCookie("js_clearbtn_show_cookie", "True", 365);
+    } else {
+        let clearButton = document.getElementById("elem_clear");
+        let clearButton2 = document.getElementById("elem_clear2");
+        clearButton.style.display = "none";
+        clearButton2.style.display = "none";
+        setCookie("js_clearbtn_show_cookie", "False", 365);
+    }
+
+    ////////////////////// 基础功能区 ///////////////////////////
+    searchString = "基础功能区";
+    if (display_panel_arr.includes(searchString)) {
+        ele = document.getElementById("basic-panel");
+        ele.style.display = "block";
+    } else {
+        ele = document.getElementById("basic-panel");
+        ele.style.display = "none";
+    }
+
+    ////////////////////// 函数插件区 ///////////////////////////
+    searchString = "函数插件区";
+    if (display_panel_arr.includes(searchString)) {
+        ele = document.getElementById("plugin-panel");
+        ele.style.display = "block";
+    } else {
+        ele = document.getElementById("plugin-panel");
+        ele.style.display = "none";
+    }
+
+}, 50);
+}
+"""
+
+
+
+js_code_show_or_hide_group2 = """
+(display_panel_arr)=>{
+setTimeout(() => {
+    // console.log("display_panel_arr");
+    // get conf
+    display_panel_arr = get_checkbox_selected_items("cbsc");
+
+    ////////////////////// 添加Live2D形象 ///////////////////////////
+    let searchString = "添加Live2D形象";
+    let ele = "none";
+    if (display_panel_arr.includes(searchString)) {
+        setCookie("js_live2d_show_cookie", "True", 365);
+        loadLive2D();
+    } else {
+        setCookie("js_live2d_show_cookie", "False", 365);
+        $('.waifu').hide();
+    }
+
+
+}, 50);
 }
 """
--- a/themes/waifu_plugin/autoload.js
+++ b/themes/waifu_plugin/autoload.js
--- a/themes/waifu_plugin/flat-ui-icons-regular.eot
+++ b/themes/waifu_plugin/flat-ui-icons-regular.eot
--- a/themes/waifu_plugin/flat-ui-icons-regular.svg
+++ b/themes/waifu_plugin/flat-ui-icons-regular.svg
--- a/显示更多
+++ b/显示更多
作者	SHA1	备注	提交日期
binary-husky	9d48afb61d	Revert "Update README.md (#1581 )" This reverts commit `0665eb75ed`.	2024-02-26 22:53:15 +08:00
binary-husky	0665eb75ed	Update README.md (#1581 )	2024-02-26 22:52:00 +08:00
binary-husky	6b784035fa	Merge branch 'master' of github.com:binary-husky/chatgpt_academic	2024-02-25 21:13:56 +08:00
binary-husky	8bb3d84912	fix zip chinese file name error	2024-02-25 21:13:41 +08:00
binary-husky	a0193cf227	edit dep url	2024-02-23 13:28:49 +08:00
binary-husky	b72289bfb0	Fix missing MATHPIX_APPID and MATHPIX_APPKEY configuration	2024-02-21 14:20:10 +08:00
Menghuan1918	bdfe3862eb	添加部分翻译 (#1566 )	2024-02-21 14:14:06 +08:00
binary-husky	dae180b9ea	update spark v3.5, fix glm parallel problem	2024-02-18 14:08:35 +08:00
binary-husky	e359fff040	Fix response message bug in bridge_qianfan.py, bridge_qwen.py, and bridge_skylark2.py	2024-02-15 00:02:24 +08:00
binary-husky	2e9b4a5770	Merge Frontier, Update to Version 3.72 (#1553 ) * Zhipu sdk update 适配最新的智谱SDK，支持GLM4v (#1502) * 适配 google gemini 优化为从用户input中提取文件 * 适配最新的智谱SDK、支持glm-4v * requirements.txt fix * pending history check --------- Co-authored-by: binary-husky <qingxu.fu@outlook.com> * Update "生成多种Mermaid图表" plugin: Separate out the file reading function (#1520) * Update crazy_functional.py with new functionality deal with PDF * Update crazy_functional.py and Mermaid.py for plugin_kwargs * Update crazy_functional.py with new chart type: mind map * Update SELECT_PROMPT and i_say_show_user messages * Update ArgsReminder message in get_crazy_functions() function * Update with read md file and update PROMPTS * Return the PROMPTS as the test found that the initial version worked best * Update Mermaid chart generation function * version 3.71 * 解决issues #1510 * Remove unnecessary text from sys_prompt in 解析历史输入 function * Remove sys_prompt message in 解析历史输入 function * Update bridge_all.py: supports gpt-4-turbo-preview (#1517) * Update bridge_all.py: supports gpt-4-turbo-preview supports gpt-4-turbo-preview * Update bridge_all.py --------- Co-authored-by: binary-husky <96192199+binary-husky@users.noreply.github.com> * Update config.py: supports gpt-4-turbo-preview (#1516) * Update config.py: supports gpt-4-turbo-preview supports gpt-4-turbo-preview * Update config.py --------- Co-authored-by: binary-husky <96192199+binary-husky@users.noreply.github.com> * Refactor 解析历史输入 function to handle file input * Update Mermaid chart generation functionality * rename files and functions --------- Co-authored-by: binary-husky <qingxu.fu@outlook.com> Co-authored-by: hongyi-zhao <hongyi.zhao@gmail.com> Co-authored-by: binary-husky <96192199+binary-husky@users.noreply.github.com> * 接入mathpix ocr功能 (#1468) * Update Latex输出PDF结果.py 借助mathpix实现了PDF翻译中文并重新编译PDF * Update config.py add mathpix appid & appkey * Add 'PDF翻译中文并重新编译PDF' feature to plugins. --------- Co-authored-by: binary-husky <96192199+binary-husky@users.noreply.github.com> * fix zhipuai * check picture * remove glm-4 due to bug * 修改config * 检查MATHPIX_APPID * Remove unnecessary code and update function_plugins dictionary * capture non-standard token overflow * bug fix #1524 * change mermaid style * 支持mermaid 滚动放大缩小重置,鼠标滚动和拖拽 (#1530) * 支持mermaid 滚动放大缩小重置,鼠标滚动和拖拽 * 微调未果先stage一下 * update --------- Co-authored-by: binary-husky <qingxu.fu@outlook.com> Co-authored-by: binary-husky <96192199+binary-husky@users.noreply.github.com> * ver 3.72 * change live2d * save the status of ``clear btn` in cookie * 前端选择保持 * js ui bug fix * reset btn bug fix * update live2d tips * fix missing get_token_num method * fix live2d toggle switch * fix persistent custom btn with cookie * fix zhipuai feedback with core functionality * Refactor button update and clean up functions --------- Co-authored-by: XIao <46100050+Kilig947@users.noreply.github.com> Co-authored-by: Menghuan1918 <menghuan2003@outlook.com> Co-authored-by: hongyi-zhao <hongyi.zhao@gmail.com> Co-authored-by: Hao Ma <893017927@qq.com> Co-authored-by: zeyuan huang <599012428@qq.com>	2024-02-14 18:35:09 +08:00
binary-husky	e0c5859cf9	update Column min_width parameter	2024-02-12 23:37:31 +08:00
binary-husky	b9b1e12dc9	fix missing get_token_num method	2024-02-12 15:58:55 +08:00
binary-husky	8814026ec3	fix gradio-client version (#1548 )	2024-02-09 13:25:01 +08:00
binary-husky	3025d5be45	remove jsdelivr (#1547 )	2024-02-09 13:17:14 +08:00
binary-husky	6c13bb7b46	patch issue #1538	2024-02-06 17:59:09 +08:00
binary-husky	c27e559f10	match sess-* key	2024-02-06 17:51:47 +08:00
binary-husky	cdb5288f49	fix issue #1532	2024-02-02 17:47:35 +08:00
hongyi-zhao	49c6fcfe97	Update config.py: supports gpt-4-turbo-preview (#1516 ) * Update config.py: supports gpt-4-turbo-preview supports gpt-4-turbo-preview * Update config.py --------- Co-authored-by: binary-husky <96192199+binary-husky@users.noreply.github.com>	2024-01-26 16:44:32 +08:00
hongyi-zhao	45fa0404eb	Update bridge_all.py: supports gpt-4-turbo-preview (#1517 ) * Update bridge_all.py: supports gpt-4-turbo-preview supports gpt-4-turbo-preview * Update bridge_all.py --------- Co-authored-by: binary-husky <96192199+binary-husky@users.noreply.github.com>	2024-01-26 16:36:23 +08:00
binary-husky	f889ef7625	解决issues #1510	2024-01-25 22:42:08 +08:00
binary-husky	a93bf4410d	version 3.71	2024-01-25 22:18:43 +08:00
binary-husky	1c0764753a	Merge branch 'frontier' of github.com:binary-husky/chatgpt_academic into frontier	2024-01-25 22:05:13 +08:00
Menghuan1918	c847209ac9	Update "Generate multiple Mermaid charts" plugin with md file read (#1506 ) * Update crazy_functional.py with new functionality deal with PDF * Update crazy_functional.py and Mermaid.py for plugin_kwargs * Update crazy_functional.py with new chart type: mind map * Update SELECT_PROMPT and i_say_show_user messages * Update ArgsReminder message in get_crazy_functions() function * Update with read md file and update PROMPTS * Return the PROMPTS as the test found that the initial version worked best * Update Mermaid chart generation function	2024-01-24 17:44:54 +08:00
binary-husky	4f9d40c14f	删除冗余代码	2024-01-24 01:42:31 +08:00
binary-husky	91926d24b7	处理一个core_functional.py中出现的mermaid渲染特例	2024-01-24 01:38:06 +08:00
binary-husky	ef311c4859	localize mjs scripts	2024-01-24 01:06:58 +08:00
binary-husky	82795d3817	remove mask string feature for now (still buggy)	2024-01-24 00:44:27 +08:00
binary-husky	49e28a5a00	Merge branch 'frontier' of github.com:binary-husky/chatgpt_academic into frontier	2024-01-23 15:48:49 +08:00
binary-husky	01def2e329	Merge branch 'master' into frontier	2024-01-23 15:48:06 +08:00
Menghuan1918	2291be2b28	Update "Generate multiple Mermaid charts" plugin (#1503 ) * Update crazy_functional.py with new functionality deal with PDF * Update crazy_functional.py and Mermaid.py for plugin_kwargs	2024-01-23 15:45:34 +08:00
binary-husky	c89ec7969f	fix test import err	2024-01-23 09:52:58 +08:00
Menghuan1918	1506c19834	Update crazy_functional.py with new functionality deal with PDF (#1500 )	2024-01-22 14:55:39 +08:00
binary-husky	a6fdc493b7	autogen plugin bug fix	2024-01-22 00:08:04 +08:00
binary-husky	113067c6ab	Merge branch 'master' into frontier	2024-01-21 23:49:20 +08:00
Menghuan1918	7b6828ab07	从当前对话历史中生产Mermaid图表的插件 (#1497 ) * Add functionality to generate multiple types of Mermaid charts * Update conditional statement in 解析历史输入 function	2024-01-21 23:41:39 +08:00
binary-husky	d818c38dfe	better theme	2024-01-21 19:41:18 +08:00
binary-husky	08b4e9796e	Update README.md (#1499 ) * Update README.md * Update README.md	2024-01-21 19:08:48 +08:00
binary-husky	b55d573819	auto prompt lang	2024-01-21 13:47:11 +08:00
binary-husky	06b0e800a2	修复渲染的小BUG	2024-01-21 12:19:04 +08:00
binary-husky	7bbaf05961	Merge branch 'master' into frontier	2024-01-20 22:33:41 +08:00
binary-husky	3b83279855	anim generation bug fix #896	2024-01-20 22:17:51 +08:00
binary-husky	37164a826e	GengKanghua #896	2024-01-20 22:14:13 +08:00
binary-husky	dd2a97e7a9	draw project struct with mermaid	2024-01-20 21:23:56 +08:00
binary-husky	e579006c4a	add set_multi_conf	2024-01-20 18:33:35 +08:00
binary-husky	031f19b6dd	替换错误的变量名称	2024-01-20 18:28:54 +08:00
binary-husky	142b516749	gpt_academic text mask imp	2024-01-20 18:00:06 +08:00
binary-husky	f2e73aa580	智谱API突发恶疾	2024-01-19 21:09:27 +08:00
binary-husky	8565a35cf7	readme update	2024-01-18 23:21:11 +08:00
binary-husky	72d78eb150	Merge branch 'master' of github.com:binary-husky/chatgpt_academic	2024-01-18 23:07:05 +08:00
binary-husky	7aeda537ac	remove debug btn	2024-01-18 23:05:47 +08:00
binary-husky	6cea17d4b7	remove debug btn	2024-01-18 22:33:49 +08:00
binary-husky	20bc51d747	Merge branch 'master' into frontier	2024-01-18 22:23:26 +08:00
XIao	b8ebefa427	Google gemini fix (#1473 ) * 适配 google gemini 优化为从用户input中提取文件 * Update README.md (#1477) * Update README.md * Update README.md * Update requirements.txt (#1480) * welcome glm4 from 智谱! * Update README.md (#1484) * Update README.md (#1485) * update zhipu * Fix translation task name in core_functional.py * zhipuai version problem --------- Co-authored-by: binary-husky <96192199+binary-husky@users.noreply.github.com> Co-authored-by: binary-husky <qingxu.fu@outlook.com>	2024-01-18 18:06:07 +08:00
binary-husky	dcc9326f0b	zhipuai version problem	2024-01-18 17:51:20 +08:00
binary-husky	94fc396eb9	Fix translation task name in core_functional.py	2024-01-18 15:32:17 +08:00
binary-husky	e594e1b928	update zhipu	2024-01-18 00:32:51 +08:00
binary-husky	8fe545d97b	update zhipu	2024-01-18 00:31:53 +08:00
binary-husky	6f978fa72e	Merge branch 'master' into frontier	2024-01-17 12:37:07 +08:00
binary-husky	19be471aa8	Refactor core_functional.py	2024-01-17 12:34:42 +08:00
binary-husky	38956934fd	Update README.md (#1485 )	2024-01-17 11:45:49 +08:00
binary-husky	32439e14b5	Update README.md (#1484 )	2024-01-17 11:30:09 +08:00
binary-husky	317389bf4b	Merge branch 'master' into frontier	2024-01-16 21:53:53 +08:00
binary-husky	2c740fc641	welcome glm4 from 智谱!	2024-01-16 21:51:14 +08:00
binary-husky	96832a8228	Update requirements.txt (#1480 )	2024-01-16 20:08:32 +08:00
binary-husky	361557da3c	roll version	2024-01-16 02:15:35 +08:00
binary-husky	5f18d4a1af	Update README.md (#1477 ) * Update README.md * Update README.md	2024-01-16 02:14:08 +08:00
binary-husky	0d10bc570f	bug fix	2024-01-16 01:22:50 +08:00
binary-husky	3ce7d9347d	dark support	2024-01-16 00:33:11 +08:00
Keldos	8a78d7b89f	adapt mermaid to dark mode (#1476 ) Co-authored-by: binary-husky <96192199+binary-husky@users.noreply.github.com>	2024-01-16 00:32:12 +08:00
binary-husky	0e43b08837	同步	2024-01-16 00:29:46 +08:00
binary-husky	74bced2d35	添加脑图编辑按钮	2024-01-15 13:41:21 +08:00
binary-husky	961a24846f	remove console log	2024-01-15 11:50:37 +08:00
binary-husky	b7e4744f28	apply to other themes	2024-01-15 11:49:04 +08:00
binary-husky	71adc40901	support diagram plotting via mermaid !	2024-01-15 02:49:21 +08:00
binary-husky	a2099f1622	fix code highlight problem	2024-01-15 00:07:07 +08:00
binary-husky	c0a697f6c8	publish gradio via jsdelivr	2024-01-14 16:46:10 +08:00
binary-husky	bdde1d2fd7	format code	2024-01-14 04:18:38 +08:00
binary-husky	63373ab3b6	Merge branch 'frontier' of github.com:binary-husky/chatgpt_academic into frontier	2024-01-14 03:41:47 +08:00
binary-husky	fb6566adde	add todo	2024-01-14 03:41:23 +08:00
binary-husky	9f2ef9ec49	limit scroll	2024-01-14 02:11:07 +08:00
binary-husky	35c1aa21e4	limit scroll	2024-01-14 01:55:59 +08:00
binary-husky	627d739720	注入火山引擎大模型的接口代码	2024-01-13 22:33:08 +08:00
binary-husky	37f15185b6	Merge branch 'master' into frontier	2024-01-13 18:23:55 +08:00
binary-husky	9643e1c25f	code dem fix	2024-01-13 18:23:06 +08:00
binary-husky	28eae2f80e	Merge branch 'frontier' of github.com:binary-husky/chatgpt_academic into frontier	2024-01-13 18:04:21 +08:00
binary-husky	7ab379688e	format source code	2024-01-13 18:04:09 +08:00
binary-husky	3d4c6f54f1	format source code	2024-01-13 18:00:52 +08:00
binary-husky	1714116a89	break down toolbox.py to multiple files	2024-01-13 16:10:46 +08:00
binary-husky	d698b96209	Merge branch 'master' into frontier	2024-01-07 18:49:56 +08:00
binary-husky	6b1c6f0bf7	better gui interaction	2024-01-07 18:49:08 +08:00
				`@@ -0,0 +1 @@`
				`// we have moved mermaid-related code to gradio-fix repository: binary-husky/gradio-fix@32150d0`