1

2025-02-07 11:21:24 +08:00 · 2025-02-07 11:17:38 +08:00 · 2025-02-06 10:46:46 +08:00 · 2025-02-06 10:32:13 +08:00 · 2025-02-06 10:30:58 +08:00 · 2025-02-06 10:23:42 +08:00
32 changed files with 1177 additions and 260 deletions
--- a/.github/workflows/stale.yml
+++ b/.github/workflows/stale.yml
@@ -7,7 +7,7 @@
 name: 'Close stale issues and PRs'
 on:
  schedule:
-    - cron: '*/5 * * * *'
+    - cron: '*/30 * * * *'

 jobs:
  stale:
@@ -19,7 +19,6 @@ jobs:
    steps:
      - uses: actions/stale@v8
        with:
-          stale-issue-message: 'This issue is stale because it has been open 100 days with no activity. Remove stale label or comment or this will be closed in 1 days.'
+          stale-issue-message: 'This issue is stale because it has been open 100 days with no activity. Remove stale label or comment or this will be closed in 7 days.'
          days-before-stale: 100
-          days-before-close: 1
-          debug-only: true
+          days-before-close: 7
--- a/2
+++ b/2
@@ -15,6 +15,7 @@ RUN echo '[global]' > /etc/pip.conf && \
 # 语音输出功能（以下两行，第一行更换阿里源，第二行安装ffmpeg，都可以删除）
 RUN UBUNTU_VERSION=$(awk -F= '/^VERSION_CODENAME=/{print $2}' /etc/os-release); echo "deb https://mirrors.aliyun.com/debian/ $UBUNTU_VERSION main non-free contrib" > /etc/apt/sources.list; apt-get update
 RUN apt-get install ffmpeg -y
+RUN apt-get clean


 # 进入工作路径（必要）
@@ -33,6 +34,7 @@ RUN pip3 install -r requirements.txt

 # 非必要步骤，用于预热模块（可以删除）
 RUN python3  -c 'from check_proxy import warm_up_modules; warm_up_modules()'
+RUN python3 -m pip cache purge


 # 启动（必要）
--- a/README.md
+++ b/README.md
@@ -1,9 +1,11 @@
 > [!IMPORTANT]
+> `master主分支`最新动态(2025.2.4): 增加deepseek-r1支持  
 > `frontier开发分支`最新动态(2024.12.9): 更新对话时间线功能，优化xelatex论文翻译  
 > `wiki文档`最新动态(2024.12.5): 更新ollama接入指南  
 >
-> 2024.10.10: 突发停电，紧急恢复了提供[whl包](https://drive.google.com/file/d/19U_hsLoMrjOlQSzYS3pzWX9fTzyusArP/view?usp=sharing)的文件服务器  
-> 2024.10.8: 版本3.90加入对llama-index的初步支持，版本3.80加入插件二级菜单功能（详见wiki）  
+> 2025.2.2: 三分钟快速接入最强qwen2.5-max[视频](https://www.bilibili.com/video/BV1LeFuerEG4)  
+> 2025.2.1: 支持自定义字体  
+> 2024.10.10: 突发停电，紧急恢复了提供[whl包](https://drive.google.com/drive/folders/14kR-3V-lIbvGxri4AHc8TpiA1fqsw7SK?usp=sharing)的文件服务器  
 > 2024.5.1: 加入Doc2x翻译PDF论文的功能，[查看详情](https://github.com/binary-husky/gpt_academic/wiki/Doc2x)  
 > 2024.3.11: 全力支持Qwen、GLM、DeepseekCoder等中文大语言模型！ SoVits语音克隆模块，[查看详情](https://www.bilibili.com/video/BV1Rp421S7tF/) 
 > 2024.1.17: 安装依赖时，请选择`requirements.txt`中**指定的版本**。 安装命令：`pip install -r requirements.txt`。本项目完全开源免费，您可通过订阅[在线服务](https://github.com/binary-husky/gpt_academic/wiki/online)的方式鼓励本项目的发展。
@@ -127,20 +129,20 @@ Latex论文一键校对 | [插件] 仿Grammarly对Latex文章进行语法、拼

 ```mermaid
 flowchart TD
-    A{"安装方法"} --> W1("I. 🔑直接运行 (Windows, Linux or MacOS)")
-    W1 --> W11["1. Python pip包管理依赖"]
-    W1 --> W12["2. Anaconda包管理依赖（推荐⭐）"]
+    A{"安装方法"} --> W1("I 🔑直接运行 (Windows, Linux or MacOS)")
+    W1 --> W11["1 Python pip包管理依赖"]
+    W1 --> W12["2 Anaconda包管理依赖（推荐⭐）"]

-    A --> W2["II. 🐳使用Docker (Windows, Linux or MacOS)"]
+    A --> W2["II 🐳使用Docker (Windows, Linux or MacOS)"]

-    W2 --> k1["1. 部署项目全部能力的大镜像（推荐⭐）"]
-    W2 --> k2["2. 仅在线模型（GPT, GLM4等）镜像"]
-    W2 --> k3["3. 在线模型 + Latex的大镜像"]
+    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. ... 其他 ..."]
+    A --> W4["IV 🚀其他部署方法"]
+    W4 --> C1["1 Windows/MacOS 一键安装运行脚本（推荐⭐）"]
+    W4 --> C2["2 Huggingface, Sealos远程部署"]
+    W4 --> C4["3 其他 ..."]
 ```

 ### 安装方法I：直接运行 (Windows, Linux or MacOS)
--- a/config.py
+++ b/config.py
@@ -7,11 +7,16 @@
    Configuration reading priority: environment variable > config_private.py > config.py
 """

-# [step 1]>> API_KEY = "sk-123456789xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx123456789"。极少数情况下，还需要填写组织（格式如org-123456789abcdefghijklmno的），请向下翻，找 API_ORG 设置项
-API_KEY = "此处填API密钥"    # 可同时填写多个API-KEY，用英文逗号分割，例如API_KEY = "sk-openaikey1,sk-openaikey2,fkxxxx-api2dkey3,azure-apikey4"
+# [step 1-1]>> ( 接入GPT等模型 ) API_KEY = "sk-123456789xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx123456789"。极少数情况下，还需要填写组织（格式如org-123456789abcdefghijklmno的），请向下翻，找 API_ORG 设置项
+API_KEY = "在此处填写APIKEY"    # 可同时填写多个API-KEY，用英文逗号分割，例如API_KEY = "sk-openaikey1,sk-openaikey2,fkxxxx-api2dkey3,azure-apikey4"

+# [step 1-2]>> ( 接入通义 qwen-max ) 接入通义千问在线大模型，api-key获取地址 https://dashscope.console.aliyun.com/
+DASHSCOPE_API_KEY = "" # 阿里灵积云API_KEY

-# [step 2]>> 改为True应用代理，如果直接在海外服务器部署，此处不修改；如果使用本地或无地域限制的大模型时，此处也不需要修改
+# [step 1-3]>> ( 接入 deepseek-reasoner, 即 deepseek-r1 ) 深度求索(DeepSeek) API KEY，默认请求地址为"https://api.deepseek.com/v1/chat/completions"
+DEEPSEEK_API_KEY = "sk-d99b8cc6b7414cc88a5d950a3ff7585e"
+
+# [step 2]>> 改为True应用代理。如果使用本地或无地域限制的大模型时，此处不修改；如果直接在海外服务器部署，此处不修改
 USE_PROXY = False
 if USE_PROXY:
    """
@@ -32,11 +37,13 @@ else:

 # [step 3]>> 模型选择是 (注意: LLM_MODEL是默认选中的模型, 它*必须*被包含在AVAIL_LLM_MODELS列表中 )
 LLM_MODEL = "gpt-3.5-turbo-16k" # 可选 ↓↓↓
-AVAIL_LLM_MODELS = ["gpt-4-1106-preview", "gpt-4-turbo-preview", "gpt-4-vision-preview",
+AVAIL_LLM_MODELS = ["qwen-max", "o1-mini", "o1-mini-2024-09-12", "o1", "o1-2024-12-17", "o1-preview", "o1-preview-2024-09-12",
+                    "gpt-4-1106-preview", "gpt-4-turbo-preview", "gpt-4-vision-preview",
                    "gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-4-turbo-2024-04-09",
                    "gpt-3.5-turbo-1106", "gpt-3.5-turbo-16k", "gpt-3.5-turbo", "azure-gpt-3.5",
                    "gpt-4", "gpt-4-32k", "azure-gpt-4", "glm-4", "glm-4v", "glm-3-turbo",
-                    "gemini-1.5-pro", "chatglm3", "chatglm4"
+                    "gemini-1.5-pro", "chatglm3", "chatglm4",
+                    "deepseek-chat", "deepseek-coder", "deepseek-reasoner"
                    ]

 EMBEDDING_MODEL = "text-embedding-3-small"
@@ -47,7 +54,7 @@ EMBEDDING_MODEL = "text-embedding-3-small"
 #   "glm-4-0520", "glm-4-air", "glm-4-airx", "glm-4-flash",
 #   "qianfan", "deepseekcoder",
 #   "spark", "sparkv2", "sparkv3", "sparkv3.5", "sparkv4",
-#   "qwen-turbo", "qwen-plus", "qwen-max", "qwen-local",
+#   "qwen-turbo", "qwen-plus", "qwen-local",
 #   "moonshot-v1-128k", "moonshot-v1-32k", "moonshot-v1-8k",
 #   "gpt-3.5-turbo-0613", "gpt-3.5-turbo-16k-0613", "gpt-3.5-turbo-0125", "gpt-4o-2024-05-13"
 #   "claude-3-haiku-20240307","claude-3-sonnet-20240229","claude-3-opus-20240229", "claude-2.1", "claude-instant-1.2",
@@ -82,6 +89,30 @@ DEFAULT_WORKER_NUM = 3
 THEME = "Default"
 AVAIL_THEMES = ["Default", "Chuanhu-Small-and-Beautiful", "High-Contrast", "Gstaff/Xkcd", "NoCrypt/Miku"]

+FONT = "Theme-Default-Font"
+AVAIL_FONTS = [
+    "默认值(Theme-Default-Font)",
+    "宋体(SimSun)",
+    "黑体(SimHei)",
+    "楷体(KaiTi)",
+    "仿宋(FangSong)",
+    "华文细黑(STHeiti Light)",
+    "华文楷体(STKaiti)",
+    "华文仿宋(STFangsong)",
+    "华文宋体(STSong)",
+    "华文中宋(STZhongsong)",
+    "华文新魏(STXinwei)",
+    "华文隶书(STLiti)",
+    "思源宋体(Source Han Serif CN VF@https://chinese-fonts-cdn.deno.dev/packages/syst/dist/SourceHanSerifCN/result.css)",
+    "月星楷(Moon Stars Kai HW@https://chinese-fonts-cdn.deno.dev/packages/moon-stars-kai/dist/MoonStarsKaiHW-Regular/result.css)",
+    "珠圆体(MaokenZhuyuanTi@https://chinese-fonts-cdn.deno.dev/packages/mkzyt/dist/猫啃珠圆体/result.css)",
+    "平方萌萌哒(PING FANG MENG MNEG DA@https://chinese-fonts-cdn.deno.dev/packages/pfmmd/dist/平方萌萌哒/result.css)",
+    "Helvetica",
+    "ui-sans-serif",
+    "sans-serif",
+    "system-ui"
+]
+

 # 默认的系统提示词（system prompt）
 INIT_SYS_PROMPT = "Serve me as a writing and programming assistant."
@@ -133,10 +164,6 @@ MULTI_QUERY_LLM_MODELS = "gpt-3.5-turbo&chatglm3"
 QWEN_LOCAL_MODEL_SELECTION = "Qwen/Qwen-1_8B-Chat-Int8"


-# 接入通义千问在线大模型 https://dashscope.console.aliyun.com/
-DASHSCOPE_API_KEY = "" # 阿里灵积云API_KEY
-
-
 # 百度千帆（LLM_MODEL="qianfan"）
 BAIDU_CLOUD_API_KEY = ''
 BAIDU_CLOUD_SECRET_KEY = ''
@@ -238,9 +265,6 @@ MOONSHOT_API_KEY = ""
 # 零一万物(Yi Model) API KEY
 YIMODEL_API_KEY = ""

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

 # 紫东太初大模型 https://ai-maas.wair.ac.cn
 TAICHU_API_KEY = ""
@@ -303,7 +327,7 @@ ARXIV_CACHE_DIR = "gpt_log/arxiv_cache"


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


--- a/config_private.py
+++ b/config_private.py
@@ -0,0 +1,444 @@
+"""
+    以下所有配置也都支持利用环境变量覆写，环境变量配置格式见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.
+    Configuration reading priority: environment variable > config_private.py > config.py
+"""
+
+# [step 1-1]>> ( 接入GPT等模型 ) API_KEY = "sk-123456789xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx123456789"。极少数情况下，还需要填写组织（格式如org-123456789abcdefghijklmno的），请向下翻，找 API_ORG 设置项
+API_KEY = "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"    # 可同时填写多个API-KEY，用英文逗号分割，例如API_KEY = "sk-openaikey1,sk-openaikey2,fkxxxx-api2dkey1,fkxxxx-api2dkey2"
+
+# [step 1-2]>> ( 接入通义 qwen-max ) 接入通义千问在线大模型，api-key获取地址 https://dashscope.console.aliyun.com/
+DASHSCOPE_API_KEY = "" # 阿里灵积云API_KEY
+
+# [step 1-3]>> ( 接入 deepseek-reasoner, 即 deepseek-r1 ) 深度求索(DeepSeek) API KEY，默认请求地址为"https://api.deepseek.com/v1/chat/completions"
+DEEPSEEK_API_KEY = "sk-d99b8cc6b7414cc88a5d950a3ff7585e"
+
+# [step 2]>> 改为True应用代理。如果使用本地或无地域限制的大模型时，此处不修改；如果直接在海外服务器部署，此处不修改
+USE_PROXY = True
+if USE_PROXY:
+    proxies = {
+        "http":"socks5h://192.168.8.9:1070",  # 再例如  "http":  "http://127.0.0.1:7890",
+        "https":"socks5h://192.168.8.9:1070",  # 再例如  "https": "http://127.0.0.1:7890",
+    }
+else:
+    proxies = None
+DEFAULT_WORKER_NUM = 256
+
+# [step 3]>> 模型选择是 (注意: LLM_MODEL是默认选中的模型, 它*必须*被包含在AVAIL_LLM_MODELS列表中 )
+LLM_MODEL = "gpt-4-32k" # 可选 ↓↓↓
+AVAIL_LLM_MODELS = ["deepseek-chat", "deepseek-coder", "deepseek-reasoner",
+                    "gpt-4-1106-preview", "gpt-4-turbo-preview", "gpt-4-vision-preview",
+                    "gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-4-turbo-2024-04-09",
+                    "gpt-3.5-turbo-1106", "gpt-3.5-turbo-16k", "gpt-3.5-turbo", "azure-gpt-3.5",
+                    "gpt-4", "gpt-4-32k", "azure-gpt-4", "glm-4", "glm-4v", "glm-3-turbo",
+                    "gemini-1.5-pro", "chatglm3", "chatglm4",
+                    ]
+
+EMBEDDING_MODEL = "text-embedding-3-small"
+
+# --- --- --- ---
+# P.S. 其他可用的模型还包括
+# AVAIL_LLM_MODELS = [
+#   "glm-4-0520", "glm-4-air", "glm-4-airx", "glm-4-flash",
+#   "qianfan", "deepseekcoder",
+#   "spark", "sparkv2", "sparkv3", "sparkv3.5", "sparkv4",
+#   "qwen-turbo", "qwen-plus", "qwen-local",
+#   "moonshot-v1-128k", "moonshot-v1-32k", "moonshot-v1-8k",
+#   "gpt-3.5-turbo-0613", "gpt-3.5-turbo-16k-0613", "gpt-3.5-turbo-0125", "gpt-4o-2024-05-13"
+#   "claude-3-haiku-20240307","claude-3-sonnet-20240229","claude-3-opus-20240229", "claude-2.1", "claude-instant-1.2",
+#   "moss", "llama2", "chatglm_onnx", "internlm", "jittorllms_pangualpha", "jittorllms_llama",
+#   "deepseek-chat" ,"deepseek-coder",
+#   "gemini-1.5-flash",
+#   "yi-34b-chat-0205","yi-34b-chat-200k","yi-large","yi-medium","yi-spark","yi-large-turbo","yi-large-preview",
+#   "grok-beta",
+# ]
+# --- --- --- ---
+# 此外，您还可以在接入one-api/vllm/ollama/Openroute时，
+# 使用"one-api-*","vllm-*","ollama-*","openrouter-*"前缀直接使用非标准方式接入的模型，例如
+# AVAIL_LLM_MODELS = ["one-api-claude-3-sonnet-20240229(max_token=100000)", "ollama-phi3(max_token=4096)","openrouter-openai/gpt-4o-mini","openrouter-openai/chatgpt-4o-latest"]
+# --- --- --- ---
+
+
+# --------------- 以下配置可以优化体验 ---------------
+
+# 重新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": "https://reverse-proxy-url/v1/chat/completions", "http://localhost:11434/api/chat": "在这里填写您ollama的URL"}
+API_URL_REDIRECT = {}
+
+
+# 多线程函数插件中，默认允许多少路线程同时访问OpenAI。Free trial users的限制是每分钟3次，Pay-as-you-go users的限制是每分钟3500次
+# 一言以蔽之：免费（5刀）用户填3，OpenAI绑了信用卡的用户可以填 16 或者更高。提高限制请查询：https://platform.openai.com/docs/guides/rate-limits/overview
+DEFAULT_WORKER_NUM = 64
+
+
+# 色彩主题, 可选 ["Default", "Chuanhu-Small-and-Beautiful", "High-Contrast"]
+# 更多主题, 请查阅Gradio主题商店: https://huggingface.co/spaces/gradio/theme-gallery 可选 ["Gstaff/Xkcd", "NoCrypt/Miku", ...]
+THEME = "Default"
+AVAIL_THEMES = ["Default", "Chuanhu-Small-and-Beautiful", "High-Contrast", "Gstaff/Xkcd", "NoCrypt/Miku"]
+
+FONT = "Theme-Default-Font"
+AVAIL_FONTS = [
+    "默认值(Theme-Default-Font)",
+    "宋体(SimSun)",
+    "黑体(SimHei)",
+    "楷体(KaiTi)",
+    "仿宋(FangSong)",
+    "华文细黑(STHeiti Light)",
+    "华文楷体(STKaiti)",
+    "华文仿宋(STFangsong)",
+    "华文宋体(STSong)",
+    "华文中宋(STZhongsong)",
+    "华文新魏(STXinwei)",
+    "华文隶书(STLiti)",
+    "思源宋体(Source Han Serif CN VF@https://chinese-fonts-cdn.deno.dev/packages/syst/dist/SourceHanSerifCN/result.css)",
+    "月星楷(Moon Stars Kai HW@https://chinese-fonts-cdn.deno.dev/packages/moon-stars-kai/dist/MoonStarsKaiHW-Regular/result.css)",
+    "珠圆体(MaokenZhuyuanTi@https://chinese-fonts-cdn.deno.dev/packages/mkzyt/dist/猫啃珠圆体/result.css)",
+    "平方萌萌哒(PING FANG MENG MNEG DA@https://chinese-fonts-cdn.deno.dev/packages/pfmmd/dist/平方萌萌哒/result.css)",
+    "Helvetica",
+    "ui-sans-serif",
+    "sans-serif",
+    "system-ui"
+]
+
+
+# 默认的系统提示词（system prompt）
+INIT_SYS_PROMPT = "Serve me as a writing and programming assistant."
+
+
+# 对话窗的高度 （仅在LAYOUT="TOP-DOWN"时生效）
+CHATBOT_HEIGHT = 1115
+
+
+# 代码高亮
+CODE_HIGHLIGHT = True
+
+
+# 窗口布局
+LAYOUT = "LEFT-RIGHT"   # "LEFT-RIGHT"（左右布局） # "TOP-DOWN"（上下布局）
+
+
+# 暗色模式 / 亮色模式
+DARK_MODE = True
+
+
+# 发送请求到OpenAI后，等待多久判定为超时
+TIMEOUT_SECONDS = 60
+
+
+# 网页的端口, -1代表随机端口
+WEB_PORT = 19998
+
+# 是否自动打开浏览器页面
+AUTO_OPEN_BROWSER = True
+
+
+# 如果OpenAI不响应（网络卡顿、代理失败、KEY失效），重试的次数限制
+MAX_RETRY = 5
+
+
+# 插件分类默认选项
+DEFAULT_FN_GROUPS = ['对话', '编程', '学术', '智能体']
+
+
+# 定义界面上“询问多个GPT模型”插件应该使用哪些模型，请从AVAIL_LLM_MODELS中选择，并在不同模型之间用`&`间隔，例如"gpt-3.5-turbo&chatglm3&azure-gpt-4"
+MULTI_QUERY_LLM_MODELS = "gpt-3.5-turbo&chatglm3"
+
+
+# 选择本地模型变体（只有当AVAIL_LLM_MODELS包含了对应本地模型时，才会起作用）
+# 如果你选择Qwen系列的模型，那么请在下面的QWEN_MODEL_SELECTION中指定具体的模型
+# 也可以是具体的模型路径
+QWEN_LOCAL_MODEL_SELECTION = "Qwen/Qwen-1_8B-Chat-Int8"
+
+
+# 百度千帆（LLM_MODEL="qianfan"）
+BAIDU_CLOUD_API_KEY = ''
+BAIDU_CLOUD_SECRET_KEY = ''
+BAIDU_CLOUD_QIANFAN_MODEL = 'ERNIE-Bot'    # 可选 "ERNIE-Bot-4"(文心大模型4.0), "ERNIE-Bot"(文心一言), "ERNIE-Bot-turbo", "BLOOMZ-7B", "Llama-2-70B-Chat", "Llama-2-13B-Chat", "Llama-2-7B-Chat", "ERNIE-Speed-128K", "ERNIE-Speed-8K", "ERNIE-Lite-8K"
+
+
+# 如果使用ChatGLM3或ChatGLM4本地模型，请把 LLM_MODEL="chatglm3" 或LLM_MODEL="chatglm4"，并在此处指定模型路径
+CHATGLM_LOCAL_MODEL_PATH = "THUDM/glm-4-9b-chat" # 例如"/home/hmp/ChatGLM3-6B/"
+
+# 如果使用ChatGLM2微调模型，请把 LLM_MODEL="chatglmft"，并在此处指定模型路径
+CHATGLM_PTUNING_CHECKPOINT = "" # 例如"/home/hmp/ChatGLM2-6B/ptuning/output/6b-pt-128-1e-2/checkpoint-100"
+
+
+# 本地LLM模型如ChatGLM的执行方式 CPU/GPU
+LOCAL_MODEL_DEVICE = "cpu" # 可选 "cuda"
+LOCAL_MODEL_QUANT = "FP16" # 默认 "FP16" "INT4" 启用量化INT4版本 "INT8" 启用量化INT8版本
+
+
+# 设置gradio的并行线程数（不需要修改）
+CONCURRENT_COUNT = 100
+
+
+# 是否在提交时自动清空输入框
+AUTO_CLEAR_TXT = False
+
+
+# 加一个live2d装饰
+ADD_WAIFU = False
+
+
+# 设置用户名和密码（不需要修改）（相关功能不稳定，与gradio版本和网络都相关，如果本地使用不建议加这个）
+# [("username", "password"), ("username2", "password2"), ...]
+AUTHENTICATION = [("van", "L807878712"),("林", "L807878712"),("源", "L807878712"),("欣", "L807878712"),("z", "czh123456789")]
+
+
+# 如果需要在二级路径下运行（常规情况下，不要修改!!）
+# （举例 CUSTOM_PATH = "/gpt_academic"，可以让软件运行在 http://ip:port/gpt_academic/ 下。）
+CUSTOM_PATH = "/"
+
+
+# HTTPS 秘钥和证书（不需要修改）
+SSL_KEYFILE = ""
+SSL_CERTFILE = ""
+
+
+# 极少数情况下，openai的官方KEY需要伴随组织编码（格式如org-xxxxxxxxxxxxxxxxxxxxxxxx）使用
+API_ORG = ""
+
+
+# 如果需要使用Slack Claude，使用教程详情见 request_llms/README.md
+SLACK_CLAUDE_BOT_ID = ''
+SLACK_CLAUDE_USER_TOKEN = ''
+
+
+# 如果需要使用AZURE（方法一：单个azure模型部署）详情请见额外文档 docs\use_azure.md
+AZURE_ENDPOINT = "https://你亲手写的api名称.openai.azure.com/"
+AZURE_API_KEY = "填入azure openai api的密钥"    # 建议直接在API_KEY处填写，该选项即将被弃用
+AZURE_ENGINE = "填入你亲手写的部署名"            # 读 docs\use_azure.md
+
+
+# 如果需要使用AZURE（方法二：多个azure模型部署+动态切换）详情请见额外文档 docs\use_azure.md
+AZURE_CFG_ARRAY = {}
+
+
+# 阿里云实时语音识别 配置难度较高
+# 参考 https://github.com/binary-husky/gpt_academic/blob/master/docs/use_audio.md
+ENABLE_AUDIO = False
+ALIYUN_TOKEN=""     # 例如 f37f30e0f9934c34a992f6f64f7eba4f
+ALIYUN_APPKEY=""    # 例如 RoPlZrM88DnAFkZK
+ALIYUN_ACCESSKEY="" # （无需填写）
+ALIYUN_SECRET=""    # （无需填写）
+
+
+# GPT-SOVITS 文本转语音服务的运行地址（将语言模型的生成文本朗读出来）
+TTS_TYPE = "DISABLE" # EDGE_TTS / LOCAL_SOVITS_API / DISABLE
+GPT_SOVITS_URL = ""
+EDGE_TTS_VOICE = "zh-CN-XiaoxiaoNeural"
+
+
+# 接入讯飞星火大模型 https://console.xfyun.cn/services/iat
+XFYUN_APPID = "00000000"
+XFYUN_API_SECRET = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
+XFYUN_API_KEY = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+
+
+# 接入智谱大模型
+ZHIPUAI_API_KEY = ""
+ZHIPUAI_MODEL = "" # 此选项已废弃，不再需要填写
+
+
+# Claude API KEY
+ANTHROPIC_API_KEY = ""
+
+
+# 月之暗面 API KEY
+MOONSHOT_API_KEY = ""
+
+
+# 零一万物(Yi Model) API KEY
+YIMODEL_API_KEY = ""
+
+
+# 紫东太初大模型 https://ai-maas.wair.ac.cn
+TAICHU_API_KEY = ""
+
+# Grok API KEY
+GROK_API_KEY = ""
+
+# Mathpix 拥有执行PDF的OCR功能，但是需要注册账号
+MATHPIX_APPID = ""
+MATHPIX_APPKEY = ""
+
+
+# DOC2X的PDF解析服务，注册账号并获取API KEY: https://doc2x.noedgeai.com/login
+DOC2X_API_KEY = ""
+
+
+# 自定义API KEY格式
+CUSTOM_API_KEY_PATTERN = ""
+
+
+# Google Gemini API-Key
+GEMINI_API_KEY = ''
+
+
+# HUGGINGFACE的TOKEN，下载LLAMA时起作用 https://huggingface.co/docs/hub/security-tokens
+HUGGINGFACE_ACCESS_TOKEN = "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"
+
+
+# GROBID服务器地址（填写多个可以均衡负载），用于高质量地读取PDF文档
+# 获取方法：复制以下空间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",
+]
+
+
+# Searxng互联网检索服务（这是一个huggingface空间，请前往huggingface复制该空间，然后把自己新的空间地址填在这里）
+SEARXNG_URLS = [ f"https://kaletianlre-beardvs{i}dd.hf.space/" for i in range(1,5) ]
+
+
+# 是否允许通过自然语言描述修改本页的配置，该功能具有一定的危险性，默认关闭
+ALLOW_RESET_CONFIG = False
+
+
+# 在使用AutoGen插件时，是否使用Docker容器运行代码
+AUTOGEN_USE_DOCKER = False
+
+
+# 临时的上传文件夹位置，请尽量不要修改
+PATH_PRIVATE_UPLOAD = "private_upload"
+
+
+# 日志文件夹的位置，请尽量不要修改
+PATH_LOGGING = "gpt_log"
+
+
+# 存储翻译好的arxiv论文的路径，请尽量不要修改
+ARXIV_CACHE_DIR = "gpt_log/arxiv_cache"
+
+
+# 除了连接OpenAI之外，还有哪些场合允许使用代理，请尽量不要修改
+WHEN_TO_USE_PROXY = ["Connect_OpenAI", "Download_LLM", "Download_Gradio_Theme", "Connect_Grobid",
+                     "Warmup_Modules", "Nougat_Download", "AutoGen", "Connect_OpenAI_Embedding"]
+
+
+# 启用插件热加载
+PLUGIN_HOT_RELOAD = False
+
+
+# 自定义按钮的最大数量限制
+NUM_CUSTOM_BASIC_BTN = 4
+
+
+# 媒体智能体的服务地址（这是一个huggingface空间，请前往huggingface复制该空间，然后把自己新的空间地址填在这里）
+DAAS_SERVER_URLS = [ f"https://niuziniu-biligpt{i}.hf.space/stream" for i in range(1,5) ]
+
+
+
+"""
+--------------- 配置关联关系说明 ---------------
+
+在线大模型配置关联关系示意图
+│
+├── "gpt-3.5-turbo" 等openai模型
+│   ├── API_KEY
+│   ├── CUSTOM_API_KEY_PATTERN（不常用）
+│   ├── API_ORG（不常用）
+│   └── API_URL_REDIRECT（不常用）
+│
+├── "azure-gpt-3.5" 等azure模型（单个azure模型，不需要动态切换）
+│   ├── API_KEY
+│   ├── AZURE_ENDPOINT
+│   ├── AZURE_API_KEY
+│   ├── AZURE_ENGINE
+│   └── API_URL_REDIRECT
+│
+├── "azure-gpt-3.5" 等azure模型（多个azure模型，需要动态切换，高优先级）
+│   └── AZURE_CFG_ARRAY
+│
+├── "spark" 星火认知大模型 spark & sparkv2
+│   ├── XFYUN_APPID
+│   ├── XFYUN_API_SECRET
+│   └── XFYUN_API_KEY
+│
+├── "claude-3-opus-20240229" 等claude模型
+│   └── ANTHROPIC_API_KEY
+│
+├── "stack-claude"
+│   ├── SLACK_CLAUDE_BOT_ID
+│   └── SLACK_CLAUDE_USER_TOKEN
+│
+├── "qianfan" 百度千帆大模型库
+│   ├── BAIDU_CLOUD_QIANFAN_MODEL
+│   ├── BAIDU_CLOUD_API_KEY
+│   └── BAIDU_CLOUD_SECRET_KEY
+│
+├── "glm-4", "glm-3-turbo", "zhipuai" 智谱AI大模型
+│   └── ZHIPUAI_API_KEY
+│
+├── "yi-34b-chat-0205", "yi-34b-chat-200k" 等零一万物(Yi Model)大模型
+│   └── YIMODEL_API_KEY
+│
+├── "qwen-turbo" 等通义千问大模型
+│   └──  DASHSCOPE_API_KEY
+│
+├── "Gemini"
+│   └──  GEMINI_API_KEY
+│
+└── "one-api-...(max_token=...)" 用一种更方便的方式接入one-api多模型管理界面
+    ├── AVAIL_LLM_MODELS
+    ├── API_KEY
+    └── API_URL_REDIRECT
+
+
+本地大模型示意图
+│
+├── "chatglm4"
+├── "chatglm3"
+├── "chatglm"
+├── "chatglm_onnx"
+├── "chatglmft"
+├── "internlm"
+├── "moss"
+├── "jittorllms_pangualpha"
+├── "jittorllms_llama"
+├── "deepseekcoder"
+├── "qwen-local"
+├──  RWKV的支持见Wiki
+└── "llama2"
+
+
+用户图形界面布局依赖关系示意图
+│
+├── CHATBOT_HEIGHT 对话窗的高度
+├── CODE_HIGHLIGHT 代码高亮
+├── LAYOUT 窗口布局
+├── DARK_MODE 暗色模式 / 亮色模式
+├── DEFAULT_FN_GROUPS 插件分类默认选项
+├── THEME 色彩主题
+├── AUTO_CLEAR_TXT 是否在提交时自动清空输入框
+├── ADD_WAIFU 加一个live2d装饰
+└── ALLOW_RESET_CONFIG 是否允许通过自然语言描述修改本页的配置，该功能具有一定的危险性
+
+
+插件在线服务配置依赖关系示意图
+│
+├── 互联网检索
+│   └── SEARXNG_URLS
+│
+├── 语音功能
+│   ├── ENABLE_AUDIO
+│   ├── ALIYUN_TOKEN
+│   ├── ALIYUN_APPKEY
+│   ├── ALIYUN_ACCESSKEY
+│   └── ALIYUN_SECRET
+│
+└── PDF文档精准解析
+    ├── GROBID_URLS
+    ├── MATHPIX_APPID
+    └── MATHPIX_APPKEY
+
+
+"""
+
+
+
--- a/crazy_functions/latex_fns/latex_actions.py
+++ b/crazy_functions/latex_fns/latex_actions.py
@@ -373,7 +373,7 @@ def 编译Latex(chatbot, history, main_file_original, main_file_modified, work_f
    # 根据编译器类型返回编译命令
    def get_compile_command(compiler, filename):
        compile_command = f'{compiler} -interaction=batchmode -file-line-error {filename}.tex'
-        logger.info('Latex 编译指令: ', compile_command)
+        logger.info('Latex 编译指令: ' + compile_command)
        return compile_command

    # 确定使用的编译器
--- a/docs/GithubAction+AllCapacity
+++ b/docs/GithubAction+AllCapacity
@@ -5,6 +5,10 @@ FROM fuqingxu/11.3.1-runtime-ubuntu20.04-with-texlive:latest

 # edge-tts需要的依赖，某些pip包所需的依赖
 RUN apt update && apt install ffmpeg build-essential -y
+RUN apt-get install -y fontconfig
+RUN ln -s /usr/local/texlive/2023/texmf-dist/fonts/truetype /usr/share/fonts/truetype/texlive
+RUN fc-cache -fv
+RUN apt-get clean

 # use python3 as the system default python
 WORKDIR /gpt
@@ -30,7 +34,7 @@ RUN python3 -m pip install -r request_llms/requirements_qwen.txt
 RUN python3 -m pip install -r request_llms/requirements_chatglm.txt
 RUN python3 -m pip install -r request_llms/requirements_newbing.txt
 RUN python3 -m pip install nougat-ocr
-
+RUN python3 -m pip cache purge

 # 预热Tiktoken模块
 RUN python3  -c 'from check_proxy import warm_up_modules; warm_up_modules()'
--- a/docs/GithubAction+ChatGLM+Moss
+++ b/docs/GithubAction+ChatGLM+Moss
@@ -7,6 +7,7 @@ RUN apt-get install -y git python python3 python-dev python3-dev --fix-missing

 # edge-tts需要的依赖，某些pip包所需的依赖
 RUN apt update && apt install ffmpeg build-essential -y
+RUN apt-get clean

 # use python3 as the system default python
 RUN curl -sS https://bootstrap.pypa.io/get-pip.py | python3.8
@@ -22,6 +23,7 @@ RUN python3 -m pip install -r request_llms/requirements_moss.txt
 RUN python3 -m pip install -r request_llms/requirements_qwen.txt
 RUN python3 -m pip install -r request_llms/requirements_chatglm.txt
 RUN python3 -m pip install -r request_llms/requirements_newbing.txt
+RUN python3 -m pip cache purge


 # 预热Tiktoken模块
--- a/docs/GithubAction+NoLocal
+++ b/docs/GithubAction+NoLocal
@@ -18,5 +18,7 @@ RUN apt update && apt install ffmpeg -y
 # 可选步骤，用于预热模块
 RUN python3  -c 'from check_proxy import warm_up_modules; warm_up_modules()'

+RUN python3 -m pip cache purge && apt-get clean
+
 # 启动
 CMD ["python3", "-u", "main.py"]
--- a/docs/GithubAction+NoLocal+Latex
+++ b/docs/GithubAction+NoLocal+Latex
@@ -30,5 +30,7 @@ COPY --chown=gptuser:gptuser . .
 # 可选步骤，用于预热模块
 RUN python3 -c 'from check_proxy import warm_up_modules; warm_up_modules()'

+RUN python3 -m pip cache purge
+
 # 启动
 CMD ["python3", "-u", "main.py"]
--- a/docs/GithubAction+NoLocal+Vectordb
+++ b/docs/GithubAction+NoLocal+Vectordb
@@ -24,6 +24,8 @@ RUN apt update && apt install ffmpeg -y

 # 可选步骤，用于预热模块
 RUN python3  -c 'from check_proxy import warm_up_modules; warm_up_modules()'
+RUN python3 -m pip cache purge && apt-get clean
+

 # 启动
 CMD ["python3", "-u", "main.py"]
--- a/main.py
+++ b/main.py
@@ -1,10 +1,7 @@
-import os, json; os.environ['no_proxy'] = '*' # 避免代理网络产生意外污染
+import os; os.environ['no_proxy'] = '*' # 避免代理网络产生意外污染

 help_menu_description = \
-"""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),
-如遇到Bug请前往[Bug反馈](https://github.com/binary-husky/gpt_academic/issues).
+"""
 </br></br>普通对话使用说明: 1. 输入问题; 2. 点击提交
 </br></br>基础功能区使用说明: 1. 输入文本; 2. 点击任意基础功能区按钮
 </br></br>函数插件区使用说明: 1. 输入路径/问题, 或者上传文件; 2. 点击任意函数插件区按钮
@@ -49,7 +46,7 @@ def main():
    # 读取配置
    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, ADD_WAIFU = get_conf('ENABLE_AUDIO', 'AUTO_CLEAR_TXT', 'PATH_LOGGING', 'AVAIL_THEMES', 'THEME', 'ADD_WAIFU')
+    ENABLE_AUDIO, AUTO_CLEAR_TXT, AVAIL_FONTS, AVAIL_THEMES, THEME, ADD_WAIFU = get_conf('ENABLE_AUDIO', 'AUTO_CLEAR_TXT', 'AVAIL_FONTS', 'AVAIL_THEMES', 'THEME', 'ADD_WAIFU')
    NUM_CUSTOM_BASIC_BTN, SSL_KEYFILE, SSL_CERTFILE = get_conf('NUM_CUSTOM_BASIC_BTN', 'SSL_KEYFILE', 'SSL_CERTFILE')
    DARK_MODE, INIT_SYS_PROMPT, ADD_WAIFU, TTS_TYPE = get_conf('DARK_MODE', 'INIT_SYS_PROMPT', 'ADD_WAIFU', 'TTS_TYPE')
    if LLM_MODEL not in AVAIL_LLM_MODELS: AVAIL_LLM_MODELS += [LLM_MODEL]
@@ -178,13 +175,13 @@ def main():
        # 左上角工具栏定义
        from themes.gui_toolbar import define_gui_toolbar
        checkboxes, checkboxes_2, max_length_sl, theme_dropdown, system_prompt, file_upload_2, md_dropdown, top_p, temperature = \
-            define_gui_toolbar(AVAIL_LLM_MODELS, LLM_MODEL, INIT_SYS_PROMPT, THEME, AVAIL_THEMES, ADD_WAIFU, help_menu_description, js_code_for_toggle_darkmode)
+            define_gui_toolbar(AVAIL_LLM_MODELS, LLM_MODEL, INIT_SYS_PROMPT, THEME, AVAIL_THEMES, AVAIL_FONTS, ADD_WAIFU, help_menu_description, js_code_for_toggle_darkmode)

        # 浮动菜单定义
        from themes.gui_floating_menu import define_gui_floating_menu
        area_input_secondary, txt2, area_customize, _, resetBtn2, clearBtn2, stopBtn2 = \
            define_gui_floating_menu(customize_btns, functional, predefined_btns, cookies, web_cookie_cache)
-        
+
        # 浮动时间线定义
        gr.Spark()

@@ -217,7 +214,7 @@ def main():
        input_combo_order = ["cookies", "max_length_sl", "md_dropdown", "txt", "txt2", "top_p", "temperature", "chatbot", "history", "system_prompt", "plugin_advanced_arg"]
        output_combo = [cookies, chatbot, history, status]
        predict_args = dict(fn=ArgsGeneralWrapper(predict), inputs=[*input_combo, gr.State(True)], outputs=output_combo)
-        
+
        # 提交按钮、重置按钮
        multiplex_submit_btn.click(
            None, [multiplex_sel], None, _js="""(multiplex_sel)=>multiplex_function_begin(multiplex_sel)""")
@@ -226,11 +223,8 @@ def main():
        multiplex_sel.select(
            None, [multiplex_sel], None, _js=f"""(multiplex_sel)=>run_multiplex_shift(multiplex_sel)""")
        cancel_handles.append(submit_btn.click(**predict_args))
-        resetBtn.click(None, None, [chatbot, history, status], _js="""(a,b,c)=>clear_conversation(a,b,c)""")   # 先在前端快速清除chatbot&status
-        resetBtn2.click(None, None, [chatbot, history, status], _js="""(a,b,c)=>clear_conversation(a,b,c)""")  # 先在前端快速清除chatbot&status
-        # reset_server_side_args = (lambda history: ([], [], "已重置"), [history], [chatbot, history, status])
-        # resetBtn.click(*reset_server_side_args)    # 再在后端清除history
-        # resetBtn2.click(*reset_server_side_args)   # 再在后端清除history
+        resetBtn.click(None, None, [chatbot, history, status], _js= """clear_conversation""")   # 先在前端快速清除chatbot&status
+        resetBtn2.click(None, None, [chatbot, history, status], _js="""clear_conversation""")  # 先在前端快速清除chatbot&status
        clearBtn.click(None, None, [txt, txt2], _js=js_code_clear)
        clearBtn2.click(None, None, [txt, txt2], _js=js_code_clear)
        if AUTO_CLEAR_TXT:
--- a/request_llms/bridge_all.py
+++ b/request_llms/bridge_all.py
@@ -273,7 +273,9 @@ model_info = {
        "token_cnt": get_token_num_gpt4,
        "openai_disable_system_prompt": True,
        "openai_disable_stream": True,
+        "openai_force_temperature_one": True,
    },
+
    "o1-mini": {
        "fn_with_ui": chatgpt_ui,
        "fn_without_ui": chatgpt_noui,
@@ -283,6 +285,31 @@ model_info = {
        "token_cnt": get_token_num_gpt4,
        "openai_disable_system_prompt": True,
        "openai_disable_stream": True,
+        "openai_force_temperature_one": True,
+    },
+
+    "o1-2024-12-17": {
+        "fn_with_ui": chatgpt_ui,
+        "fn_without_ui": chatgpt_noui,
+        "endpoint": openai_endpoint,
+        "max_token": 200000,
+        "tokenizer": tokenizer_gpt4,
+        "token_cnt": get_token_num_gpt4,
+        "openai_disable_system_prompt": True,
+        "openai_disable_stream": True,
+        "openai_force_temperature_one": True,
+    },
+
+    "o1": {
+        "fn_with_ui": chatgpt_ui,
+        "fn_without_ui": chatgpt_noui,
+        "endpoint": openai_endpoint,
+        "max_token": 200000,
+        "tokenizer": tokenizer_gpt4,
+        "token_cnt": get_token_num_gpt4,
+        "openai_disable_system_prompt": True,
+        "openai_disable_stream": True,
+        "openai_force_temperature_one": True,
    },

    "gpt-4-turbo": {
@@ -785,7 +812,8 @@ if "qwen-local" in AVAIL_LLM_MODELS:
    except:
        logger.error(trimmed_format_exc())
 # -=-=-=-=-=-=- 通义-在线模型 -=-=-=-=-=-=-
-if "qwen-turbo" in AVAIL_LLM_MODELS or "qwen-plus" in AVAIL_LLM_MODELS or "qwen-max" in AVAIL_LLM_MODELS:   # zhipuai
+qwen_models = ["qwen-max-latest", "qwen-max-2025-01-25","qwen-max","qwen-turbo","qwen-plus"]
+if any(item in qwen_models for item in AVAIL_LLM_MODELS):
    try:
        from .bridge_qwen import predict_no_ui_long_connection as qwen_noui
        from .bridge_qwen import predict as qwen_ui
@@ -795,7 +823,7 @@ if "qwen-turbo" in AVAIL_LLM_MODELS or "qwen-plus" in AVAIL_LLM_MODELS or "qwen-
                "fn_without_ui": qwen_noui,
                "can_multi_thread": True,
                "endpoint": None,
-                "max_token": 6144,
+                "max_token": 100000,
                "tokenizer": tokenizer_gpt35,
                "token_cnt": get_token_num_gpt35,
            },
@@ -804,7 +832,7 @@ if "qwen-turbo" in AVAIL_LLM_MODELS or "qwen-plus" in AVAIL_LLM_MODELS or "qwen-
                "fn_without_ui": qwen_noui,
                "can_multi_thread": True,
                "endpoint": None,
-                "max_token": 30720,
+                "max_token": 129024,
                "tokenizer": tokenizer_gpt35,
                "token_cnt": get_token_num_gpt35,
            },
@@ -813,7 +841,25 @@ if "qwen-turbo" in AVAIL_LLM_MODELS or "qwen-plus" in AVAIL_LLM_MODELS or "qwen-
                "fn_without_ui": qwen_noui,
                "can_multi_thread": True,
                "endpoint": None,
-                "max_token": 28672,
+                "max_token": 30720,
+                "tokenizer": tokenizer_gpt35,
+                "token_cnt": get_token_num_gpt35,
+            },
+            "qwen-max-latest": {
+                "fn_with_ui": qwen_ui,
+                "fn_without_ui": qwen_noui,
+                "can_multi_thread": True,
+                "endpoint": None,
+                "max_token": 30720,
+                "tokenizer": tokenizer_gpt35,
+                "token_cnt": get_token_num_gpt35,
+            },
+            "qwen-max-2025-01-25": {
+                "fn_with_ui": qwen_ui,
+                "fn_without_ui": qwen_noui,
+                "can_multi_thread": True,
+                "endpoint": None,
+                "max_token": 30720,
                "tokenizer": tokenizer_gpt35,
                "token_cnt": get_token_num_gpt35,
            }
@@ -1044,18 +1090,18 @@ if "deepseekcoder" in AVAIL_LLM_MODELS:   # deepseekcoder
    except:
        logger.error(trimmed_format_exc())
 # -=-=-=-=-=-=- 幻方-深度求索大模型在线API -=-=-=-=-=-=-
-if "deepseek-chat" in AVAIL_LLM_MODELS or "deepseek-coder" in AVAIL_LLM_MODELS:
+if "deepseek-chat" in AVAIL_LLM_MODELS or "deepseek-coder" in AVAIL_LLM_MODELS or "deepseek-reasoner" in AVAIL_LLM_MODELS:
    try:
        deepseekapi_noui, deepseekapi_ui = get_predict_function(
            api_key_conf_name="DEEPSEEK_API_KEY", max_output_token=4096, disable_proxy=False
-            )
+        )
        model_info.update({
            "deepseek-chat":{
                "fn_with_ui": deepseekapi_ui,
                "fn_without_ui": deepseekapi_noui,
                "endpoint": deepseekapi_endpoint,
                "can_multi_thread": True,
-                "max_token": 32000,
+                "max_token": 64000,
                "tokenizer": tokenizer_gpt35,
                "token_cnt": get_token_num_gpt35,
            },
@@ -1068,6 +1114,16 @@ if "deepseek-chat" in AVAIL_LLM_MODELS or "deepseek-coder" in AVAIL_LLM_MODELS:
                "tokenizer": tokenizer_gpt35,
                "token_cnt": get_token_num_gpt35,
            },
+            "deepseek-reasoner":{
+                "fn_with_ui": deepseekapi_ui,
+                "fn_without_ui": deepseekapi_noui,
+                "endpoint": deepseekapi_endpoint,
+                "can_multi_thread": True,
+                "max_token": 64000,
+                "tokenizer": tokenizer_gpt35,
+                "token_cnt": get_token_num_gpt35,
+                "enable_reasoning": True
+            },
        })
    except:
        logger.error(trimmed_format_exc())
@@ -1335,6 +1391,11 @@ def predict(inputs:str, llm_kwargs:dict, plugin_kwargs:dict, chatbot,

    inputs = apply_gpt_academic_string_mask(inputs, mode="show_llm")

+    if llm_kwargs['llm_model'] not in model_info:
+        from toolbox import update_ui
+        chatbot.append([inputs, f"很抱歉，模型 '{llm_kwargs['llm_model']}' 暂不支持<br/>(1) 检查config中的AVAIL_LLM_MODELS选项<br/>(2) 检查request_llms/bridge_all.py中的模型路由"])
+        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
+
    method = model_info[llm_kwargs['llm_model']]["fn_with_ui"]  # 如果这里报错，检查config中的AVAIL_LLM_MODELS选项

    if additional_fn: # 根据基础功能区 ModelOverride 参数调整模型类型
--- a/request_llms/bridge_chatgpt.py
+++ b/request_llms/bridge_chatgpt.py
@@ -23,8 +23,13 @@ from loguru import logger
 from toolbox import get_conf, update_ui, is_any_api_key, select_api_key, what_keys, clip_history
 from toolbox import trimmed_format_exc, is_the_upload_folder, read_one_api_model_name, log_chat
 from toolbox import ChatBotWithCookies, have_any_recent_upload_image_files, encode_image
-proxies, TIMEOUT_SECONDS, MAX_RETRY, API_ORG, AZURE_CFG_ARRAY = \
-    get_conf('proxies', 'TIMEOUT_SECONDS', 'MAX_RETRY', 'API_ORG', 'AZURE_CFG_ARRAY')
+proxies, WHEN_TO_USE_PROXY, TIMEOUT_SECONDS, MAX_RETRY, API_ORG, AZURE_CFG_ARRAY = \
+    get_conf('proxies', 'WHEN_TO_USE_PROXY', 'TIMEOUT_SECONDS', 'MAX_RETRY', 'API_ORG', 'AZURE_CFG_ARRAY')
+
+if "Connect_OpenAI" not in WHEN_TO_USE_PROXY:
+    if proxies is not None:
+        logger.error("虽然您配置了代理设置，但不会在连接OpenAI的过程中起作用，请检查WHEN_TO_USE_PROXY配置。")
+        proxies = None

 timeout_bot_msg = '[Local Message] Request timeout. Network error. Please check proxy settings in config.py.' + \
                  '网络错误，检查代理服务器是否可用，以及代理设置的格式是否正确，格式须是[协议]://[地址]:[端口]，缺一不可。'
@@ -180,14 +185,20 @@ def predict_no_ui_long_connection(inputs:str, llm_kwargs:dict, history:list=[],
                raise ConnectionAbortedError("正常结束，但显示Token不足，导致输出不完整，请削减单次输入的文本量。")
            else:
                raise RuntimeError("OpenAI拒绝了请求：" + error_msg)
-        if ('data: [DONE]' in chunk_decoded): break # api2d 正常完成
+        if ('data: [DONE]' in chunk_decoded): break # api2d & one-api 正常完成
        # 提前读取一些信息 （用于判断异常）
        if has_choices and not choice_valid:
            # 一些垃圾第三方接口的出现这样的错误
            continue
        json_data = chunkjson['choices'][0]
        delta = json_data["delta"]
-        if len(delta) == 0: break
+
+        if len(delta) == 0:
+            is_termination_certain = False
+            if (has_choices) and (chunkjson['choices'][0].get('finish_reason', 'null') == 'stop'): is_termination_certain = True
+            if is_termination_certain: break
+            else: continue # 对于不符合规范的狗屎接口，这里需要继续
+
        if (not has_content) and has_role: continue
        if (not has_content) and (not has_role): continue # raise RuntimeError("发现不标准的第三方接口："+delta)
        if has_content: # has_role = True/False
@@ -285,6 +296,8 @@ def predict(inputs:str, llm_kwargs:dict, plugin_kwargs:dict, chatbot:ChatBotWith
        history.extend([inputs, ""])

    retry = 0
+    previous_ui_reflesh_time = 0
+    ui_reflesh_min_interval = 0.0
    while True:
        try:
            # make a POST request to the API endpoint, stream=True
@@ -297,13 +310,13 @@ def predict(inputs:str, llm_kwargs:dict, plugin_kwargs:dict, chatbot:ChatBotWith
            yield from update_ui(chatbot=chatbot, history=history, msg="请求超时"+retry_msg) # 刷新界面
            if retry > MAX_RETRY: raise TimeoutError

-
    if not stream:
        # 该分支仅适用于不支持stream的o1模型，其他情形一律不适用
        yield from handle_o1_model_special(response, inputs, llm_kwargs, chatbot, history)
        return

    if stream:
+        reach_termination = False   # 处理一些 new-api 的奇葩异常
        gpt_replying_buffer = ""
        is_head_of_the_stream = True
        stream_response =  response.iter_lines()
@@ -316,11 +329,14 @@ def predict(inputs:str, llm_kwargs:dict, plugin_kwargs:dict, chatbot:ChatBotWith
                error_msg = chunk_decoded
                # 首先排除一个one-api没有done数据包的第三方Bug情形
                if len(gpt_replying_buffer.strip()) > 0 and len(error_msg) == 0:
-                    yield from update_ui(chatbot=chatbot, history=history, msg="检测到有缺陷的非OpenAI官方接口，建议选择更稳定的接口。")
+                    yield from update_ui(chatbot=chatbot, history=history, msg="检测到有缺陷的接口，建议选择更稳定的接口。")
+                    if not reach_termination:
+                        reach_termination = True
+                        log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=gpt_replying_buffer)
                    break
                # 其他情况，直接返回报错
                chatbot, history = handle_error(inputs, llm_kwargs, chatbot, history, chunk_decoded, error_msg)
-                yield from update_ui(chatbot=chatbot, history=history, msg="非OpenAI官方接口返回了错误:" + chunk.decode()) # 刷新界面
+                yield from update_ui(chatbot=chatbot, history=history, msg="接口返回了错误:" + chunk.decode()) # 刷新界面
                return

            # 提前读取一些信息 （用于判断异常）
@@ -330,6 +346,8 @@ def predict(inputs:str, llm_kwargs:dict, plugin_kwargs:dict, chatbot:ChatBotWith
                # 数据流的第一帧不携带content
                is_head_of_the_stream = False; continue

+            if "error" in chunk_decoded: logger.error(f"接口返回了未知错误: {chunk_decoded}")
+
            if chunk:
                try:
                    if has_choices and not choice_valid:
@@ -338,14 +356,25 @@ def predict(inputs:str, llm_kwargs:dict, plugin_kwargs:dict, chatbot:ChatBotWith
                    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也写完了
-                        log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=gpt_replying_buffer)
-                        break
+                    # 前者是API2D & One-API的结束条件，后者是OPENAI的结束条件
+                    one_api_terminate = ('data: [DONE]' in chunk_decoded)
+                    openai_terminate = (has_choices) and (len(chunkjson['choices'][0]["delta"]) == 0)
+                    if one_api_terminate or openai_terminate:
+                        is_termination_certain = False
+                        if one_api_terminate: is_termination_certain = True # 抓取符合规范的结束条件
+                        elif (has_choices) and (chunkjson['choices'][0].get('finish_reason', 'null') == 'stop'): is_termination_certain = True # 抓取符合规范的结束条件
+                        if is_termination_certain:
+                            reach_termination = True
+                            log_chat(llm_model=llm_kwargs["llm_model"], input_str=inputs, output_str=gpt_replying_buffer)
+                            break # 对于符合规范的接口，这里可以break
+                        else:
+                            continue # 对于不符合规范的狗屎接口，这里需要继续
+                    # 到这里，我们已经可以假定必须包含choice了
+                    try:
+                        status_text = f"finish_reason: {chunkjson['choices'][0].get('finish_reason', 'null')}"
+                    except:
+                        logger.error(f"一些垃圾第三方接口出现这样的错误，兼容一下吧: {chunk_decoded}")
                    # 处理数据流的主体
-                    status_text = f"finish_reason: {chunkjson['choices'][0].get('finish_reason', 'null')}"
-                    # 如果这里抛出异常，一般是文本过长，详情见get_full_error的输出
                    if has_content:
                        # 正常情况
                        gpt_replying_buffer = gpt_replying_buffer + chunkjson['choices'][0]["delta"]["content"]
@@ -354,21 +383,26 @@ def predict(inputs:str, llm_kwargs:dict, plugin_kwargs:dict, chatbot:ChatBotWith
                        continue
                    else:
                        # 至此已经超出了正常接口应该进入的范围，一些垃圾第三方接口会出现这样的错误
-                        if chunkjson['choices'][0]["delta"]["content"] is None: continue # 一些垃圾第三方接口出现这样的错误，兼容一下吧
+                        if chunkjson['choices'][0]["delta"].get("content", None) is None:
+                            logger.error(f"一些垃圾第三方接口出现这样的错误，兼容一下吧: {chunk_decoded}")
+                            continue
                        gpt_replying_buffer = gpt_replying_buffer + chunkjson['choices'][0]["delta"]["content"]

                    history[-1] = gpt_replying_buffer
                    chatbot[-1] = (history[-2], history[-1])
-                    yield from update_ui(chatbot=chatbot, history=history, msg=status_text) # 刷新界面
+                    if time.time() - previous_ui_reflesh_time > ui_reflesh_min_interval:
+                        yield from update_ui(chatbot=chatbot, history=history, msg=status_text) # 刷新界面
+                        previous_ui_reflesh_time = time.time()
                except Exception as e:
                    yield from update_ui(chatbot=chatbot, history=history, msg="Json解析不合常规") # 刷新界面
                    chunk = get_full_error(chunk, stream_response)
                    chunk_decoded = chunk.decode()
                    error_msg = chunk_decoded
                    chatbot, history = handle_error(inputs, llm_kwargs, chatbot, history, chunk_decoded, error_msg)
-                    yield from update_ui(chatbot=chatbot, history=history, msg="Json解析异常" + error_msg) # 刷新界面
                    logger.error(error_msg)
+                    yield from update_ui(chatbot=chatbot, history=history, msg="Json解析异常" + error_msg) # 刷新界面
                    return
+        yield from update_ui(chatbot=chatbot, history=history, msg="完成") # 刷新界面
        return  # return from stream-branch

 def handle_o1_model_special(response, inputs, llm_kwargs, chatbot, history):
@@ -536,6 +570,8 @@ def generate_payload(inputs:str, llm_kwargs:dict, history:list, system_prompt:st
        "n": 1,
        "stream": stream,
    }
-
+    openai_force_temperature_one = model_info[llm_kwargs['llm_model']].get('openai_force_temperature_one', False)
+    if openai_force_temperature_one:
+        payload.pop('temperature')
    return headers,payload

--- a/request_llms/bridge_openrouter.py
+++ b/request_llms/bridge_openrouter.py
@@ -170,7 +170,7 @@ def predict_no_ui_long_connection(inputs:str, llm_kwargs:dict, history:list=[],
        except requests.exceptions.ConnectionError:
            chunk = next(stream_response) # 失败了，重试一次？再失败就没办法了。
        chunk_decoded, chunkjson, has_choices, choice_valid, has_content, has_role = decode_chunk(chunk)
-        if len(chunk_decoded)==0: continue
+        if len(chunk_decoded)==0 or chunk_decoded.startswith(':'): continue
        if not chunk_decoded.startswith('data:'):
            error_msg = get_full_error(chunk, stream_response).decode()
            if "reduce the length" in error_msg:
@@ -181,9 +181,6 @@ def predict_no_ui_long_connection(inputs:str, llm_kwargs:dict, history:list=[],
                raise RuntimeError("OpenAI拒绝了请求：" + error_msg)
        if ('data: [DONE]' in chunk_decoded): break # api2d 正常完成
        # 提前读取一些信息 （用于判断异常）
-        if (has_choices and not choice_valid) or ('OPENROUTER PROCESSING' in chunk_decoded):
-            # 一些垃圾第三方接口的出现这样的错误，openrouter的特殊处理
-            continue
        json_data = chunkjson['choices'][0]
        delta = json_data["delta"]
        if len(delta) == 0: break
@@ -328,8 +325,7 @@ def predict(inputs:str, llm_kwargs:dict, plugin_kwargs:dict, chatbot:ChatBotWith

            if chunk:
                try:
-                    if (has_choices and not choice_valid) or ('OPENROUTER PROCESSING' in chunk_decoded):
-                        # 一些垃圾第三方接口的出现这样的错误, 或者OPENROUTER的特殊处理,因为OPENROUTER的数据流未连接到模型时会出现OPENROUTER PROCESSING
+                    if (has_choices and not choice_valid) or chunk_decoded.startswith(':'):
                        continue
                    if ('data: [DONE]' not in chunk_decoded) and len(chunk_decoded) > 0 and (chunkjson is None):
                        # 传递进来一些奇怪的东西
--- a/request_llms/com_google.py
+++ b/request_llms/com_google.py
@@ -202,16 +202,29 @@ class GoogleChatInit:
            )  # 处理 history
            
        messages.append(self.__conversation_user(inputs, llm_kwargs, enable_multimodal_capacity))  # 处理用户对话
-        payload = {
-            "contents": messages,
-            "generationConfig": {
-                # "maxOutputTokens": llm_kwargs.get("max_token", 1024),
-                "stopSequences": str(llm_kwargs.get("stop", "")).split(" "),
-                "temperature": llm_kwargs.get("temperature", 1),
-                "topP": llm_kwargs.get("top_p", 0.8),
-                "topK": 10,
-            },
-        }
+        stop_sequences = str(llm_kwargs.get("stop", "")).split(" ")
+        # 过滤空字符串并确保至少有一个停止序列
+        stop_sequences = [s for s in stop_sequences if s]
+        if not stop_sequences:
+            payload = {
+                "contents": messages,
+                "generationConfig": {
+                    "temperature": llm_kwargs.get("temperature", 1),
+                    "topP": llm_kwargs.get("top_p", 0.8),
+                    "topK": 10,
+                },
+            }
+        else:
+            payload = {
+                "contents": messages,
+                "generationConfig": {
+                    # "maxOutputTokens": llm_kwargs.get("max_token", 1024),
+                    "stopSequences": stop_sequences,
+                    "temperature": llm_kwargs.get("temperature", 1),
+                    "topP": llm_kwargs.get("top_p", 0.8),
+                    "topK": 10,
+                },
+            }

        return header, payload

--- a/request_llms/com_qwenapi.py
+++ b/request_llms/com_qwenapi.py
@@ -24,18 +24,13 @@ class QwenRequestInstance():
    def generate(self, inputs, llm_kwargs, history, system_prompt):
        # import _thread as thread
        from dashscope import Generation
-        QWEN_MODEL = {
-            'qwen-turbo': Generation.Models.qwen_turbo,
-            'qwen-plus': Generation.Models.qwen_plus,
-            'qwen-max': Generation.Models.qwen_max,
-        }[llm_kwargs['llm_model']]
        top_p = llm_kwargs.get('top_p', 0.8)
        if top_p == 0: top_p += 1e-5
        if top_p == 1: top_p -= 1e-5

        self.result_buf = ""
        responses = Generation.call(
-            model=QWEN_MODEL,
+            model=llm_kwargs['llm_model'],
            messages=generate_message_payload(inputs, llm_kwargs, history, system_prompt),
            top_p=top_p,
            temperature=llm_kwargs.get('temperature', 1.0),
--- a/request_llms/oai_std_model_template.py
+++ b/request_llms/oai_std_model_template.py
@@ -36,10 +36,11 @@ def get_full_error(chunk, stream_response):

 def decode_chunk(chunk):
    """
-    用于解读"content"和"finish_reason"的内容
+    用于解读"content"和"finish_reason"的内容（如果支持思维链也会返回"reasoning_content"内容）
    """
    chunk = chunk.decode()
    respose = ""
+    reasoning_content = ""
    finish_reason = "False"
    try:
        chunk = json.loads(chunk[6:])
@@ -57,14 +58,20 @@ def decode_chunk(chunk):
        return respose, finish_reason

    try:
-        respose = chunk["choices"][0]["delta"]["content"]
+        if chunk["choices"][0]["delta"]["content"] is not None:
+            respose = chunk["choices"][0]["delta"]["content"]
+    except:
+        pass
+    try:
+        if chunk["choices"][0]["delta"]["reasoning_content"] is not None:
+            reasoning_content = chunk["choices"][0]["delta"]["reasoning_content"]
    except:
        pass
    try:
        finish_reason = chunk["choices"][0]["finish_reason"]
    except:
        pass
-    return respose, finish_reason
+    return respose, reasoning_content, finish_reason


 def generate_message(input, model, key, history, max_output_token, system_prompt, temperature):
@@ -149,6 +156,7 @@ def get_predict_function(
        observe_window = None：
            用于负责跨越线程传递已经输出的部分，大部分时候仅仅为了fancy的视觉效果，留空即可。observe_window[0]：观测窗。observe_window[1]：看门狗
        """
+        from .bridge_all import model_info
        watch_dog_patience = 5  # 看门狗的耐心，设置5秒不准咬人(咬的也不是人
        if len(APIKEY) == 0:
            raise RuntimeError(f"APIKEY为空,请检查配置文件的{APIKEY}")
@@ -163,29 +171,21 @@ def get_predict_function(
            system_prompt=sys_prompt,
            temperature=llm_kwargs["temperature"],
        )
+
+        reasoning = model_info[llm_kwargs['llm_model']].get('enable_reasoning', False)
+
        retry = 0
        while True:
            try:
-                from .bridge_all import model_info
-
                endpoint = model_info[llm_kwargs["llm_model"]]["endpoint"]
-                if not disable_proxy:
-                    response = requests.post(
-                        endpoint,
-                        headers=headers,
-                        proxies=proxies,
-                        json=playload,
-                        stream=True,
-                        timeout=TIMEOUT_SECONDS,
-                    )
-                else:
-                    response = requests.post(
-                        endpoint,
-                        headers=headers,
-                        json=playload,
-                        stream=True,
-                        timeout=TIMEOUT_SECONDS,
-                    )
+                response = requests.post(
+                    endpoint,
+                    headers=headers,
+                    proxies=None if disable_proxy else proxies,
+                    json=playload,
+                    stream=True,
+                    timeout=TIMEOUT_SECONDS,
+                )
                break
            except:
                retry += 1
@@ -194,10 +194,13 @@ def get_predict_function(
                    raise TimeoutError
                if MAX_RETRY != 0:
                    logger.error(f"请求超时，正在重试 ({retry}/{MAX_RETRY}) ……")
-
-        stream_response = response.iter_lines()
+        
        result = ""
        finish_reason = ""
+        if reasoning:
+            resoning_buffer = ""
+        
+        stream_response = response.iter_lines()
        while True:
            try:
                chunk = next(stream_response)
@@ -207,9 +210,9 @@ def get_predict_function(
                break
            except requests.exceptions.ConnectionError:
                chunk = next(stream_response)  # 失败了，重试一次？再失败就没办法了。
-            response_text, finish_reason = decode_chunk(chunk)
+            response_text, reasoning_content, finish_reason = decode_chunk(chunk)
            # 返回的数据流第一次为空，继续等待
-            if response_text == "" and finish_reason != "False":
+            if response_text == "" and (reasoning == False or reasoning_content == "") and finish_reason != "False":
                continue
            if response_text == "API_ERROR" and (
                finish_reason != "False" or finish_reason != "stop"
@@ -227,6 +230,8 @@ def get_predict_function(
                            print(f"[response] {result}")
                        break
                    result += response_text
+                    if reasoning:
+                        resoning_buffer += reasoning_content
                    if observe_window is not None:
                        # 观测窗，把已经获取的数据显示出去
                        if len(observe_window) >= 1:
@@ -241,6 +246,10 @@ def get_predict_function(
                    error_msg = chunk_decoded
                    logger.error(error_msg)
                    raise RuntimeError("Json解析不合常规")
+        if reasoning:
+            # reasoning 的部分加上框 (>)
+            return '\n'.join(map(lambda x: '> ' + x, resoning_buffer.split('\n'))) + \
+                   '\n\n' + result
        return result

    def predict(
@@ -262,6 +271,7 @@ def get_predict_function(
        chatbot 为WebUI中显示的对话列表，修改它，然后yeild出去，可以直接修改对话界面内容
        additional_fn代表点击的哪个按钮，按钮见functional.py
        """
+        from .bridge_all import model_info
        if len(APIKEY) == 0:
            raise RuntimeError(f"APIKEY为空,请检查配置文件的{APIKEY}")
        if inputs == "":
@@ -298,32 +308,23 @@ def get_predict_function(
            system_prompt=system_prompt,
            temperature=llm_kwargs["temperature"],
        )
+        
+        reasoning = model_info[llm_kwargs['llm_model']].get('enable_reasoning', False)

        history.append(inputs)
        history.append("")
        retry = 0
        while True:
            try:
-                from .bridge_all import model_info
-
                endpoint = model_info[llm_kwargs["llm_model"]]["endpoint"]
-                if not disable_proxy:
-                    response = requests.post(
-                        endpoint,
-                        headers=headers,
-                        proxies=proxies,
-                        json=playload,
-                        stream=True,
-                        timeout=TIMEOUT_SECONDS,
-                    )
-                else:
-                    response = requests.post(
-                        endpoint,
-                        headers=headers,
-                        json=playload,
-                        stream=True,
-                        timeout=TIMEOUT_SECONDS,
-                    )
+                response = requests.post(
+                    endpoint,
+                    headers=headers,
+                    proxies=None if disable_proxy else proxies,
+                    json=playload,
+                    stream=True,
+                    timeout=TIMEOUT_SECONDS,
+                )
                break
            except:
                retry += 1
@@ -338,6 +339,8 @@ def get_predict_function(
                    raise TimeoutError

        gpt_replying_buffer = ""
+        if reasoning:
+            gpt_reasoning_buffer = ""

        stream_response = response.iter_lines()
        while True:
@@ -347,9 +350,9 @@ def get_predict_function(
                break
            except requests.exceptions.ConnectionError:
                chunk = next(stream_response)  # 失败了，重试一次？再失败就没办法了。
-            response_text, finish_reason = decode_chunk(chunk)
+            response_text, reasoning_content, finish_reason = decode_chunk(chunk)
            # 返回的数据流第一次为空，继续等待
-            if response_text == "" and finish_reason != "False":
+            if response_text == "" and (reasoning == False or reasoning_content == "") and finish_reason != "False":
                status_text = f"finish_reason: {finish_reason}"
                yield from update_ui(
                    chatbot=chatbot, history=history, msg=status_text
@@ -379,9 +382,14 @@ def get_predict_function(
                        logger.info(f"[response] {gpt_replying_buffer}")
                        break
                    status_text = f"finish_reason: {finish_reason}"
-                    gpt_replying_buffer += response_text
-                    # 如果这里抛出异常，一般是文本过长，详情见get_full_error的输出
-                    history[-1] = gpt_replying_buffer
+                    if reasoning:
+                        gpt_replying_buffer += response_text
+                        gpt_reasoning_buffer += reasoning_content
+                        history[-1] = '\n'.join(map(lambda x: '> ' + x, gpt_reasoning_buffer.split('\n'))) + '\n\n' + gpt_replying_buffer
+                    else:
+                        gpt_replying_buffer += response_text
+                        # 如果这里抛出异常，一般是文本过长，详情见get_full_error的输出
+                        history[-1] = gpt_replying_buffer
                    chatbot[-1] = (history[-2], history[-1])
                    yield from update_ui(
                        chatbot=chatbot, history=history, msg=status_text
--- a/requirements.txt
+++ b/requirements.txt
@@ -13,7 +13,7 @@ scipdf_parser>=0.52
 spacy==3.7.4
 anthropic>=0.18.1
 python-markdown-math
-pymdown-extensions
+pymdown-extensions>=10.14
 websocket-client
 beautifulsoup4
 prompt_toolkit
--- a/shared_utils/advanced_markdown_format.py
+++ b/shared_utils/advanced_markdown_format.py
@@ -2,6 +2,7 @@ import markdown
 import re
 import os
 import math
+import html

 from loguru import logger
 from textwrap import dedent
@@ -384,6 +385,24 @@ def markdown_convertion(txt):
        )


+def code_block_title_replace_format(match):
+    lang = match.group(1)
+    filename = match.group(2)
+    return f"```{lang} {{title=\"{filename}\"}}\n"
+
+
+def get_last_backticks_indent(text):
+    # 从后向前查找最后一个 ``` 
+    lines = text.splitlines()
+    for line in reversed(lines):
+        if '```' in line:
+            # 计算前面的空格数量
+            indent = len(line) - len(line.lstrip())
+            return indent
+    return 0 # 如果没找到返回0
+
+
+@lru_cache(maxsize=16)  # 使用lru缓存
 def close_up_code_segment_during_stream(gpt_reply):
    """
    在gpt输出代码的中途（输出了前面的```，但还没输出完后面的```），补上后面的```
@@ -397,6 +416,12 @@ def close_up_code_segment_during_stream(gpt_reply):
    """
    if "```" not in gpt_reply:
        return gpt_reply
+
+    # replace [```python:warp.py] to [```python {title="warp.py"}]
+    pattern = re.compile(r"```([a-z]{1,12}):([^:\n]{1,35}\.([a-zA-Z^:\n]{1,3}))\n")
+    if pattern.search(gpt_reply):
+        gpt_reply = pattern.sub(code_block_title_replace_format, gpt_reply)
+
    if gpt_reply.endswith("```"):
        return gpt_reply

@@ -404,7 +429,11 @@ def close_up_code_segment_during_stream(gpt_reply):
    segments = gpt_reply.split("```")
    n_mark = len(segments) - 1
    if n_mark % 2 == 1:
-        return gpt_reply + "\n```"  # 输出代码片段中！
+        try:
+            num_padding = get_last_backticks_indent(gpt_reply)
+        except:
+            num_padding = 0
+        return gpt_reply + "\n" + " "*num_padding + "```"  # 输出代码片段中！
    else:
        return gpt_reply

@@ -421,6 +450,19 @@ def special_render_issues_for_mermaid(text):
    return text


+def contain_html_tag(text):
+    """
+    判断文本中是否包含HTML标签。
+    """
+    pattern = r'</?([a-zA-Z0-9_]{3,16})>|<script\s+[^>]*src=["\']([^"\']+)["\'][^>]*>'
+    return re.search(pattern, text) is not None
+
+
+def contain_image(text):
+    pattern = r'<br/><br/><div align="center"><img src="file=(.*?)" base64="(.*?)"></div>'
+    return re.search(pattern, text) is not None
+
+
 def compat_non_markdown_input(text):
    """
    改善非markdown输入的显示效果，例如将空格转换为&nbsp;，将换行符转换为</br>等。
@@ -429,9 +471,13 @@ def compat_non_markdown_input(text):
        # careful input：markdown输入
        text = special_render_issues_for_mermaid(text)  # 处理特殊的渲染问题
        return text
-    elif "</div>" in text:
+    elif ("<" in text) and (">" in text) and contain_html_tag(text):
        # careful input：html输入
-        return text
+        if contain_image(text):
+            return text
+        else:
+            escaped_text = html.escape(text)
+            return escaped_text
    else:
        # whatever input：非markdown输入
        lines = text.split("\n")
--- a/shared_utils/key_pattern_manager.py
+++ b/shared_utils/key_pattern_manager.py
@@ -45,6 +45,13 @@ def is_cohere_api_key(key):


 def is_any_api_key(key):
+    # key 一般只包含字母、数字、下划线、逗号、中划线
+    if not re.match(r"^[a-zA-Z0-9_\-,]+$", key):
+        # 如果配置了 CUSTOM_API_KEY_PATTERN，再检查以下以免误杀
+        if CUSTOM_API_KEY_PATTERN := get_conf('CUSTOM_API_KEY_PATTERN'):
+            return bool(re.match(CUSTOM_API_KEY_PATTERN, key))
+        return False
+
    if ',' in key:
        keys = key.split(',')
        for k in keys:
@@ -79,7 +86,7 @@ def select_api_key(keys, llm_model):
    key_list = keys.split(',')

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

--- a/start.sh
+++ b/start.sh
@@ -0,0 +1,11 @@
+#!/bin/bash
+GPT_COMMAND="/home/van/.env/python3.12-venv/bin/python main.py"
+LOG_FILE="/home/van/project/gpt/gpt.log"
+GPT_PROCESS=$(ps aux | grep "$/home/van/.env/python3.12-venv/bin/python main.py" | grep -v grep)
+if [ -n "$GPT_PROCESS" ]; then
+echo "gpt is running..."
+else
+cd /home/van/project/gpt/
+$GPT_COMMAND > "$LOG_FILE" 2>&1 &
+echo "gpt start successfully. Log file: $LOG_FILE"
+fi
--- a/tests/test_markdown.py
+++ b/tests/test_markdown.py
@@ -20,7 +20,7 @@ Replace 'Tex/' with the actual directory path where your files are located befor
 md = """
 Following code including wrapper

-```mermaid
+```python:wrapper.py
 graph TD
    A[Enter Chart Definition] --> B(Preview)
    B --> C{decide}
@@ -41,6 +41,33 @@ Any folded content here. It requires an empty line just above it.

 </details>

+"""
+
+md ="""
+
+在这种场景中，您希望机器 B 能够通过轮询机制来间接地“请求”机器 A，而实际上机器 A 只能主动向机器 B 发出请求。这是一种典型的客户端-服务器轮询模式。下面是如何实现这种机制的详细步骤：
+
+### 机器 B 的实现
+
+1. **安装 FastAPI 和必要的依赖库**：
+   ```bash
+   pip install fastapi uvicorn
+   ```
+
+2. **创建 FastAPI 服务**：
+   ```python
+   from fastapi import FastAPI
+   from fastapi.responses import JSONResponse
+   from uuid import uuid4
+   from threading import Lock
+   import time
+
+   app = FastAPI()
+
+   # 字典用于存储请求和状态
+   requests = {}
+   process_lock = Lock()
+
 """
 def validate_path():
    import os, sys
@@ -53,10 +80,12 @@ def validate_path():

 validate_path()  # validate path so you can run from base directory
 from toolbox import markdown_convertion
-from shared_utils.advanced_markdown_format import markdown_convertion_for_file
+# from shared_utils.advanced_markdown_format import markdown_convertion_for_file
+from shared_utils.advanced_markdown_format import close_up_code_segment_during_stream
 # with open("gpt_log/default_user/shared/2024-04-22-01-27-43.zip.extract/translated_markdown.md", "r", encoding="utf-8") as f:
    # md = f.read()
-html = markdown_convertion_for_file(md)
+md = close_up_code_segment_during_stream(md)
+html = markdown_convertion(md)
 # print(html)
 with open("test.html", "w", encoding="utf-8") as f:
    f.write(html)
--- a/themes/common.css
+++ b/themes/common.css
@@ -1,9 +1,16 @@
+:root {
+    --gpt-academic-message-font-size: 15px;
+}
+
+.message {
+    font-size: var(--gpt-academic-message-font-size) !important;
+}
+
 #plugin_arg_menu {
    transform: translate(-50%, -50%);
    border: dashed;
 }

-
 /* hide remove all button */
 .remove-all.svelte-aqlk7e.svelte-aqlk7e.svelte-aqlk7e {
    visibility: hidden;
@@ -25,7 +32,6 @@
    visibility: hidden;
 }

-
 /* height of the upload box */
 .wrap.svelte-xwlu1w {
    min-height: var(--size-32);
@@ -97,13 +103,9 @@
    min-width: min(80px, 100%);
 }

-
-#cbs {
-    background-color: var(--block-background-fill) !important;
-}
-
+#cbs,
 #cbsc {
-    background-color: var(--block-background-fill) !important;
+    background-color: rgba(var(--block-background-fill), 0.5) !important;
 }

 #interact-panel .form {
@@ -155,7 +157,7 @@
    transform: translate(-50%, -50%);
    flex-wrap: wrap;
    justify-content: center;
-    transition: opacity 1s ease-in-out;
+    transition: opacity 0.6s ease-in-out;
    opacity: 0;
 }
 .welcome-card-container.show {
@@ -207,6 +209,7 @@
 .welcome-content {
    text-wrap: balance;
    height: 55px;
+    font-size: 13px;
    display: flex;
    align-items: center;
 }
@@ -275,4 +278,36 @@
 .tooltip.svelte-p2nen8.svelte-p2nen8 {
    box-shadow: 10px 10px 15px rgba(0, 0, 0, 0.5);
    left: 10px;
-}
+}
+
+#tooltip .hidden {
+    /* display: none; */
+    opacity: 0;
+    transition: opacity 0.5s ease;
+}
+
+#tooltip .visible {
+    /* display: block; */
+    opacity: 1;
+    transition: opacity 0.5s ease;
+}
+
+#elem_fontsize,
+#elem_top_p,
+#elem_temperature,
+#elem_max_length_sl,
+#elem_prompt {
+    /* 左右为0；顶部为0，底部为2px */
+    padding: 0 0 4px 0;
+    backdrop-filter: blur(10px);
+    background-color: rgba(var(--block-background-fill), 0.5);
+}
+
+
+#tooltip #cbs,
+#tooltip #cbsc,
+#tooltip .svelte-b6y5bg,
+#tooltip .tabitem {
+    backdrop-filter: blur(10px);
+    background-color: rgba(var(--block-background-fill), 0.5);
+}
--- a/themes/common.js
+++ b/themes/common.js
@@ -392,7 +392,8 @@ function chatbotContentChanged(attempt = 1, force = false) {
                // Now pass both the message element and the is_last_in_arr boolean to addCopyButton
                addCopyButton(message, index, is_last_in_arr);

-                save_conversation_history();
+                // save_conversation_history
+                save_conversation_history_slow_down();
            });
            // gradioApp().querySelectorAll('#gpt-chatbot .message-wrap .message.bot').forEach(addCopyButton);
        }, i === 0 ? 0 : 200);
@@ -749,10 +750,24 @@ function minor_ui_adjustment() {
    var bar_btn_width = [];
    // 自动隐藏超出范围的toolbar按钮
    function auto_hide_toolbar() {
-        var qq = document.getElementById('tooltip');
-        var tab_nav = qq.getElementsByClassName('tab-nav');
+        // if chatbot hit upper page boarder, hide all
+        const elem_chatbot = document.getElementById('gpt-chatbot');
+        const chatbot_top = elem_chatbot.getBoundingClientRect().top;
+        var tooltip = document.getElementById('tooltip');
+        var tab_nav = tooltip.getElementsByClassName('tab-nav')[0];
+
+        // 20 px 大概是一个字的高度
+        if (chatbot_top < 20) {
+            // tab_nav.style.display = 'none';
+            if (tab_nav.classList.contains('visible')) {tab_nav.classList.remove('visible');}
+            if (!tab_nav.classList.contains('hidden')) {tab_nav.classList.add('hidden');}
+            return;
+        }
+        if (tab_nav.classList.contains('hidden')) {tab_nav.classList.remove('hidden');}
+        if (!tab_nav.classList.contains('visible')) {tab_nav.classList.add('visible');}
+        // tab_nav.style.display = '';
        if (tab_nav.length == 0) { return; }
-        var btn_list = tab_nav[0].getElementsByTagName('button')
+        var btn_list = tab_nav.getElementsByTagName('button')
        if (btn_list.length == 0) { return; }
        // 获取页面宽度
        var page_width = document.documentElement.clientWidth;
@@ -938,19 +953,36 @@ function gpt_academic_gradio_saveload(
    }
 }

+function generateUUID() {
+    // Generate a random number and convert it to a hexadecimal string
+    function randomHexDigit() {
+        return Math.floor((1 + Math.random()) * 0x10000).toString(16).slice(1);
+    }
+
+    // Construct the UUID using the randomHexDigit function
+    return (
+        randomHexDigit() + randomHexDigit() + '-' +
+        randomHexDigit() + '-' +
+        '4' + randomHexDigit().slice(0, 3) + '-' + // Version 4 UUID
+        ((Math.floor(Math.random() * 4) + 8).toString(16)) + randomHexDigit().slice(0, 3) + '-' +
+        randomHexDigit() + randomHexDigit() + randomHexDigit()
+    );
+}
+
 function update_conversation_metadata() {
    // Create a conversation UUID and timestamp
-    const conversationId = crypto.randomUUID();
-    const timestamp = new Date().toISOString();
-    const conversationData = {
-        id: conversationId,
-        timestamp: timestamp
-    };
-    // Save to cookie
-    setCookie("conversation_metadata", JSON.stringify(conversationData), 2);
-    // read from cookie
-    let conversation_metadata = getCookie("conversation_metadata");
-    // console.log("conversation_metadata", conversation_metadata);
+    try {
+        const conversationId = generateUUID();
+        console.log('Create conversation ID:', conversationId);
+        const timestamp = new Date().toISOString();
+        const conversationMetaData = {
+            id: conversationId,
+            timestamp: timestamp
+        };
+        localStorage.setItem("conversation_metadata", JSON.stringify(conversationMetaData));
+    } catch (e) {
+        console.error('Error in updating conversation metadata:', e);
+    }
 }


@@ -966,20 +998,26 @@ function generatePreview(conversation, timestamp, maxLength = 100) {
 }

 async function save_conversation_history() {
-    // 505030475
+
    let chatbot = await get_data_from_gradio_component('gpt-chatbot');
    let history = await get_data_from_gradio_component('history-ng');
-    let conversation_metadata = getCookie("conversation_metadata");
-    conversation_metadata = JSON.parse(conversation_metadata);
-    // console.log("conversation_metadata", conversation_metadata);
-    let conversation = {
-        timestamp: conversation_metadata.timestamp,
-        id: conversation_metadata.id,
-        metadata: conversation_metadata,
-        conversation: chatbot,
-        history: history,
-        preview: generatePreview(JSON.parse(history), conversation_metadata.timestamp)
-    };
+    let conversation = {};
+    let conversation_metadata = localStorage.getItem("conversation_metadata");
+    try {
+        conversation_metadata = JSON.parse(conversation_metadata);
+        conversation = {
+            timestamp: conversation_metadata.timestamp,
+            id: conversation_metadata.id,
+            metadata: conversation_metadata,
+            conversation: chatbot,
+            history: history,
+            preview: generatePreview(JSON.parse(history), conversation_metadata.timestamp)
+        };
+    } catch (e) {
+        // console.error('Conversation metadata parse error, recreate conversation metadata');
+        update_conversation_metadata();
+        return;
+    }

    // Get existing conversation history from local storage
    let conversation_history = [];
@@ -1010,6 +1048,13 @@ async function save_conversation_history() {
        return timeB - timeA;
    });

+    const max_chat_preserve = 10;
+
+    if (conversation_history.length >= max_chat_preserve + 1) {
+        toast_push('对话时间线记录已满，正在移除最早的对话记录。您也可以点击左侧的记录点进行手动清理。', 3000);
+        conversation_history = conversation_history.slice(0, max_chat_preserve);
+    }
+
    // Save back to local storage
    try {
        localStorage.setItem('conversation_history', JSON.stringify(conversation_history));
@@ -1024,61 +1069,35 @@ async function save_conversation_history() {
    }
 }

+save_conversation_history_slow_down = do_something_but_not_too_frequently(300, save_conversation_history);

 function restore_chat_from_local_storage(event) {
    let conversation = event.detail;
    push_data_to_gradio_component(conversation.conversation, "gpt-chatbot", "obj");
    push_data_to_gradio_component(conversation.history, "history-ng", "obj");
-    // console.log("restore_chat_from_local_storage", conversation);
-
-    // Create a conversation UUID and timestamp
    const conversationId = conversation.id;
    const timestamp = conversation.timestamp;
    const conversationData = {
        id: conversationId,
        timestamp: timestamp
    };
-    // Save to cookie
-    setCookie("conversation_metadata", JSON.stringify(conversationData), 2);
-    // read from cookie
-    let conversation_metadata = getCookie("conversation_metadata");
-
+    localStorage.setItem("conversation_metadata", JSON.stringify(conversationData));
 }

-
-function clear_conversation(a, b, c) {
+async function clear_conversation(a, b, c) {
+    await save_conversation_history();
    update_conversation_metadata();
    let stopButton = document.getElementById("elem_stop");
    stopButton.click();
-    // console.log("clear_conversation");
    return reset_conversation(a, b);
 }


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


-// clear -> 将 history 缓存至 history_cache -> 点击复原 -> restore_previous_chat() -> 触发elem_update_history -> 读取 history_cache
-function restore_previous_chat() {
-    // console.log("restore_previous_chat");
-    let chat = getCookie("js_previous_chat_cookie");
-    chat = JSON.parse(decodeURIComponent(escape(atob(chat))));
-    push_data_to_gradio_component(chat, "gpt-chatbot", "obj");
-    let history = getCookie("js_previous_history_cookie");
-    history = JSON.parse(decodeURIComponent(escape(atob(history))));
-    push_data_to_gradio_component(history, "history-ng", "obj");
-    // document.querySelector("#elem_update_history").click(); // in order to call set_history_gr_state, and send history state to server
-}
-
-
 async function on_plugin_exe_complete(fn_name) {
    // console.log(fn_name);
    if (fn_name === "保存当前的对话") {
--- a/themes/green.css
+++ b/themes/green.css
@@ -567,7 +567,6 @@ ul:not(.options) {
    border-radius: var(--radius-xl) !important;
    border: none;
    padding: var(--spacing-xl) !important;
-    font-size: 15px !important;
    line-height: var(--line-md) !important;
    min-height: calc(var(--text-md)*var(--line-md) + 2*var(--spacing-xl));
    min-width: calc(var(--text-md)*var(--line-md) + 2*var(--spacing-xl));
--- a/themes/green.py
+++ b/themes/green.py
@@ -10,6 +10,14 @@ theme_dir = os.path.dirname(__file__)
 def adjust_theme():
    try:
        set_theme = gr.themes.Soft(
+            font=[
+                "Helvetica",
+                "Microsoft YaHei",
+                "ui-sans-serif",
+                "sans-serif",
+                "system-ui",
+            ],
+            font_mono=["ui-monospace", "Consolas", "monospace"],
            primary_hue=gr.themes.Color(
                c50="#EBFAF2",
                c100="#CFF3E1",
--- a/themes/gui_toolbar.py
+++ b/themes/gui_toolbar.py
@@ -1,6 +1,7 @@
 import gradio as gr
+from toolbox import get_conf

-def define_gui_toolbar(AVAIL_LLM_MODELS, LLM_MODEL, INIT_SYS_PROMPT, THEME, AVAIL_THEMES, ADD_WAIFU, help_menu_description, js_code_for_toggle_darkmode):
+def define_gui_toolbar(AVAIL_LLM_MODELS, LLM_MODEL, INIT_SYS_PROMPT, THEME, AVAIL_THEMES, AVAIL_FONTS, ADD_WAIFU, help_menu_description, js_code_for_toggle_darkmode):
    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"):
@@ -9,12 +10,12 @@ def define_gui_toolbar(AVAIL_LLM_MODELS, LLM_MODEL, INIT_SYS_PROMPT, THEME, AVAI

            with gr.Tab("更换模型", elem_id="interact-panel"):
                md_dropdown = gr.Dropdown(AVAIL_LLM_MODELS, value=LLM_MODEL, elem_id="elem_model_sel", 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)",)
+                top_p = gr.Slider(minimum=-0, maximum=1.0, value=1.0, step=0.01,interactive=True, label="Top-p (nucleus sampling)", elem_id="elem_top_p")
                temperature = gr.Slider(minimum=-0, maximum=2.0, value=1.0, step=0.01, interactive=True, label="Temperature", elem_id="elem_temperature")
-                max_length_sl = gr.Slider(minimum=256, maximum=1024*32, value=4096, step=128, interactive=True, label="Local LLM MaxLength",)
+                max_length_sl = gr.Slider(minimum=256, maximum=1024*32, value=4096, step=128, interactive=True, label="Local LLM MaxLength", elem_id="elem_max_length_sl")
                system_prompt = gr.Textbox(show_label=True, lines=2, placeholder=f"System Prompt", label="System prompt", value=INIT_SYS_PROMPT, elem_id="elem_prompt")
                temperature.change(None, inputs=[temperature], outputs=None,
-                    _js="""(temperature)=>gpt_academic_gradio_saveload("save", "elem_prompt", "js_temperature_cookie", temperature)""")
+                    _js="""(temperature)=>gpt_academic_gradio_saveload("save", "elem_temperature", "js_temperature_cookie", temperature)""")
                system_prompt.change(None, inputs=[system_prompt], outputs=None,
                    _js="""(system_prompt)=>gpt_academic_gradio_saveload("save", "elem_prompt", "js_system_prompt_cookie", system_prompt)""")
                md_dropdown.change(None, inputs=[md_dropdown], outputs=None,
@@ -22,6 +23,8 @@ def define_gui_toolbar(AVAIL_LLM_MODELS, LLM_MODEL, INIT_SYS_PROMPT, THEME, AVAI

            with gr.Tab("界面外观", elem_id="interact-panel"):
                theme_dropdown = gr.Dropdown(AVAIL_THEMES, value=THEME, label="更换UI主题").style(container=False)
+                fontfamily_dropdown = gr.Dropdown(AVAIL_FONTS, value=get_conf("FONT"), elem_id="elem_fontfamily", label="更换字体类型").style(container=False)
+                fontsize_slider = gr.Slider(minimum=5, maximum=25, value=15, step=1, interactive=True, label="字体大小(默认15)", elem_id="elem_fontsize")
                checkboxes = gr.CheckboxGroup(["基础功能区", "函数插件区", "浮动输入区", "输入清除键", "插件参数区"], value=["基础功能区", "函数插件区"], label="显示/隐藏功能区", elem_id='cbs').style(container=False)
                opt = ["自定义菜单"]
                value=[]
@@ -31,7 +34,10 @@ def define_gui_toolbar(AVAIL_LLM_MODELS, LLM_MODEL, INIT_SYS_PROMPT, THEME, AVAI
                dark_mode_btn.click(None, None, None, _js=js_code_for_toggle_darkmode)
                open_new_tab = gr.Button("打开新对话", variant="secondary").style(size="sm")
                open_new_tab.click(None, None, None, _js=f"""()=>duplicate_in_new_window()""")
-
+                fontfamily_dropdown.select(None, inputs=[fontfamily_dropdown], outputs=None,
+                    _js="""(fontfamily)=>{gpt_academic_gradio_saveload("save", "elem_fontfamily", "js_fontfamily", fontfamily); gpt_academic_change_chatbot_font(fontfamily, null, null);}""")
+                fontsize_slider.change(None, inputs=[fontsize_slider], outputs=None,
+                    _js="""(fontsize)=>{gpt_academic_gradio_saveload("save", "elem_fontsize", "js_fontsize", fontsize); gpt_academic_change_chatbot_font(null, fontsize, null);}""")

            with gr.Tab("帮助", elem_id="interact-panel"):
                gr.Markdown(help_menu_description)
--- a/themes/init.js
+++ b/themes/init.js
@@ -1,11 +1,142 @@
+function remove_legacy_cookie() {
+    setCookie("web_cookie_cache", "", -1);
+    setCookie("js_previous_chat_cookie", "", -1);
+    setCookie("js_previous_history_cookie", "", -1);
+}
+
+
+function processFontFamily(fontfamily) {
+    // 检查是否包含括号
+    if (fontfamily.includes('(')) {
+        // 分割字符串
+        const parts = fontfamily.split('(');
+        const fontNamePart = parts[1].split(')')[0].trim(); // 获取括号内的部分
+
+        // 检查是否包含 @
+        if (fontNamePart.includes('@')) {
+            const [fontName, fontUrl] = fontNamePart.split('@').map(part => part.trim());
+            return { fontName, fontUrl };
+        } else {
+            return { fontName: fontNamePart, fontUrl: null };
+        }
+    } else {
+        return { fontName: fontfamily, fontUrl: null };
+    }
+}
+
+// 检查字体是否存在
+function checkFontAvailability(fontfamily) {
+    return new Promise((resolve) => {
+        const canvas = document.createElement('canvas');
+        const context = canvas.getContext('2d');
+
+        // 设置两个不同的字体进行比较
+        const testText = 'abcdefghijklmnopqrstuvwxyz0123456789';
+        context.font = `16px ${fontfamily}, sans-serif`;
+        const widthWithFont = context.measureText(testText).width;
+
+        context.font = '16px sans-serif';
+        const widthWithFallback = context.measureText(testText).width;
+
+        // 如果宽度相同，说明字体不存在
+        resolve(widthWithFont !== widthWithFallback);
+    });
+}
+async function checkFontAvailabilityV2(fontfamily) {
+    fontName = fontfamily;
+    console.log('Checking font availability:', fontName);
+    if ('queryLocalFonts' in window) {
+        try {
+            const fonts = await window.queryLocalFonts();
+            const fontExists = fonts.some(font => font.family === fontName);
+            console.log(`Local Font "${fontName}" exists:`, fontExists);
+            return fontExists;
+        } catch (error) {
+            console.error('Error querying local fonts:', error);
+            return false;
+        }
+    } else {
+        console.error('queryLocalFonts is not supported in this browser.');
+        return false;
+    }
+}
+// 动态加载字体
+function loadFont(fontfamily, fontUrl) {
+    return new Promise((resolve, reject) => {
+        // 使用 Google Fonts 或其他字体来源
+        const link = document.createElement('link');
+        link.rel = 'stylesheet';
+        link.href = fontUrl;
+        link.onload = () => {
+            toast_push(`字体 "${fontfamily}" 已成功加载`, 3000);
+            resolve();
+        };
+        link.onerror = (error) => {
+            reject(error);
+        };
+        document.head.appendChild(link);
+    });
+}
+function gpt_academic_change_chatbot_font(fontfamily, fontsize, fontcolor) {
+    const chatbot = document.querySelector('#gpt-chatbot');
+    // 检查元素是否存在
+    if (chatbot) {
+        if (fontfamily != null) {
+            // 更改字体
+            const result = processFontFamily(fontfamily);
+            if (result.fontName == "Theme-Default-Font") {
+                chatbot.style.fontFamily = result.fontName;
+                return;
+            }
+            // 检查字体是否存在
+            checkFontAvailability(result.fontName).then((isAvailable) => {
+                if (isAvailable) {
+                    // 如果字体存在，直接应用
+                    chatbot.style.fontFamily = result.fontName;
+                } else {
+                    if (result.fontUrl == null) {
+                        // toast_push('无法加载字体，本地字体不存在，且URL未提供', 3000);
+                        // 直接把失效的字体放上去，让系统自动fallback
+                        chatbot.style.fontFamily = result.fontName;
+                        return;
+                    } else {
+                        toast_push('正在下载字体', 3000);
+                        // 如果字体不存在，尝试加载字体
+                        loadFont(result.fontName, result.fontUrl).then(() => {
+                            chatbot.style.fontFamily = result.fontName;
+                        }).catch((error) => {
+                            console.error(`无法加载字体 "${result.fontName}":`, error);
+                        });
+                    }
+                }
+            });
+
+        }
+        if (fontsize != null) {
+            // 修改字体大小
+            document.documentElement.style.setProperty(
+                '--gpt-academic-message-font-size',
+                `${fontsize}px`
+            );
+        }
+        if (fontcolor != null) {
+            // 更改字体颜色
+            chatbot.style.color = fontcolor;
+        }
+    } else {
+        console.error('#gpt-chatbot is missing');
+    }
+}
+
 async function GptAcademicJavaScriptInit(dark, prompt, live2d, layout, tts) {
    // 第一部分，布局初始化
+    remove_legacy_cookie();
    audio_fn_init();
    minor_ui_adjustment();
    ButtonWithDropdown_init();
    update_conversation_metadata();
    window.addEventListener("gptac_restore_chat_from_local_storage", restore_chat_from_local_storage);
-    
+
    // 加载欢迎页面
    const welcomeMessage = new WelcomeMessage();
    welcomeMessage.begin_render();
@@ -15,7 +146,7 @@ async function GptAcademicJavaScriptInit(dark, prompt, live2d, layout, tts) {
        welcomeMessage.update();
    });
    chatbotObserver.observe(chatbotIndicator, { attributes: true, childList: true, subtree: true });
-    
+
    if (layout === "LEFT-RIGHT") { chatbotAutoHeight(); }
    if (layout === "LEFT-RIGHT") { limit_scroll_position(); }

@@ -38,7 +169,7 @@ async function GptAcademicJavaScriptInit(dark, prompt, live2d, layout, tts) {
    }

    //  自动朗读
-    if (tts != "DISABLE"){
+    if (tts != "DISABLE") {
        enable_tts = true;
        if (getCookie("js_auto_read_cookie")) {
            auto_read_tts = getCookie("js_auto_read_cookie")
@@ -48,7 +179,11 @@ async function GptAcademicJavaScriptInit(dark, prompt, live2d, layout, tts) {
            }
        }
    }
-
+    // 字体
+    gpt_academic_gradio_saveload("load", "elem_fontfamily", "js_fontfamily", null, "str");
+    gpt_academic_change_chatbot_font(getCookie("js_fontfamily"), null, null);
+    gpt_academic_gradio_saveload("load", "elem_fontsize", "js_fontsize", null, "str");
+    gpt_academic_change_chatbot_font(null, getCookie("js_fontsize"), null);
    // SysPrompt 系统静默提示词
    gpt_academic_gradio_saveload("load", "elem_prompt", "js_system_prompt_cookie", null, "str");
    // Temperature 大模型温度参数
@@ -58,7 +193,7 @@ async function GptAcademicJavaScriptInit(dark, prompt, live2d, layout, tts) {
        const cached_model = getCookie("js_md_dropdown_cookie");
        var model_sel = await get_gradio_component("elem_model_sel");
        // determine whether the cached model is in the choices
-        if (model_sel.props.choices.includes(cached_model)){
+        if (model_sel.props.choices.includes(cached_model)) {
            // change dropdown
            gpt_academic_gradio_saveload("load", "elem_model_sel", "js_md_dropdown_cookie", null, "str");
            // 连锁修改chatbot的label
--- a/themes/welcome.js
+++ b/themes/welcome.js
@@ -85,7 +85,8 @@ class WelcomeMessage {
        this.card_array = [];
        this.static_welcome_message_previous = [];
        this.reflesh_time_interval = 15 * 1000;
-
+        this.update_time_interval = 2 * 1000;
+        this.major_title = "欢迎使用GPT-Academic";

        const reflesh_render_status = () => {
            for (let index = 0; index < this.card_array.length; index++) {
@@ -99,16 +100,28 @@ class WelcomeMessage {

        // call update when page size change, call this.update when page size change
        window.addEventListener('resize', this.update.bind(this));
+        // add a loop to reflesh cards
+        this.startRefleshCards();
+        this.startAutoUpdate();
    }

    begin_render() {
        this.update();
    }

+    async startAutoUpdate() {
+        // sleep certain time
+        await new Promise(r => setTimeout(r, this.update_time_interval));
+        this.update();
+    }
+
    async startRefleshCards() {
+        // sleep certain time
        await new Promise(r => setTimeout(r, this.reflesh_time_interval));
-        await this.reflesh_cards();
+        // checkout visible status
        if (this.visible) {
+            // if visible, then reflesh cards
+            await this.reflesh_cards();
            setTimeout(() => {
                this.startRefleshCards.call(this);
            }, 1);
@@ -129,6 +142,7 @@ class WelcomeMessage {

        // combine two lists
        this.static_welcome_message_previous = not_shown_previously.concat(already_shown_previously);
+        this.static_welcome_message_previous = this.static_welcome_message_previous.slice(0, this.max_welcome_card_num);

        (async () => {
            // 使用 for...of 循环来处理异步操作
@@ -145,8 +159,10 @@ class WelcomeMessage {
                    continue;
                }

-                // 等待动画结束
-                card.addEventListener('transitionend', () => {
+
+                card.classList.add('hide');
+                const timeout = 100; // 与CSS中transition的时间保持一致(0.1s)
+                setTimeout(() => {
                    // 更新卡片信息
                    const message = this.static_welcome_message_previous[index];
                    const title = card.getElementsByClassName('welcome-card-title')[0];
@@ -158,16 +174,14 @@ class WelcomeMessage {
                    text.href = message.url;
                    content.textContent = message.content;
                    card.classList.remove('hide');
-
                    // 等待动画结束
-                    card.addEventListener('transitionend', () => {
-                        card.classList.remove('show');
-                    }, { once: true });
                    card.classList.add('show');
+                    const timeout = 100; // 与CSS中transition的时间保持一致(0.1s)
+                    setTimeout(() => {
+                        card.classList.remove('show');
+                    }, timeout);
+                }, timeout);

-                }, { once: true });
-
-                card.classList.add('hide');

                // 等待 250 毫秒
                await new Promise(r => setTimeout(r, 200));
@@ -193,36 +207,38 @@ class WelcomeMessage {
        return array;
    }

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

    showCard(message) {
@@ -263,7 +279,7 @@ class WelcomeMessage {
    }

    async showWelcome() {
-
+        this.visible = true;
        // 首先，找到想要添加子元素的父元素
        const elem_chatbot = document.getElementById('gpt-chatbot');

@@ -274,7 +290,7 @@ class WelcomeMessage {
        // 创建主标题
        const major_title = document.createElement('div');
        major_title.classList.add('welcome-title');
-        major_title.textContent = "欢迎使用GPT-Academic";
+        major_title.textContent = this.major_title;
        welcome_card_container.appendChild(major_title)

        // 创建卡片
@@ -289,6 +305,16 @@ class WelcomeMessage {
        });

        elem_chatbot.appendChild(welcome_card_container);
+        const can_display = await this.can_display();
+        if (!can_display) {
+            // undo
+            this.visible = false;
+            this.card_array = [];
+            this.static_welcome_message_previous = [];
+            elem_chatbot.removeChild(welcome_card_container);
+            await new Promise(r => setTimeout(r, this.update_time_interval / 2));
+            return;
+        }

        // 添加显示动画
        requestAnimationFrame(() => {
@@ -297,15 +323,24 @@ class WelcomeMessage {
    }

    async removeWelcome() {
+        this.visible = false;
        // remove welcome-card-container
        const elem_chatbot = document.getElementById('gpt-chatbot');
        const welcome_card_container = document.getElementsByClassName('welcome-card-container')[0];
-        // 添加隐藏动画
+        // begin hide animation
        welcome_card_container.classList.add('hide');
-        // 等待动画结束后再移除元素
        welcome_card_container.addEventListener('transitionend', () => {
            elem_chatbot.removeChild(welcome_card_container);
+            this.card_array = [];
+            this.static_welcome_message_previous = [];
        }, { once: true });
+        // add a fail safe timeout
+        const timeout = 600; // 与 CSS 中 transition 的时间保持一致(1s)
+        setTimeout(() => {
+            if (welcome_card_container.parentNode) {
+                elem_chatbot.removeChild(welcome_card_container);
+            }
+        }, timeout);
    }

    async isChatbotEmpty() {
--- a/toolbox.py
+++ b/toolbox.py
@@ -178,6 +178,7 @@ def update_ui(chatbot:ChatBotWithCookies, history:list, msg:str="正常", **kwar
    else:
        chatbot_gr = chatbot

+    history = [str(history_item) for history_item in history] # ensure all items are string
    json_history = json.dumps(history, ensure_ascii=False)
    yield cookies, chatbot_gr, json_history, msg

--- a/4
+++ b/4
@@ -1,5 +1,5 @@
 {
-  "version": 3.91,
+  "version": 3.93,
  "show_feature": true,
-  "new_feature": "优化前端并修复TTS的BUG <-> 添加时间线回溯功能 <-> 支持chatgpt-4o-latest <-> 增加RAG组件 <-> 升级多合一主提交键"
+  "new_feature": "支持deepseek-reason(r1) <-> 字体和字体大小自定义 <-> 优化前端并修复TTS的BUG <-> 添加时间线回溯功能 <-> 支持chatgpt-4o-latest <-> 增加RAG组件 <-> 升级多合一主提交键"
 }
Author	SHA1	Message	Date
雷欧（林平凡）	e9de41b7e8	1 Some checks failed build-with-all-capacity / build-and-push-image (push) Has been cancelled Details build-with-audio-assistant / build-and-push-image (push) Has been cancelled Details build-with-chatglm / build-and-push-image (push) Has been cancelled Details build-with-latex-arm / build-and-push-image (push) Has been cancelled Details build-with-latex / build-and-push-image (push) Has been cancelled Details build-without-local-llms / build-and-push-image (push) Has been cancelled Details	2025-02-07 11:21:24 +08:00
雷欧（林平凡）	b34c79a94b	1 Some checks are pending build-with-all-capacity / build-and-push-image (push) Waiting to run Details build-with-audio-assistant / build-and-push-image (push) Waiting to run Details build-with-chatglm / build-and-push-image (push) Waiting to run Details build-with-latex-arm / build-and-push-image (push) Waiting to run Details build-with-latex / build-and-push-image (push) Waiting to run Details build-without-local-llms / build-and-push-image (push) Waiting to run Details	2025-02-07 11:17:38 +08:00
雷欧（林平凡）	95284d859b	1 Some checks are pending build-with-all-capacity / build-and-push-image (push) Waiting to run Details build-with-audio-assistant / build-and-push-image (push) Waiting to run Details build-with-chatglm / build-and-push-image (push) Waiting to run Details build-with-latex-arm / build-and-push-image (push) Waiting to run Details build-with-latex / build-and-push-image (push) Waiting to run Details build-without-local-llms / build-and-push-image (push) Waiting to run Details	2025-02-06 10:46:46 +08:00
雷欧（林平凡）	a552592b5a	1 Some checks are pending build-with-all-capacity / build-and-push-image (push) Waiting to run Details build-with-audio-assistant / build-and-push-image (push) Waiting to run Details build-with-chatglm / build-and-push-image (push) Waiting to run Details build-with-latex-arm / build-and-push-image (push) Waiting to run Details build-with-latex / build-and-push-image (push) Waiting to run Details build-without-local-llms / build-and-push-image (push) Waiting to run Details	2025-02-06 10:32:13 +08:00
雷欧（林平凡）	e305f1b4a8	1 Some checks are pending build-with-all-capacity / build-and-push-image (push) Waiting to run Details build-with-audio-assistant / build-and-push-image (push) Waiting to run Details build-with-chatglm / build-and-push-image (push) Waiting to run Details build-with-latex-arm / build-and-push-image (push) Waiting to run Details build-with-latex / build-and-push-image (push) Waiting to run Details build-without-local-llms / build-and-push-image (push) Waiting to run Details	2025-02-06 10:30:58 +08:00
van	a88497c3ab	1 Some checks are pending build-with-all-capacity / build-and-push-image (push) Waiting to run Details build-with-audio-assistant / build-and-push-image (push) Waiting to run Details build-with-chatglm / build-and-push-image (push) Waiting to run Details build-with-latex-arm / build-and-push-image (push) Waiting to run Details build-with-latex / build-and-push-image (push) Waiting to run Details build-without-local-llms / build-and-push-image (push) Waiting to run Details	2025-02-06 10:23:42 +08:00
雷欧（林平凡）	0f1d2e0e48	1 Some checks are pending build-with-all-capacity / build-and-push-image (push) Waiting to run Details build-with-audio-assistant / build-and-push-image (push) Waiting to run Details build-with-chatglm / build-and-push-image (push) Waiting to run Details build-with-latex-arm / build-and-push-image (push) Waiting to run Details build-with-latex / build-and-push-image (push) Waiting to run Details build-without-local-llms / build-and-push-image (push) Waiting to run Details	2025-02-06 10:03:34 +08:00
binary-husky	936e2f5206	update readme	2025-02-04 16:15:56 +08:00
binary-husky	7f4b87a633	update readme	2025-02-04 16:08:18 +08:00
binary-husky	2ddd1bb634	Merge branch 'memset0-master'	2025-02-04 16:03:53 +08:00
binary-husky	c68285aeac	update config and version	2025-02-04 16:03:01 +08:00
Memento mori.	caaebe4296	add support for Deepseek R1 model and display CoT (#2118 ) * feat: add support for R1 model and display CoT * fix unpacking * feat: customized font & font size * auto hide tooltip when scoll down * tooltip glass transparent css * fix: Enhance API key validation in is_any_api_key function (#2113) * support qwen2.5-max! * update minior adjustment --------- Co-authored-by: binary-husky <qingxu.fu@outlook.com> Co-authored-by: Steven Moder <java20131114@gmail.com>	2025-02-04 16:02:02 +08:00
binary-husky	39d50c1c95	update minior adjustment	2025-02-04 15:57:35 +08:00
binary-husky	25dc7bf912	Merge branch 'master' of https://github.com/memset0/gpt_academic into memset0-master	2025-01-30 22:03:31 +08:00
binary-husky	0458590a77	support qwen2.5-max!	2025-01-29 23:29:38 +08:00
Steven Moder	44fe78fff5	fix: Enhance API key validation in is_any_api_key function (#2113 )	2025-01-29 21:40:30 +08:00
binary-husky	5ddd657ebc	tooltip glass transparent css	2025-01-28 23:50:21 +08:00
binary-husky	9b0b2cf260	auto hide tooltip when scoll down	2025-01-28 23:32:40 +08:00
binary-husky	9f39a6571a	feat: customized font & font size	2025-01-28 02:52:56 +08:00
memset0	d07e736214	fix unpacking	2025-01-25 00:00:13 +08:00
memset0	a1f7ae5b55	feat: add support for R1 model and display CoT	2025-01-24 14:43:49 +08:00
binary-husky	1213ef19e5	Merge branch 'master' of github.com:binary-husky/chatgpt_academic	2025-01-22 01:50:08 +08:00
binary-husky	aaafe2a797	fix xelatex font problem in all-cap image	2025-01-22 01:49:53 +08:00
binary-husky	2716606f0c	Update README.md	2025-01-16 23:40:24 +08:00
binary-husky	286f7303be	fix image display bug	2025-01-12 21:54:43 +08:00
binary-husky	7eeab9e376	fix code block display bug	2025-01-09 22:31:59 +08:00
binary-husky	4ca331fb28	prevent html rendering for input	2025-01-05 21:20:12 +08:00
binary-husky	9487829930	change max_chat_preserve = 10	2025-01-03 00:34:36 +08:00
binary-husky	a73074b89e	upgrade chat checkpoint	2025-01-03 00:31:03 +08:00
Southlandi	fd93622840	修复Gemini对话错误问题（停用词数量为0的情况） (#2092 )	2024-12-28 23:22:10 +08:00
whyXVI	09a82a572d	Fix RuntimeError in predict_no_ui_long_connection() (#2095 ) Bug fix: Fix RuntimeError in predict_no_ui_long_connection() In the original code, calling predict_no_ui_long_connection() would trigger a RuntimeError("OpenAI拒绝了请求：" + error_msg) even when the server responded normally. The issue occurred due to incorrect handling of SSE protocol comment lines (lines starting with ":"). Modified the parsing logic in both `predict` and `predict_no_ui_long_connection` to handle these lines correctly, making the logic more intuitive and robust.	2024-12-28 23:21:14 +08:00
G.RQ	c53ddf65aa	修复 bug“重置”按钮报错 (#2102 ) * fix 重置按钮bug * fix version control bug --------- Co-authored-by: binary-husky <qingxu.fu@outlook.com>	2024-12-28 23:19:25 +08:00
binary-husky	ac64a77c2d	allow disable openai proxy in `WHEN_TO_USE_PROXY`	2024-12-28 07:14:54 +08:00
binary-husky	dae8a0affc	compat bug fix	2024-12-25 01:21:58 +08:00
binary-husky	97a81e9388	fix temp issue of o1	2024-12-25 00:54:03 +08:00
binary-husky	1dd1d0ed6c	fix cookie overflow bug	2024-12-25 00:33:20 +08:00
binary-husky	060af0d2e6	Merge branch 'master' of github.com:binary-husky/chatgpt_academic	2024-12-22 23:33:44 +08:00
binary-husky	a848f714b6	fix welcome card bugs	2024-12-22 23:33:22 +08:00
binary-husky	924f8e30c7	Update issue stale.yml	2024-12-22 14:16:18 +08:00
binary-husky	f40347665b	github action change	2024-12-22 14:15:16 +08:00
binary-husky	734c40bbde	fix non-localhost javascript error	2024-12-22 14:01:22 +08:00
binary-husky	4ec87fbb54	history ng patch 1	2024-12-21 11:27:53 +08:00
binary-husky	17b5c22e61	Merge branch 'master' of github.com:binary-husky/chatgpt_academic	2024-12-19 22:46:14 +08:00
binary-husky	c6cd04a407	promote the rank of DASHSCOPE_API_KEY	2024-12-19 22:39:14 +08:00
YIQI JIANG	f60a12f8b4	Add o1 and o1-2024-12-17 model support (#2090 ) * Add o1 and o1-2024-12-17 model support * patch api key selection --------- Co-authored-by: 蒋翌琪 <jiangyiqi99@jiangyiqideMacBook-Pro.local> Co-authored-by: binary-husky <qingxu.fu@outlook.com>	2024-12-19 22:32:57 +08:00