Release v2.3.1

fix: 未指定utf-8保存已输出的公告
fix: Windows上无法读取和应用命令权限配置的问题
2025-11-25 19:37:36 +08:00 · 2023-04-02 16:32:52 +08:00 · 2023-04-02 16:30:42 +08:00 · 2023-04-02 16:24:30 +08:00 · 2023-04-02 16:04:52 +08:00 · 2023-04-02 14:43:34 +08:00
70 changed files with 2484 additions and 615 deletions
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -0,0 +1,34 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/python
+{
+	"name": "QChatGPT 3.10",
+	// Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+	"image": "mcr.microsoft.com/devcontainers/python:0-3.10",
+
+	// Features to add to the dev container. More info: https://containers.dev/features.
+	// "features": {},
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	// "postCreateCommand": "pip3 install --user -r requirements.txt",
+
+	// Configure tool-specific properties.
+	// "customizations": {},
+	"customizations": {
+		"codespaces": {
+		  "repositories": {
+			"RockChinQ/QChatGPT": {
+			  "permissions": "write-all"
+			},
+			"RockChinQ/revLibs": {
+			  "permissions": "write-all"
+			}
+		  }
+		}
+	  }
+
+	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "root"
+}
--- a/.github/ISSUE_TEMPLATE/bug-report.yml
+++ b/.github/ISSUE_TEMPLATE/bug-report.yml
@@ -0,0 +1,42 @@
+name: 漏洞反馈
+description: 报错或漏洞请使用这个模板创建，不使用此模板创建的异常、漏洞相关issue将被直接关闭
+title: "[Bug]: "
+labels: ["bug?"]
+body:
+  - type: dropdown
+    attributes:
+      label: 部署方式
+      description: "主程序使用的部署方式"
+      options:
+        - 手动部署
+        - 安装器部署
+        - 一键安装包部署
+        - Docker部署
+    validations:
+      required: true
+  - type: input
+    attributes:
+      label: 系统环境
+      description: 操作系统、系统架构。
+      placeholder: 例如： CentOS x64、Windows11
+    validations:
+      required: true
+  - type: input
+    attributes:
+      label: Python环境
+      description: 运行程序的Python版本
+      placeholder: 例如： Python 3.10
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 异常情况
+      description: 完整描述异常情况，什么时候发生的、发生了什么
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 报错信息
+      description: 请提供完整的**控制台**报错信息（若有）
+    validations:
+      required: false
--- a/.github/ISSUE_TEMPLATE/feature-request.yml
+++ b/.github/ISSUE_TEMPLATE/feature-request.yml
@@ -0,0 +1,21 @@
+name: 需求建议
+title: "[Feature]: "
+labels: ["enhancement"]
+description: "新功能或现有功能优化请使用这个模板；不符合类别的issue将被直接关闭"
+body:
+  - type: dropdown
+    attributes:
+      label: 这是一个？
+      description: 新功能建议还是现有功能优化
+      options:
+        - 新功能
+        - 现有功能优化
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 详细描述
+      description: 详细描述，越详细越好
+    validations:
+      required: true
+      
--- a/.github/ISSUE_TEMPLATE/漏洞反馈.md
+++ b/.github/ISSUE_TEMPLATE/漏洞反馈.md
@@ -1,24 +0,0 @@
---
-name: 漏洞反馈
-about: 报错或漏洞请使用这个模板创建
-title: "[BUG]"
-labels: 'bug'
-assignees: ''
-
---
-
-请认真按照实际情况填写以下信息！！！！
-
-**运行环境**
- 部署方式：
-    手动部署/自动部署/Docker部署
- 系统环境：
-    例如： Centos x64
- Python环境（仅手动部署填写）：
-    例如： Python 3.10.9
-
-**描述漏洞**  
-什么时候发生的，mirai还是主程序，越详细越好
-
-**完整报错信息**  
-完整的报错信息
--- a/.github/ISSUE_TEMPLATE/需求建议.md
+++ b/.github/ISSUE_TEMPLATE/需求建议.md
@@ -1,10 +0,0 @@
---
-name: 需求建议
-about: 软件优化建议请使用这个模板创建
-title: "[ENHANCE]"
-labels: 'enhancement'
-assignees: ''
-
---
-
-不是需求建议请勿填写此模板！！！！
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -0,0 +1,25 @@
+## 概述
+
+实现/解决/优化的内容: 
+
+### 事务
+
+- [ ] 已阅读仓库[贡献指引](../CONTRIBUTING.md)
+- [ ] 已与维护者在issues或其他平台沟通此PR大致内容
+
+## 以下内容可在起草PR后、合并PR前逐步完成
+
+### 功能
+
+- [ ] 已编写完善的配置文件字段说明（若有新增）
+- [ ] 已编写面向用户的新功能说明（若有必要）
+- [ ] 已测试新功能或更改
+
+### 兼容性
+
+- [ ] 已处理版本兼容性
+- [ ] 已处理插件兼容问题
+
+### 风险
+
+可能导致或已知的问题: 
--- a/.github/workflows/update-cmdpriv-template.yml
+++ b/.github/workflows/update-cmdpriv-template.yml
@@ -0,0 +1,54 @@
+name: Update cmdpriv-template
+
+on:
+  push:
+    paths:
+      - 'pkg/qqbot/cmds/**'
+  pull_request:
+    types: [closed]
+    paths:
+      - 'pkg/qqbot/cmds/**'
+
+jobs:
+  update-cmdpriv-template:
+    if: github.event.pull_request.merged == true || github.event_name == 'push'
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.x
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install --upgrade  yiri-mirai openai colorlog func_timeout dulwich Pillow
+      
+    - name: Generate Files
+      run: |
+        python main.py
+
+    - name: Run generate_cmdpriv_template.py
+      run: python3 generate_cmdpriv_template.py
+
+    - name: Check for changes in cmdpriv-template.json
+      id: check_changes
+      run: |
+        if git diff --name-only | grep -q "cmdpriv-template.json"; then
+          echo "::set-output name=changes_detected::true"
+        else
+          echo "::set-output name=changes_detected::false"
+        fi
+
+    - name: Commit changes to cmdpriv-template.json
+      if: steps.check_changes.outputs.changes_detected == 'true'
+      run: |
+        git config --global user.name "GitHub Actions Bot"
+        git config --global user.email "<github-actions@github.com>"
+        git add cmdpriv-template.json
+        git commit -m "Update cmdpriv-template.json"
+        git push
--- a/.github/workflows/update-override-all.yml
+++ b/.github/workflows/update-override-all.yml
@@ -0,0 +1,49 @@
+name: Check and Update override_all
+
+on:
+  push:
+    paths:
+      - 'config-template.py'
+  pull_request:
+    types:
+      - closed
+    branches:
+      - master
+    paths:
+      - 'config-template.py'
+
+jobs:
+  update-override-all:
+    name: check and update
+    if: github.event.pull_request.merged == true || github.event_name == 'push'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.x
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          # 在此处添加您的项目所需的其他依赖
+
+      - name: Run generate_override_all.py
+        run: python3 generate_override_all.py
+
+      - name: Check for changes in override-all.json
+        id: check_changes
+        run: |
+          git diff --exit-code override-all.json || echo "::set-output name=changes_detected::true"
+
+      - name: Commit and push changes
+        if: steps.check_changes.outputs.changes_detected == 'true'
+        run: |
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+          git config --global user.name "GitHub Actions"
+          git add override-all.json
+          git commit -m "Update override-all.json"
+          git push
--- a/.gitignore
+++ b/.gitignore
@@ -11,4 +11,10 @@ prompts/
 logs/
 sensitive.json
 temp/
-current_tag
+current_tag
+scenario/
+!scenario/default-template.json
+override.json
+cookies.json
+res/announcement_saved
+cmdpriv.json
--- a/.gitmodules
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "QChatGPT.wiki"]
+	path = QChatGPT.wiki
+	url = https://github.com/RockChinQ/QChatGPT.wiki.git
--- a/17
+++ b/17
@@ -0,0 +1,17 @@
+FROM python:3.9-slim
+WORKDIR /QChatGPT
+
+RUN sed -i "s/deb.debian.org/mirrors.tencent.com/g" /etc/apt/sources.list \
+    && sed -i 's|security.debian.org/debian-security|mirrors.tencent.com/debian-security|g' /etc/apt/sources.list \
+    && apt-get clean \
+    && apt-get update \
+    && apt-get -y upgrade \
+    && apt-get install -y git \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY . /QChatGPT/
+
+RUN pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
+
+CMD [ "python", "main.py" ] 
--- a/QChatGPT.wiki
+++ b/QChatGPT.wiki
--- a/README.md
+++ b/README.md
@@ -1,24 +1,32 @@
 # QChatGPT🤖
-> 2023/3/3  官方接口疑似被墙，可考虑使用网络代理 [#198](https://github.com/RockChinQ/QChatGPT/issues/198)  
+
+> 2023/3/18 现已支持GPT-4 API（内测），请查看`config-template.py`中的`completion_api_params`  
+> 2023/3/15 逆向库已支持New Bing，使用方法查看[插件文档](https://github.com/RockChinQ/revLibs)  
+> 2023/3/15 逆向库已支持GPT-4模型，使用方法查看[插件](https://github.com/RockChinQ/revLibs)   
 > 2023/3/3  现已在主线支持官方ChatGPT接口，使用方法查看[#195](https://github.com/RockChinQ/QChatGPT/issues/195)  
-> 2023/3/2  OpenAI已发布ChatGPT官方接口，我们正在全力接入，预计明日前完成，请查看[此PR](https://github.com/RockChinQ/QChatGPT/pull/194)  
-> 2023/2/16 现已支持接入ChatGPT网页版，详情请完成部署并查看底部**插件**小节或[此仓库](https://github.com/RockChinQ/revLibs)

 - 到[项目Wiki](https://github.com/RockChinQ/QChatGPT/wiki)可了解项目详细信息
- 由bilibili TheLazy制作的[视频教程](https://www.bilibili.com/video/BV15v4y1X7aP)
- 交流、答疑群: ~~204785790~~（已满）、691226829、656285629  
+- ~~由bilibili TheLazy制作的[视频教程](https://www.bilibili.com/video/BV15v4y1X7aP)~~（寄了，求大佬做个新的）
+- 交流、答疑群: ~~204785790~~（已满）、~~691226829~~（已满）、656285629  
  - **进群提问前请您`确保`已经找遍文档和issue均无法解决**  
 - QQ频道机器人见[QQChannelChatGPT](https://github.com/Soulter/QQChannelChatGPT)
+- 欢迎各种形式的贡献，请查看[贡献指引](CONTRIBUTING.md)

 通过调用OpenAI的ChatGPT等语言模型来实现一个更加智能的QQ机器人  

 ## 🍺模型适配一览

+<details>
+<summary>点击此处展开</summary>
+
 ### 文字对话

 - OpenAI GPT-3.5模型(ChatGPT API), 本项目原生支持, 默认使用
- OpenAI GPT-3模型, 本项目原生支持, 部署完成后前往config.py切换
- ChatGPT网页版逆向API, 由[插件](https://github.com/RockChinQ/revLibs)接入
+- OpenAI GPT-3模型, 本项目原生支持, 部署完成后前往`config.py`切换
+- OpenAI GPT-4模型, 本项目原生支持, 目前需要您的账户通过OpenAI的内测申请, 请前往`config.py`切换
+- ChatGPT网页版GPT-3.5模型, 由[插件](https://github.com/RockChinQ/revLibs)接入
+- ChatGPT网页版GPT-4模型, 目前需要ChatGPT Plus订阅, 由[插件](https://github.com/RockChinQ/revLibs)接入
+- New Bing逆向库, 由[插件](https://github.com/RockChinQ/revLibs)接入

 ### 故事续写

@@ -32,9 +40,16 @@
 ### 语音生成

 - TTS+VITS, 由[插件](https://github.com/dominoar/QChatPlugins)接入
+- Plachta/VITS-Umamusume-voice-synthesizer, 由[插件](https://github.com/oliverkirk-sudo/chat_voice)接入
+
+
+</details>

 ## ✅功能

+<details>
+<summary>点击此处展开概述</summary>
+
 <details>
 <summary>✅支持敏感词过滤，避免账号风险</summary>

@@ -106,18 +121,27 @@
    - “丢弃”策略：此分钟内对话次数达到限制时，丢弃之后的对话
  - 详细请查看config.py中的相关配置
 </details>
+<details>
+<summary>✅支持使用网络代理</summary>
+
+  - 目前已支持正向代理访问接口
+  - 详细请查看config.py中的`openai_config`的说明
+</details>
+</details>

 详情请查看[Wiki功能使用页](https://github.com/RockChinQ/QChatGPT/wiki/%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8#%E5%8A%9F%E8%83%BD%E7%82%B9%E5%88%97%E4%B8%BE)

 ## 🔩部署

-**部署过程中遇到任何问题，请先在[QChatGPT](https://github.com/RockChinQ/QChatGPT/issues)或[qcg-installer](https://github.com/RockChinQ/qcg-installer/issues)的issue里进行搜索**
+**部署过程中遇到任何问题，请先在[QChatGPT](https://github.com/RockChinQ/QChatGPT/issues)或[qcg-installer](https://github.com/RockChinQ/qcg-installer/issues)的issue里进行搜索**  

 ### - 注册OpenAI账号

+> 若您要直接使用非OpenAI的模型（如New Bing），可跳过此步骤，直接进行之后的部署，完成后按照相关插件的文档进行配置即可
+
 参考以下文章自行注册

-> [国内注册ChatGPT的方法(100%可用)](https://www.pythonthree.com/register-openai-chatgpt/)
+> [国内注册ChatGPT的方法(100%可用)](https://www.pythonthree.com/register-openai-chatgpt/)  
 > [手把手教你如何注册ChatGPT，超级详细](https://guxiaobei.com/51461)

 注册成功后请前往[个人中心查看](https://beta.openai.com/account/api-keys)api_key  
@@ -130,9 +154,11 @@

 #### Docker方式

-请查看此仓库[mikumifa/QChatGPT-Docker-Installer](https://github.com/mikumifa/QChatGPT-Docker-Installer)
+请查看[此文档](docker_deploy.md)  
+由[@mikumifa](https://github.com/mikumifa)贡献

 #### 安装器方式
+
 使用[此安装器](https://github.com/RockChinQ/qcg-installer)（若无法访问请到[Gitee](https://gitee.com/RockChin/qcg-installer)）进行部署

 - 安装器目前仅支持部分平台，请到仓库文档查看，其他平台请手动部署
@@ -162,8 +188,7 @@ cd QChatGPT
 2. 安装依赖

 ```bash
-pip3 install yiri-mirai openai colorlog func_timeout
-pip3 install dulwich
+pip3 install yiri-mirai openai colorlog func_timeout dulwich Pillow
 ```

 3. 运行一次主程序，生成配置文件
@@ -194,7 +219,8 @@ python3 main.py

 ## 🚀使用

-查看[Wiki功能使用页](https://github.com/RockChinQ/QChatGPT/wiki/%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8#%E4%BD%BF%E7%94%A8%E6%96%B9%E5%BC%8F)
+**部署完成后必看: [指令说明](https://github.com/RockChinQ/QChatGPT/wiki/%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8#%E6%9C%BA%E5%99%A8%E4%BA%BA%E6%8C%87%E4%BB%A4)**  
+所有功能查看[Wiki功能使用页](https://github.com/RockChinQ/QChatGPT/wiki/%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8#%E4%BD%BF%E7%94%A8%E6%96%B9%E5%BC%8F)  

 ## 🧩插件生态

@@ -202,6 +228,9 @@ python3 main.py
 详见[Wiki插件使用页](https://github.com/RockChinQ/QChatGPT/wiki/%E6%8F%92%E4%BB%B6%E4%BD%BF%E7%94%A8)  
 开发教程见[Wiki插件开发页](https://github.com/RockChinQ/QChatGPT/wiki/%E6%8F%92%E4%BB%B6%E5%BC%80%E5%8F%91)

+<details>
+<summary>查看插件列表</summary>
+
 ### 示例插件

 在`tests/plugin_examples`目录下，将其整个目录复制到`plugins`目录下即可使用
@@ -216,20 +245,24 @@ python3 main.py

 - [revLibs](https://github.com/RockChinQ/revLibs) - 将ChatGPT网页版接入此项目，关于[官方接口和网页版有什么区别](https://github.com/RockChinQ/QChatGPT/wiki/%E5%AE%98%E6%96%B9%E6%8E%A5%E5%8F%A3%E4%B8%8EChatGPT%E7%BD%91%E9%A1%B5%E7%89%88)
 - [hello_plugin](https://github.com/RockChinQ/hello_plugin) - `hello_plugin` 的储存库形式，插件开发模板
- [dominoar/QChatPlugins](https://github.com/dominoar/QchatPlugins) - dominoar编写的诸多新功能插件（语言输出、Ranimg、屏蔽词规则等）
+- [dominoar/QChatPlugins](https://github.com/dominoar/QchatPlugins) - dominoar编写的诸多新功能插件（语音输出、Ranimg、屏蔽词规则等）
 - [dominoar/QCP-NovelAi](https://github.com/dominoar/QCP-NovelAi) - NovelAI 故事叙述与绘画
+- [oliverkirk-sudo/chat_voice](https://github.com/oliverkirk-sudo/chat_voice) - 文字转语音输出，使用HuggingFace上的[VITS-Umamusume-voice-synthesizer模型](https://huggingface.co/spaces/Plachta/VITS-Umamusume-voice-synthesizer)
+- [RockChinQ/WaitYiYan](https://github.com/RockChinQ/WaitYiYan) - 实时获取百度`文心一言`等待列表人数
+- [chordfish-k/QChartGPT_Emoticon_Plugin](https://github.com/chordfish-k/QChartGPT_Emoticon_Plugin) - 使机器人根据回复内容发送表情包
+- [oliverkirk-sudo/ChatPoeBot](https://github.com/oliverkirk-sudo/ChatPoeBot) - 接入[Poe](https://poe.com/)上的机器人
+</details>

 ## 😘致谢

 - [@the-lazy-me](https://github.com/the-lazy-me) 为本项目制作[视频教程](https://www.bilibili.com/video/BV15v4y1X7aP)
 - [@mikumifa](https://github.com/mikumifa) 本项目Docker部署仓库开发者
 - [@dominoar](https://github.com/dominoar) 为本项目开发多种插件
- [@hissincn](https://github.com/hissincn) 本项目贡献者
- [@LINSTCL](https://github.com/LINSTCL)   GPT-3.5官方模型适配贡献者
- [@Haibersut](https://github.com/Haibersut)  本项目贡献者
+- [@万神的星空](https://github.com/qq255204159)  整合包发行
+- [@ljcduo](https://github.com/ljcduo)  GPT-4 API内测账号提供

-以及其他所有为本项目提供支持的朋友们。
+以及所有[贡献者](https://github.com/RockChinQ/QChatGPT/graphs/contributors)和其他为本项目提供支持的朋友们。

-## 👍赞赏
+<!-- ## 👍赞赏

-<img alt="赞赏码" src="res/mm_reward_qrcode_1672840549070.png" width="400" height="400"/>
+<img alt="赞赏码" src="res/mm_reward_qrcode_1672840549070.png" width="400" height="400"/> -->
--- a/cmdpriv-template.json
+++ b/cmdpriv-template.json
@@ -0,0 +1,27 @@
+{
+    "comment": "以下为命令权限，请设置到cmdpriv.json中。关于此功能的说明，请查看：https://github.com/RockChinQ/QChatGPT/wiki/%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8#%E5%91%BD%E4%BB%A4%E6%9D%83%E9%99%90%E6%8E%A7%E5%88%B6",
+    "draw": 1,
+    "plugin": 2,
+    "plugin.get": 2,
+    "plugin.update": 2,
+    "plugin.del": 2,
+    "plugin.off": 2,
+    "plugin.on": 2,
+    "default": 1,
+    "default.set": 2,
+    "del": 1,
+    "del.all": 1,
+    "delhst": 2,
+    "delhst.all": 2,
+    "last": 1,
+    "list": 1,
+    "next": 1,
+    "prompt": 1,
+    "resend": 1,
+    "reset": 1,
+    "help": 1,
+    "reload": 2,
+    "update": 2,
+    "usage": 1,
+    "version": 1
+}
--- a/config-template.py
+++ b/config-template.py
@@ -33,11 +33,26 @@ mirai_http_api_config = {
 #     },
 #     "http_proxy": "http://127.0.0.1:12345"
 # }
+#
+# 现已支持反向代理，可以添加reverse_proxy字段以使用反向代理
+# 使用反向代理可以在国内使用OpenAI的API，反向代理的配置请参考
+# https://github.com/Ice-Hazymoon/openai-scf-proxy
+#
+# 反向代理填写示例：
+# openai_config = {
+#     "api_key": {
+#         "default": "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+#         "key1": "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+#         "key2": "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+#     },
+#     "reverse_proxy": "http://example.com:12345/v1"
+# }
 openai_config = {
    "api_key": {
        "default": "openai_api_key"
    },
-    "http_proxy": None
+    "http_proxy": None,
+    "reverse_proxy": None
 }

 # [必需] 管理员QQ号，用于接收报错等通知及执行管理员级别指令
@@ -48,7 +63,7 @@ admin_qq = 0
 # 情景预设（机器人人格）
 # 每个会话的预设信息，影响所有会话，无视指令重置
 # 可以通过这个字段指定某些情况的回复，可直接用自然语言描述指令
-# 例如: 
+# 例如:
 # default_prompt = "如果我之后想获取帮助，请你说“输入!help获取帮助”"
 #   这样用户在不知所措的时候机器人就会提示其输入!help获取帮助
 # 可参考 https://github.com/PlexPt/awesome-chatgpt-prompts-zh
@@ -66,19 +81,26 @@ admin_qq = 0
 # 例如：
 # !reset linux-terminal
 # 若不指定名称，则使用默认情景预设
-# 
+#
 # 也可以使用指令：
 # !default <名称>
 #   将指定的情景预设设置为默认情景预设
 # 例如：
 # !default linux-terminal
 # 之后的会话重置时若不指定名称，则使用linux-terminal情景预设
-# 
+#
 # 还可以加载文件中的预设文字，使用方法请查看：https://github.com/RockChinQ/QChatGPT/wiki/%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8#%E9%A2%84%E8%AE%BE%E6%96%87%E5%AD%97
 default_prompt = {
    "default": "如果我之后想获取帮助，请你说“输入!help获取帮助”",
 }

+# 情景预设格式
+# 参考值：默认方式：normal | 完整情景：full_scenario
+# 默认方式 的格式为上述default_prompt中的内容，或prompts目录下的文件名
+# 完整情景方式 的格式为JSON，在scenario目录下的JSON文件中列出对话的每个回合，编写方法见scenario/default-template.json
+#     编写方法请查看：https://github.com/RockChinQ/QChatGPT/wiki/%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8#%E9%A2%84%E8%AE%BE%E6%96%87%E5%AD%97full_scenario%E6%A8%A1%E5%BC%8F
+preset_mode = "normal"
+
 # 群内响应规则
 # 符合此消息的群内消息即使不包含at机器人也会响应
 # 支持消息前缀匹配及正则表达式匹配
@@ -133,12 +155,16 @@ encourage_sponsor_at_start = True
 # 每次向OpenAI接口发送对话记录上下文的字符数
 # 最大不超过(4096 - max_tokens)个字符，max_tokens为下方completion_api_params中的max_tokens
 # 注意：较大的prompt_submit_length会导致OpenAI账户额度消耗更快
-prompt_submit_length = 1024
+prompt_submit_length = 2048

 # OpenAI补全API的参数
 # 请在下方填写模型，程序自动选择接口
 # 现已支持的模型有：
-# 
+#
+#    'gpt-4'
+#    'gpt-4-0314'
+#    'gpt-4-32k'
+#    'gpt-4-32k-0314'
 #    'gpt-3.5-turbo'
 #    'gpt-3.5-turbo-0301'
 #    'text-davinci-003'
@@ -150,10 +176,10 @@ prompt_submit_length = 1024
 #    'text-ada-001'
 #
 # 具体请查看OpenAI的文档: https://beta.openai.com/docs/api-reference/completions/create
+# 请将内容修改到config.py中，请勿修改config-template.py
 completion_api_params = {
    "model": "gpt-3.5-turbo",
    "temperature": 0.9,  # 数值越低得到的回答越理性，取值范围[0, 1]
-    "max_tokens": 1024,  # 每次获取OpenAI接口响应的文字量上限, 不高于4096
    "top_p": 1,  # 生成的文本的文本与要求的符合度, 取值范围[0, 1]
    "frequency_penalty": 0.2,
    "presence_penalty": 1.0,
@@ -205,10 +231,18 @@ hide_exce_info_to_user = False
 # 设置为空字符串时，不发送提示信息
 alter_tip_message = '出错了，请稍后再试'

-# 机器人线程池大小
+# 线程池相关配置
 # 该参数决定机器人可以同时处理几个人的消息，超出线程池数量的请求会被阻塞，不会被丢弃
 # 如果你不清楚该参数的意义，请不要更改
-pool_num = 10
+# 程序运行本身线程池，无代码层面修改请勿更改
+sys_pool_num = 8
+
+# 执行管理员请求和指令的线程池并行线程数量，一般和管理员数量相等
+admin_pool_num = 2
+
+# 执行用户请求和指令的线程池并行线程数量
+# 如需要更高的并发，可以增大该值
+user_pool_num = 6

 # 每个会话的过期时间，单位为秒
 # 默认值20分钟
@@ -249,11 +283,4 @@ help_message = """此机器人通过调用OpenAI的GPT-3大型语言模型生成
 每次会话最后一次交互后{}分钟后会自动结束，结束后将开启新会话，如需继续前一次会话请发送 !last 重新开启
 欢迎到github.com/RockChinQ/QChatGPT 给个star

-帮助信息：
-!help - 显示帮助
-!reset - 重置会话
-!last - 切换到前一次的对话
-!next - 切换到后一次的对话
-!prompt - 显示当前对话所有内容
-!list - 列出所有历史会话
-!usage - 列出各个api-key的使用量""".format(session_expire_time // 60)
+指令帮助信息请查看: https://github.com/RockChinQ/QChatGPT/wiki/%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8#%E6%9C%BA%E5%99%A8%E4%BA%BA%E6%8C%87%E4%BB%A4""".format(session_expire_time // 60)
--- a/docker_deploy.md
+++ b/docker_deploy.md
@@ -0,0 +1,95 @@
+
+
+## 操作步骤
+
+### 1.安装docker和docker compose
+
+[各种设备的安装Docker方法](https://yeasy.gitbook.io/docker_practice/install)
+
+[安装Compose方法](https://yeasy.gitbook.io/docker_practice/compose)
+
+> `Docker Desktop for Mac/Windows` 自带 `docker-compose` 二进制文件，安装 Docker 之后可以直接使用。
+>
+> 可以选择很多下载方法,反正只要安装了就可以了
+
+### 2. 登录qq(下面所有步骤建议在项目文件夹下操作)
+
+#### 2.1 输入指令
+
+```
+docker run -d -it --name mcl --network host -v ${PWD}/qq/plugins:/app/plugins -v ${PWD}/qq/config:/app/config -v   ${PWD}/qq/data:/app/data -v ${PWD}/qq/bots:/app/bots --restart unless-stopped kagurazakanyaa/mcl:latest
+```
+
+这里使用了[KagurazakaNyaa/mirai-console-loader-docker](https://github.com/KagurazakaNyaa/mirai-console-loader-docker)的镜像
+
+#### 2.2 进入容器
+
+```
+docker ps
+```
+在输出中查看容器的ID，例如：
+```sh
+CONTAINER ID   IMAGE                COMMAND      CREATED          STATUS          PORTS                                       NAMES
+bce1e5568f46   kagurazakanyaa/mcl   "./mcl -u"   10 minutes ago   Up 10 minutes   0.0.0.0:8080->8080/tcp, :::8080->8080/tcp   admiring_mendeleev
+```
+查看`IMAGE`名为`kagurazakanyaa/mcl`的容器的`CONTAINER ID`，在这里是`bce1e5568f46`，于是使用以下命令将其切到前台：
+```
+docker attach bce1e5568f46
+```
+如需将其切到后台运行，请使用组合键`Ctrl+P+Q`
+
+#### 2.3 编写配置文件
+
+- 在` /qq/config/net.mamoe.mirai-api-http` 文件夹中找到`setting.yml`，这是`mirai-api-http`的配置文件
+  - 将这个文件的内容修改为：
+
+```
+adapters:
+  - ws
+debug: true
+enableVerify: true
+verifyKey: yirimirai
+singleMode: false
+cacheSize: 4096
+adapterSettings:
+  ws:
+    host: localhost
+    port: 8080
+    reservedSyncId: -1
+```
+
+`verifyKey`要求与`bot`的`config.py`中的`verifyKey`相同
+
+ `port`: 8080要和2.4 config.py配置里面的端口号相同
+
+#### 2.4 登录
+
+#### 在mirai上登录QQ
+
+```
+login <机器人QQ号> <机器人QQ密码>
+```
+
+> 具体见[此教程](https://yiri-mirai.wybxc.cc/tutorials/01/configuration#4-登录-qq)
+
+#### 配置自动登录(可选)
+
+当机器人账号登录成功以后，执行
+
+```
+autologin add <机器人QQ号> <机器人密码>
+autologin setConfig <机器人QQ号> protocol ANDROID_PAD
+```
+
+> 出现`无法登录`报错时候[无法登录的临时处理方案](https://mirai.mamoe.net/topic/223/无法登录的临时处理方案)
+
+**完成后, `Ctrl+P+Q`退出(不会关掉容器,容器还会运行)**
+
+### 3. 部署QChatGPT
+
+配置好config.py,保存到当前目录下,运行下面的
+
+```
+ docker run  -it -d --name QChatGPT   --network host   -v ${PWD}/config.py:/QChatGPT/config.py  -v ${PWD}/banlist.py:/QChatGPT/banlist.py  -v ${PWD}/sensitive.json:/QChatGPT/sensitive.json  mikumifa/qchatgpt-docker
+```
+
--- a/generate_cmdpriv_template.py
+++ b/generate_cmdpriv_template.py
@@ -0,0 +1,17 @@
+import pkg.qqbot.cmds.mgr as cmdsmgr
+import json
+
+# 执行命令模块的注册
+cmdsmgr.register_all()
+
+# 生成限权文件模板
+template: dict[str, int] = {
+    "comment": "以下为命令权限，请设置到cmdpriv.json中。关于此功能的说明，请查看：https://github.com/RockChinQ/QChatGPT/wiki/%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8#%E5%91%BD%E4%BB%A4%E6%9D%83%E9%99%90%E6%8E%A7%E5%88%B6",
+}
+
+for key in cmdsmgr.__command_list__:
+    template[key] = cmdsmgr.__command_list__[key]['privilege']
+
+# 写入cmdpriv-template.json
+with open('cmdpriv-template.json', 'w') as f:
+    f.write(json.dumps(template, indent=4, ensure_ascii=False))
--- a/generate_override_all.py
+++ b/generate_override_all.py
@@ -0,0 +1,23 @@
+# 使用config-template生成override.json的字段全集模板文件override-all.json
+# 关于override.json机制，请参考：https://github.com/RockChinQ/QChatGPT/pull/271
+import json
+import importlib
+
+
+template = importlib.import_module("config-template")
+output_json = {
+    "comment": "这是override.json支持的字段全集, 关于override.json机制, 请查看https://github.com/RockChinQ/QChatGPT/pull/271"
+}
+
+
+for k, v in template.__dict__.items():
+    if k.startswith("__"):
+        continue
+    # 如果是module
+    if type(v) == type(template):
+        continue
+    print(k, v, type(v))
+    output_json[k] = v
+
+with open("override-all.json", "w", encoding="utf-8") as f:
+    json.dump(output_json, f, indent=4, ensure_ascii=False)
--- a/main.py
+++ b/main.py
@@ -1,4 +1,5 @@
 import importlib
+import json
 import os
 import shutil
 import threading
@@ -6,14 +7,17 @@ import time

 import logging
 import sys
+import traceback
+
+sys.path.append(".")

 try:
    import colorlog
 except ImportError:
    # 尝试安装
    import pkg.utils.pkgmgr as pkgmgr
-    pkgmgr.install_requirements("requirements.txt")
    try:
+        pkgmgr.install_requirements("requirements.txt")
        import colorlog
    except ImportError:
        print("依赖不满足,请查看 https://github.com/RockChinQ/qcg-installer/issues/15")
@@ -23,16 +27,15 @@ import colorlog
 import requests
 import websockets.exceptions
 from urllib3.exceptions import InsecureRequestWarning
+import pkg.utils.context


-sys.path.append(".")
-
 log_colors_config = {
    'DEBUG': 'green',  # cyan white
    'INFO': 'white',
    'WARNING': 'yellow',
    'ERROR': 'red',
-    'CRITICAL': 'bold_red',
+    'CRITICAL': 'cyan',
 }


@@ -74,11 +77,8 @@ def init_runtime_log_file():

 def reset_logging():
    global log_file_name
-    assert os.path.exists('config.py')

-    config = importlib.import_module('config')
-
-    import pkg.utils.context
+    import config

    if pkg.utils.context.context['logger_handler'] is not None:
        logging.getLogger().removeHandler(pkg.utils.context.context['logger_handler'])
@@ -106,12 +106,46 @@ def reset_logging():
    return sh


-def main(first_time_init=False):
+# 临时函数，用于加载config和上下文，未来统一放在config类
+def load_config():
+    # 完整性校验
+    is_integrity = True
+    config_template = importlib.import_module('config-template')
+    config = importlib.import_module('config')
+    for key in dir(config_template):
+        if not key.startswith("__") and not hasattr(config, key):
+            setattr(config, key, getattr(config_template, key))
+            logging.warning("[{}]不存在".format(key))
+            is_integrity = False
+    
+    if not is_integrity:
+        logging.warning("配置文件不完整，请依据config-template.py检查config.py")
+
+    # 检查override.json覆盖
+    if os.path.exists("override.json"):
+        override_json = json.load(open("override.json", "r", encoding="utf-8"))
+        for key in override_json:
+            if hasattr(config, key):
+                setattr(config, key, override_json[key])
+                logging.info("覆写配置[{}]为[{}]".format(key, override_json[key]))
+            else:
+                logging.error("无法覆写配置[{}]为[{}]，该配置不存在，请检查override.json是否正确".format(key, override_json[key]))
+
+    if not is_integrity:
+        logging.warning("以上配置已被设为默认值，将在5秒后继续启动... ")
+        time.sleep(5)
+
+    # 存进上下文
+    pkg.utils.context.set_config(config)
+
+
+def start(first_time_init=False):
    """启动流程，reload之后会被执行"""

    global known_exception_caught
+    import pkg.utils.context

-    import config
+    config = pkg.utils.context.get_config()
    # 更新openai库到最新版本
    if not hasattr(config, 'upgrade_dependencies') or config.upgrade_dependencies:
        print("正在更新依赖库，请等待...")
@@ -126,30 +160,9 @@ def main(first_time_init=False):

    known_exception_caught = False
    try:
-        # 导入config.py
-        assert os.path.exists('config.py')
-
-        config = importlib.import_module('config')
-
-        init_runtime_log_file()

        sh = reset_logging()
-
-        # 配置完整性校验
-        is_integrity = True
-        config_template = importlib.import_module('config-template')
-        for key in dir(config_template):
-            if not key.startswith("__") and not hasattr(config, key):
-                setattr(config, key, getattr(config_template, key))
-                logging.warning("[{}]不存在".format(key))
-                is_integrity = False
-        if not is_integrity:
-            logging.warning("配置文件不完整，请依据config-template.py检查config.py")
-            logging.warning("以上配置已被设为默认值，将在5秒后继续启动... ")
-            time.sleep(5)
-
-        import pkg.utils.context
-        pkg.utils.context.set_config(config)
+        pkg.utils.context.context['logger_handler'] = sh

        # 检查是否设置了管理员
        if not (hasattr(config, 'admin_qq') and config.admin_qq != 0):
@@ -180,10 +193,21 @@ def main(first_time_init=False):
        import pkg.openai.session
        import pkg.qqbot.manager
        import pkg.openai.dprompt
+        import pkg.qqbot.cmds.mgr
+        
+        try:
+            pkg.openai.dprompt.register_all()
+            pkg.qqbot.cmds.mgr.register_all()
+            pkg.qqbot.cmds.mgr.apply_privileges()
+        except Exception as e:
+            logging.error(e)
+            traceback.print_exc()

-        pkg.openai.dprompt.read_prompt_from_file()
+        # 配置openai api_base
+        if "reverse_proxy" in config.openai_config and config.openai_config["reverse_proxy"] is not None:
+            import openai
+            openai.api_base = config.openai_config["reverse_proxy"]

-        pkg.utils.context.context['logger_handler'] = sh
        # 主启动流程
        database = pkg.database.manager.DatabaseManager()

@@ -197,7 +221,7 @@ def main(first_time_init=False):
        # 初始化qq机器人
        qqbot = pkg.qqbot.manager.QQBotManager(mirai_http_api_config=config.mirai_http_api_config,
                                               timeout=config.process_message_timeout, retry=config.retry_times,
-                                               first_time_init=first_time_init, pool_num=config.pool_num)
+                                               first_time_init=first_time_init)

        # 加载插件
        import pkg.plugin.host
@@ -251,11 +275,19 @@ def main(first_time_init=False):
                            "捕捉到未知异常:{}, 请前往 https://github.com/RockChinQ/QChatGPT/issues 查找或提issue".format(e))
                        known_exception_caught = True
                        raise e
-
-            qq_bot_thread = threading.Thread(target=run_bot_wrapper, args=(), daemon=True)
-            qq_bot_thread.start()
+                finally:
+                    time.sleep(12)
+            threading.Thread(
+                target=run_bot_wrapper
+            ).start()
    finally:
+        # 判断若是Windows，输出选择模式可能会暂停程序的警告
+        if os.name == 'nt':
+            time.sleep(2)
+            logging.info("您正在使用Windows系统，若命令行窗口处于“选择”模式，程序可能会被暂停，此时请右键点击窗口空白区域使其取消选择模式。")
+
        time.sleep(12)
+        
        if first_time_init:
            if not known_exception_caught:
                logging.info('程序启动完成,如长时间未显示 ”成功登录到账号xxxxx“ ,并且不回复消息,请查看 '
@@ -287,18 +319,24 @@ def main(first_time_init=False):
    import pkg.utils.updater
    try:
        if pkg.utils.updater.is_new_version_available():
-            pkg.utils.context.get_qqbot_manager().notify_admin("新版本可用，请发送 !update 进行自动更新\n更新日志:\n{}".format("\n".join(pkg.utils.updater.get_rls_notes())))
+            logging.info("新版本可用，请发送 !update 进行自动更新\n更新日志:\n{}".format("\n".join(pkg.utils.updater.get_rls_notes())))
        else:
            logging.info("当前已是最新版本")

    except Exception as e:
        logging.warning("检查更新失败:{}".format(e))

+    try:
+        import pkg.utils.announcement as announcement
+        new_announcement = announcement.fetch_new()
+        if new_announcement != "":
+            logging.critical("[公告] {}".format(new_announcement))
+    except Exception as e:
+        logging.warning("获取公告失败:{}".format(e))
+
    return qqbot

-
 def stop():
-    import pkg.utils.context
    import pkg.qqbot.manager
    import pkg.openai.session
    try:
@@ -317,8 +355,8 @@ def stop():
            raise e


-if __name__ == '__main__':
-    # 检查是否有config.py,如果没有就把config-template.py复制一份,并退出程序
+def check_file():
+    # 配置文件存在性校验
    if not os.path.exists('config.py'):
        shutil.copy('config-template.py', 'config.py')
        print('请先在config.py中填写配置')
@@ -332,6 +370,14 @@ if __name__ == '__main__':
    if not os.path.exists("sensitive.json"):
        shutil.copy("sensitive-template.json", "sensitive.json")

+    # 检查是否有scenario/default.json
+    if not os.path.exists("scenario/default.json"):
+        shutil.copy("scenario/default-template.json", "scenario/default.json")
+
+    # 检查cmdpriv.json
+    if not os.path.exists("cmdpriv.json"):
+        shutil.copy("cmdpriv-template.json", "cmdpriv.json")
+
    # 检查temp目录
    if not os.path.exists("temp/"):
        os.mkdir("temp/")
@@ -342,6 +388,30 @@ if __name__ == '__main__':
        if not os.path.exists(path):
            os.mkdir(path)

+
+def main():
+    # 初始化相关文件
+    check_file()
+
+    # 初始化logging
+    init_runtime_log_file()
+    pkg.utils.context.context['logger_handler'] = reset_logging()
+
+    # 加载配置
+    load_config()
+    config = pkg.utils.context.get_config()
+
+    # 配置线程池
+    from pkg.utils import ThreadCtl
+    thread_ctl = ThreadCtl(
+        sys_pool_num=config.sys_pool_num,
+        admin_pool_num=config.admin_pool_num,
+        user_pool_num=config.user_pool_num
+    )
+    # 存进上下文
+    pkg.utils.context.set_thread_ctl(thread_ctl)
+
+    # 启动指令处理
    if len(sys.argv) > 1 and sys.argv[1] == 'init_db':
        init_db()
        sys.exit(0)
@@ -352,19 +422,29 @@ if __name__ == '__main__':
        updater.update_all(cli=True)
        sys.exit(0)

-    # import pkg.utils.configmgr
-    #
-    # pkg.utils.configmgr.set_config_and_reload("quote_origin", False)
+    # 关闭urllib的http警告
    requests.packages.urllib3.disable_warnings(InsecureRequestWarning)

-    qqbot = main(True)
+    pkg.utils.context.get_thread_ctl().submit_sys_task(
+        start,
+        True
+    )

-    import pkg.utils.context
+    # 主线程循环
    while True:
        try:
-            time.sleep(10)
-        except KeyboardInterrupt:
+            time.sleep(0xFF)
+        except:
            stop()
+            pkg.utils.context.get_thread_ctl().shutdown()
+            import platform
+            if platform.system() == 'Windows':
+                cmd = "taskkill /F /PID {}".format(os.getpid())
+            elif platform.system() in ['Linux', 'Darwin']:
+                cmd = "kill -9 {}".format(os.getpid())
+            os.system(cmd)
+
+
+if __name__ == '__main__':
+    main()

-            print("程序退出")
-            sys.exit(0)
--- a/override-all.json
+++ b/override-all.json
@@ -0,0 +1,78 @@
+{
+    "comment": "这是override.json支持的字段全集, 关于override.json机制, 请查看https://github.com/RockChinQ/QChatGPT/pull/271",
+    "mirai_http_api_config": {
+        "adapter": "WebSocketAdapter",
+        "host": "localhost",
+        "port": 8080,
+        "verifyKey": "yirimirai",
+        "qq": 1234567890
+    },
+    "openai_config": {
+        "api_key": {
+            "default": "openai_api_key"
+        },
+        "http_proxy": null,
+        "reverse_proxy": null
+    },
+    "admin_qq": 0,
+    "default_prompt": {
+        "default": "如果我之后想获取帮助，请你说“输入!help获取帮助”"
+    },
+    "preset_mode": "normal",
+    "response_rules": {
+        "at": true,
+        "prefix": [
+            "/ai",
+            "!ai",
+            "！ai",
+            "ai"
+        ],
+        "regexp": [],
+        "random_rate": 0.0
+    },
+    "ignore_rules": {
+        "prefix": [
+            "/"
+        ],
+        "regexp": []
+    },
+    "income_msg_check": false,
+    "sensitive_word_filter": true,
+    "baidu_check": false,
+    "baidu_api_key": "",
+    "baidu_secret_key": "",
+    "inappropriate_message_tips": "[百度云]请珍惜机器人，当前返回内容不合规",
+    "encourage_sponsor_at_start": true,
+    "prompt_submit_length": 2048,
+    "completion_api_params": {
+        "model": "gpt-3.5-turbo",
+        "temperature": 0.9,
+        "top_p": 1,
+        "frequency_penalty": 0.2,
+        "presence_penalty": 1.0
+    },
+    "image_api_params": {
+        "size": "256x256"
+    },
+    "quote_origin": true,
+    "include_image_description": true,
+    "process_message_timeout": 30,
+    "show_prefix": false,
+    "blob_message_threshold": 256,
+    "blob_message_strategy": "forward",
+    "font_path": "",
+    "retry_times": 3,
+    "hide_exce_info_to_user": false,
+    "alter_tip_message": "出错了，请稍后再试",
+    "sys_pool_num": 8,
+    "admin_pool_num": 2,
+    "user_pool_num": 6,
+    "session_expire_time": 1200,
+    "rate_limitation": 60,
+    "rate_limit_strategy": "wait",
+    "rate_limit_drop_tip": "本分钟对话次数超过限速次数，此对话被丢弃",
+    "upgrade_dependencies": true,
+    "report_usage": true,
+    "logging_level": 20,
+    "help_message": "此机器人通过调用OpenAI的GPT-3大型语言模型生成回复，不具有情感。\n你可以用自然语言与其交流，回复的消息中[GPT]开头的为模型生成的语言，[bot]开头的为程序提示。\n了解此项目请找QQ 1010553892 联系作者\n请不要用其生成整篇文章或大段代码，因为每次只会向模型提交少部分文字，生成大部分文字会产生偏题、前后矛盾等问题\n每次会话最后一次交互后20分钟后会自动结束，结束后将开启新会话，如需继续前一次会话请发送 !last 重新开启\n欢迎到github.com/RockChinQ/QChatGPT 给个star\n\n指令帮助信息请查看: https://github.com/RockChinQ/QChatGPT/wiki/%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8#%E6%9C%BA%E5%99%A8%E4%BA%BA%E6%8C%87%E4%BB%A4"
+}
--- a/pkg/audit/gatherer.py
+++ b/pkg/audit/gatherer.py
@@ -46,7 +46,7 @@ class DataGatherer:
            config = pkg.utils.context.get_config()
            if hasattr(config, "report_usage") and not config.report_usage:
                return
-            res = requests.get("http://rockchin.top:18989/usage?service_name=qchatgpt.{}&version={}&count={}".format(subservice_name, self.version_str, count))
+            res = requests.get("http://reports.rockchin.top:18989/usage?service_name=qchatgpt.{}&version={}&count={}".format(subservice_name, self.version_str, count))
            if res.status_code != 200 or res.text != "ok":
                logging.warning("report to server failed, status_code: {}, text: {}".format(res.status_code, res.text))
        except:
--- a/pkg/database/manager.py
+++ b/pkg/database/manager.py
@@ -35,6 +35,7 @@ class DatabaseManager:

    def __execute__(self, *args, **kwargs) -> Cursor:
        # logging.debug('SQL: {}'.format(sql))
+        logging.debug('SQL: {}'.format(args))
        c = self.cursor.execute(*args, **kwargs)
        self.conn.commit()
        return c
@@ -52,10 +53,30 @@ class DatabaseManager:
            `create_timestamp` bigint not null,
            `last_interact_timestamp` bigint not null,
            `status` varchar(255) not null default 'on_going',
-            `prompt` text not null
+            `default_prompt` text not null default '',
+            `prompt` text not null,
+            `token_counts` text not null default '[]'
        )
        """)

+        # 检查sessions表是否存在`default_prompt`字段, 检查是否存在`token_counts`字段
+        self.__execute__("PRAGMA table_info('sessions')")
+        columns = self.cursor.fetchall()
+        has_default_prompt = False
+        has_token_counts = False
+        for field in columns:
+            if field[1] == 'default_prompt':
+                has_default_prompt = True
+            if field[1] == 'token_counts':
+                has_token_counts = True
+            if has_default_prompt and has_token_counts:
+                break
+        if not has_default_prompt:
+            self.__execute__("alter table `sessions` add column `default_prompt` text not null default ''")
+        if not has_token_counts:
+            self.__execute__("alter table `sessions` add column `token_counts` text not null default '[]'")
+
+
        self.__execute__("""
        create table if not exists `account_fee`(
            `id` INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -75,7 +96,7 @@ class DatabaseManager:

    # session持久化
    def persistence_session(self, subject_type: str, subject_number: int, create_timestamp: int,
-                            last_interact_timestamp: int, prompt: str):
+                            last_interact_timestamp: int, prompt: str, default_prompt: str = '', token_counts: str = ''):
        """持久化指定session"""

        # 检查是否已经有了此name和create_timestamp的session
@@ -88,20 +109,20 @@ class DatabaseManager:
        if count == 0:

            sql = """
-            insert into `sessions` (`name`, `type`, `number`, `create_timestamp`, `last_interact_timestamp`, `prompt`) 
-            values (?, ?, ?, ?, ?, ?)
+            insert into `sessions` (`name`, `type`, `number`, `create_timestamp`, `last_interact_timestamp`, `prompt`, `default_prompt`, `token_counts`) 
+            values (?, ?, ?, ?, ?, ?, ?, ?)
            """

            self.__execute__(sql,
                             ("{}_{}".format(subject_type, subject_number), subject_type, subject_number, create_timestamp,
-                          last_interact_timestamp, prompt))
+                          last_interact_timestamp, prompt, default_prompt, token_counts))
        else:
            sql = """
-            update `sessions` set `last_interact_timestamp` = ?, `prompt` = ? 
+            update `sessions` set `last_interact_timestamp` = ?, `prompt` = ?, `token_counts` = ?
            where `type` = ? and `number` = ? and `create_timestamp` = ?
            """

-            self.__execute__(sql, (last_interact_timestamp, prompt, subject_type,
+            self.__execute__(sql, (last_interact_timestamp, prompt, token_counts, subject_type,
                                   subject_number, create_timestamp))

    # 显式关闭一个session
@@ -126,7 +147,7 @@ class DatabaseManager:
        # 从数据库中加载所有还没过期的session
        config = pkg.utils.context.get_config()
        self.__execute__("""
-        select `name`, `type`, `number`, `create_timestamp`, `last_interact_timestamp`, `prompt`, `status`
+        select `name`, `type`, `number`, `create_timestamp`, `last_interact_timestamp`, `prompt`, `status`, `default_prompt`, `token_counts`
        from `sessions` where `last_interact_timestamp` > {}
        """.format(int(time.time()) - config.session_expire_time))
        results = self.cursor.fetchall()
@@ -139,6 +160,8 @@ class DatabaseManager:
            last_interact_timestamp = result[4]
            prompt = result[5]
            status = result[6]
+            default_prompt = result[7]
+            token_counts = result[8]

            # 当且仅当最后一个该对象的会话是on_going状态时，才会被加载
            if status == 'on_going':
@@ -147,7 +170,9 @@ class DatabaseManager:
                    'subject_number': subject_number,
                    'create_timestamp': create_timestamp,
                    'last_interact_timestamp': last_interact_timestamp,
-                    'prompt': prompt
+                    'prompt': prompt,
+                    'default_prompt': default_prompt,
+                    'token_counts': token_counts
                }
            else:
                if session_name in sessions:
@@ -159,7 +184,7 @@ class DatabaseManager:
    def last_session(self, session_name: str, cursor_timestamp: int):

        self.__execute__("""
-        select `name`, `type`, `number`, `create_timestamp`, `last_interact_timestamp`, `prompt`, `status`
+        select `name`, `type`, `number`, `create_timestamp`, `last_interact_timestamp`, `prompt`, `status`, `default_prompt`, `token_counts`
        from `sessions` where `name` = '{}' and `last_interact_timestamp` < {} order by `last_interact_timestamp` desc
        limit 1
        """.format(session_name, cursor_timestamp))
@@ -175,20 +200,24 @@ class DatabaseManager:
        last_interact_timestamp = result[4]
        prompt = result[5]
        status = result[6]
+        default_prompt = result[7]
+        token_counts = result[8]

        return {
            'subject_type': subject_type,
            'subject_number': subject_number,
            'create_timestamp': create_timestamp,
            'last_interact_timestamp': last_interact_timestamp,
-            'prompt': prompt
+            'prompt': prompt,
+            'default_prompt': default_prompt,
+            'token_counts': token_counts
        }

    # 获取此session_name后一个session的数据
    def next_session(self, session_name: str, cursor_timestamp: int):

        self.__execute__("""
-            select `name`, `type`, `number`, `create_timestamp`, `last_interact_timestamp`, `prompt`, `status`
+            select `name`, `type`, `number`, `create_timestamp`, `last_interact_timestamp`, `prompt`, `status`, `default_prompt`, `token_counts`
            from `sessions` where `name` = '{}' and `last_interact_timestamp` > {} order by `last_interact_timestamp` asc
            limit 1
            """.format(session_name, cursor_timestamp))
@@ -204,19 +233,23 @@ class DatabaseManager:
        last_interact_timestamp = result[4]
        prompt = result[5]
        status = result[6]
+        default_prompt = result[7]
+        token_counts = result[8]

        return {
            'subject_type': subject_type,
            'subject_number': subject_number,
            'create_timestamp': create_timestamp,
            'last_interact_timestamp': last_interact_timestamp,
-            'prompt': prompt
+            'prompt': prompt,
+            'default_prompt': default_prompt,
+            'token_counts': token_counts
        }

    # 列出与某个对象的所有对话session
    def list_history(self, session_name: str, capacity: int, page: int):
        self.__execute__("""
-        select `name`, `type`, `number`, `create_timestamp`, `last_interact_timestamp`, `prompt`, `status`
+        select `name`, `type`, `number`, `create_timestamp`, `last_interact_timestamp`, `prompt`, `status`, `default_prompt`, `token_counts`
        from `sessions` where `name` = '{}' order by `last_interact_timestamp` desc limit {} offset {}
        """.format(session_name, capacity, capacity * page))
        results = self.cursor.fetchall()
@@ -229,17 +262,42 @@ class DatabaseManager:
            last_interact_timestamp = result[4]
            prompt = result[5]
            status = result[6]
+            default_prompt = result[7]
+            token_counts = result[8]

            sessions.append({
                'subject_type': subject_type,
                'subject_number': subject_number,
                'create_timestamp': create_timestamp,
                'last_interact_timestamp': last_interact_timestamp,
-                'prompt': prompt
+                'prompt': prompt,
+                'default_prompt': default_prompt,
+                'token_counts': token_counts
            })

        return sessions

+    def delete_history(self, session_name: str, index: int) -> bool:
+        # 删除倒序第index个session
+        # 查找其id再删除
+        self.__execute__("""
+        delete from `sessions` where `id` in (select `id` from `sessions` where `name` = '{}' order by `last_interact_timestamp` desc limit 1 offset {})
+        """.format(session_name, index))
+
+        return self.cursor.rowcount == 1
+
+    def delete_all_history(self, session_name: str) -> bool:
+        self.__execute__("""
+        delete from `sessions` where `name` = '{}'
+        """.format(session_name))
+        return self.cursor.rowcount > 0
+
+    def delete_all_session_history(self) -> bool:
+        self.__execute__("""
+        delete from `sessions`
+        """)
+        return self.cursor.rowcount > 0
+
    # 将apikey的使用量存进数据库
    def dump_api_key_usage(self, api_keys: dict, usage: dict):
        logging.debug('dumping api key usage...')
--- a/pkg/openai/dprompt.py
+++ b/pkg/openai/dprompt.py
@@ -1,79 +1,145 @@
 # 多情景预设值管理
+import json
+import logging
+import config
+import os

-__current__ = "default"
-"""当前默认使用的情景预设的名称
+# __current__ = "default"
+# """当前默认使用的情景预设的名称

-由管理员使用`!default <名称>`指令切换
-"""
+# 由管理员使用`!default <名称>`指令切换
+# """

-__prompts_from_files__ = {}
-"""从文件中读取的情景预设值"""
+# __prompts_from_files__ = {}
+# """从文件中读取的情景预设值"""
+
+# __scenario_from_files__ = {}


-def read_prompt_from_file() -> str:
-    """从文件读取预设值"""
-    # 读取prompts/目录下的所有文件，以文件名为键，文件内容为值
-    # 保存在__prompts_from_files__中
-    global __prompts_from_files__
-    import os
-
-    __prompts_from_files__ = {}
-    for file in os.listdir("prompts"):
-        with open(os.path.join("prompts", file), encoding="utf-8") as f:
-            __prompts_from_files__[file] = f.read()
+__universal_first_reply__ = "ok, I'll follow your commands."
+"""通用首次回复"""


-def get_prompt_dict() -> dict:
-    """获取预设值字典"""
+class ScenarioMode:
+    """情景预设模式抽象类"""
+
+    using_prompt_name = "default"
+    """新session创建时使用的prompt名称"""
+
+    prompts: dict[str, list] = {}
+
+    def __init__(self):
+        logging.debug("prompts: {}".format(self.prompts))
+
+    def list(self) -> dict[str, list]:
+        """获取所有情景预设的名称及内容"""
+        return self.prompts
+
+    def get_prompt(self, name: str) -> tuple[list, str]:
+        """获取指定情景预设的名称及内容"""
+        for key in self.prompts:
+            if key.startswith(name):
+                return self.prompts[key], key
+        raise Exception("没有找到情景预设: {}".format(name))
+
+    def set_using_name(self, name: str) -> str:
+        """设置默认情景预设"""
+        for key in self.prompts:
+            if key.startswith(name):
+                self.using_prompt_name = key
+                return key
+        raise Exception("没有找到情景预设: {}".format(name))
+    
+    def get_full_name(self, name: str) -> str:
+        """获取完整的情景预设名称"""
+        for key in self.prompts:
+            if key.startswith(name):
+                return key
+        raise Exception("没有找到情景预设: {}".format(name))
+
+    def get_using_name(self) -> str:
+        """获取默认情景预设"""
+        return self.using_prompt_name
+
+
+class NormalScenarioMode(ScenarioMode):
+    """普通情景预设模式"""
+
+    def __init__(self):
+        global __universal_first_reply__
+        # 加载config中的default_prompt值
+        if type(config.default_prompt) == str:
+            self.using_prompt_name = "default"
+            self.prompts = {"default": [
+                {
+                    "role": "user",
+                    "content": config.default_prompt
+                },{
+                    "role": "assistant",
+                    "content": __universal_first_reply__
+                }
+            ]}
+        
+        elif type(config.default_prompt) == dict:
+            for key in config.default_prompt:
+                self.prompts[key] = [
+                    {
+                        "role": "user",
+                        "content": config.default_prompt[key]
+                    },{
+                        "role": "assistant",
+                        "content": __universal_first_reply__
+                    }
+                ]
+
+        # 从prompts/目录下的文件中载入
+        # 遍历文件
+        for file in os.listdir("prompts"):
+            with open(os.path.join("prompts", file), encoding="utf-8") as f:
+                self.prompts[file] = [
+                    {
+                        "role": "user",
+                        "content": f.read()
+                    },{
+                        "role": "assistant",
+                        "content": __universal_first_reply__
+                    }
+                ]
+
+
+class FullScenarioMode(ScenarioMode):
+    """完整情景预设模式"""
+
+    def __init__(self):
+        """从json读取所有"""
+        # 遍历scenario/目录下的所有文件，以文件名为键，文件内容中的prompt为值
+        for file in os.listdir("scenario"):
+            if file == "default-template.json":
+                continue
+            with open(os.path.join("scenario", file), encoding="utf-8") as f:
+                self.prompts[file] = json.load(f)["prompt"]
+
+        super().__init__()
+
+
+scenario_mode_mapping = {}
+"""情景预设模式名称与对象的映射"""
+
+
+def register_all():
+    """注册所有情景预设模式，不使用装饰器，因为装饰器的方式不支持热重载"""
+    global scenario_mode_mapping
+    scenario_mode_mapping = {
+        "normal": NormalScenarioMode(),
+        "full_scenario": FullScenarioMode()
+    }
+
+
+def mode_inst() -> ScenarioMode:
+    """获取指定名称的情景预设模式对象"""
    import config
-    default_prompt = config.default_prompt
-    if type(default_prompt) == str:
-        default_prompt = {"default": default_prompt}
-    elif type(default_prompt) == dict:
-        pass
-    else:
-        raise TypeError("default_prompt must be str or dict")

-    # 将文件中的预设值合并到default_prompt中
-    for key in __prompts_from_files__:
-        default_prompt[key] = __prompts_from_files__[key]
+    if config.preset_mode == "default":
+        config.preset_mode = "normal"

-    return default_prompt
-
-
-def set_current(name):
-    global __current__
-    for key in get_prompt_dict():
-        if key.lower().startswith(name.lower()):
-            __current__ = key
-            return
-    raise KeyError("未找到情景预设: " + name)
-
-
-def get_current():
-    global __current__
-    return __current__
-
-
-def set_to_default():
-    global __current__
-    default_dict = get_prompt_dict()
-
-    if "default" in default_dict:
-        __current__ = "default"
-    else:
-        __current__ = list(default_dict.keys())[0]
-
-
-def get_prompt(name: str = None) -> str:
-    """获取预设值"""
-    if name is None:
-        name = get_current()
-
-    default_dict = get_prompt_dict()
-
-    for key in default_dict:
-        if key.lower().startswith(name.lower()):
-            return default_dict[key]
-
-    raise KeyError("未找到情景预设: " + name)
+    return scenario_mode_mapping[config.preset_mode]
--- a/pkg/openai/keymgr.py
+++ b/pkg/openai/keymgr.py
@@ -88,4 +88,4 @@ class KeysManager:
        for key_name in self.api_key:
            if self.api_key[key_name] == api_key:
                return key_name
-        return ""
+        return ""
--- a/pkg/openai/manager.py
+++ b/pkg/openai/manager.py
@@ -34,7 +34,7 @@ class OpenAIInteract:
        pkg.utils.context.set_openai_manager(self)

    # 请求OpenAI Completion
-    def request_completion(self, prompts) -> str:
+    def request_completion(self, prompts) -> tuple[str, int]:
        """请求补全接口回复

        Parameters:
@@ -48,8 +48,8 @@ class OpenAIInteract:

        # 根据模型选择使用的接口
        ai: ModelRequest = create_openai_model_request(
-            config.completion_api_params['model'], 
-            'user', 
+            config.completion_api_params['model'],
+            'user',
            config.openai_config["http_proxy"] if "http_proxy" in config.openai_config else None
        )
        ai.request(
@@ -60,14 +60,18 @@ class OpenAIInteract:

        logging.debug("OpenAI response: %s", response)

+        # 记录使用量
+        current_round_token = 0
        if 'model' in config.completion_api_params:
            self.audit_mgr.report_text_model_usage(config.completion_api_params['model'],
                                                   ai.get_total_tokens())
+            current_round_token = ai.get_total_tokens()
        elif 'engine' in config.completion_api_params:
            self.audit_mgr.report_text_model_usage(config.completion_api_params['engine'],
                                                   response['usage']['total_tokens'])
+            current_round_token = response['usage']['total_tokens']

-        return ai.get_message()
+        return ai.get_message(), current_round_token

    def request_image(self, prompt) -> dict:
        """请求图片接口回复
--- a/pkg/openai/modelmgr.py
+++ b/pkg/openai/modelmgr.py
@@ -21,6 +21,10 @@ COMPLETION_MODELS = {
 CHAT_COMPLETION_MODELS = {
    'gpt-3.5-turbo',
    'gpt-3.5-turbo-0301',
+    'gpt-4',
+    'gpt-4-0314',
+    'gpt-4-32k',
+    'gpt-4-32k-0314'
 }

 EDIT_MODELS = {
--- a/pkg/openai/session.py
+++ b/pkg/openai/session.py
@@ -40,7 +40,7 @@ def reset_session_prompt(session_name, prompt):
    prompt = [
        {
            'role': 'system',
-            'content': config.default_prompt['default']
+            'content': config.default_prompt['default'] if type(config.default_prompt) == dict else config.default_prompt
        }
    ]
    # 警告
@@ -72,9 +72,12 @@ def load_sessions():
        temp_session.last_interact_timestamp = session_data[session_name]['last_interact_timestamp']
        try:
            temp_session.prompt = json.loads(session_data[session_name]['prompt'])
+            temp_session.token_counts = json.loads(session_data[session_name]['token_counts'])
        except Exception:
            temp_session.prompt = reset_session_prompt(session_name, session_data[session_name]['prompt'])
            temp_session.persistence()
+        temp_session.default_prompt = json.loads(session_data[session_name]['default_prompt']) if \
+            session_data[session_name]['default_prompt'] else []

        sessions[session_name] = temp_session

@@ -104,6 +107,12 @@ class Session:
    prompt = []
    """使用list来保存会话中的回合"""

+    token_counts = []
+    """每个回合的token数量"""
+
+    default_prompt = []
+    """本session的默认prompt"""
+
    create_timestamp = 0
    """会话创建时间"""

@@ -129,33 +138,26 @@ class Session:

    # 从配置文件获取会话预设信息
    def get_default_prompt(self, use_default: str = None):
-        config = pkg.utils.context.get_config()
-
        import pkg.openai.dprompt as dprompt

        if use_default is None:
-            current_default_prompt = dprompt.get_prompt(dprompt.get_current())
-        else:
-            current_default_prompt = dprompt.get_prompt(use_default)
+            use_default = dprompt.mode_inst().get_using_name()

-        return [
-            {
-                'role': 'user',
-                'content': current_default_prompt
-            }, {
-                'role': 'assistant',
-                'content': 'ok'
-            }
-        ]
+        current_default_prompt, _ = dprompt.mode_inst().get_prompt(use_default)
+        return current_default_prompt

    def __init__(self, name: str):
        self.name = name
        self.create_timestamp = int(time.time())
        self.last_interact_timestamp = int(time.time())
+        self.prompt = []
+        self.token_counts = []
        self.schedule()

        self.response_lock = threading.Lock()
-        self.prompt = self.get_default_prompt()
+
+        self.default_prompt = self.get_default_prompt()
+        logging.debug("prompt is: {}".format(self.default_prompt))

    # 设定检查session最后一次对话是否超过过期时间的计时器
    def schedule(self):
@@ -199,11 +201,11 @@ class Session:
        self.last_interact_timestamp = int(time.time())

        # 触发插件事件
-        if self.prompt == self.get_default_prompt():
+        if not self.prompt:
            args = {
                'session_name': self.name,
                'session': self,
-                'default_prompt': self.prompt,
+                'default_prompt': self.default_prompt,
            }

            event = pkg.plugin.host.emit(plugin_models.SessionFirstMessageReceived, **args)
@@ -213,9 +215,16 @@ class Session:
        config = pkg.utils.context.get_config()
        max_length = config.prompt_submit_length if hasattr(config, "prompt_submit_length") else 1024

+        prompts, counts = self.cut_out(text, max_length)
+
+        # 计算请求前的prompt数量
+        total_token_before_query = 0
+        for token_count in counts:
+            total_token_before_query += token_count
+
        # 向API请求补全
-        message = pkg.utils.context.get_openai_manager().request_completion(
-            self.cut_out(text, max_length),
+        message, total_token = pkg.utils.context.get_openai_manager().request_completion(
+            prompts,
        )

        # 成功获取，处理回复
@@ -232,6 +241,10 @@ class Session:
        self.prompt.append({'role': 'user', 'content': text})
        self.prompt.append({'role': 'assistant', 'content': res_ans})

+        # 向token_counts中添加本回合的token数量
+        self.token_counts.append(total_token-total_token_before_query)
+        logging.debug("本回合使用token: {}, session counts: {}".format(total_token-total_token_before_query, self.token_counts))
+
        if self.just_switched_to_exist_session:
            self.just_switched_to_exist_session = False
            self.set_ongoing()
@@ -248,35 +261,61 @@ class Session:

        question = self.prompt[-2]['content']
        self.prompt = self.prompt[:-2]
+        self.token_counts = self.token_counts[:-1]

        # 返回上一回合的问题
        return question

    # 构建对话体
-    def cut_out(self, msg: str, max_tokens: int) -> list:
-        """将现有prompt进行切割处理，使得新的prompt长度不超过max_tokens"""
-        # 如果用户消息长度超过max_tokens，直接返回
+    def cut_out(self, msg: str, max_tokens: int) -> tuple[list, list]:
+        """将现有prompt进行切割处理，使得新的prompt长度不超过max_tokens

-        temp_prompt = [
+        :return: (新的prompt, 新的token_counts)
+        """
+
+        # 最终由三个部分组成
+        # - default_prompt         情景预设固定值
+        # - changable_prompts      可变部分, 此会话中的历史对话回合
+        # - current_question       当前问题
+
+        # 包装目前的对话回合内容
+        changable_prompts = []
+        changable_counts = []
+        # 倒着来, 遍历prompt的步长为2, 遍历tokens_counts的步长为1
+        changable_index = len(self.prompt) - 1
+        token_count_index = len(self.token_counts) - 1
+
+        packed_tokens = 0
+
+        while changable_index >= 0 and token_count_index >= 0:
+            if packed_tokens + self.token_counts[token_count_index] > max_tokens:
+                break
+
+            changable_prompts.insert(0, self.prompt[changable_index])
+            changable_prompts.insert(0, self.prompt[changable_index - 1])
+            changable_counts.insert(0, self.token_counts[token_count_index])
+            packed_tokens += self.token_counts[token_count_index]
+
+            changable_index -= 2
+            token_count_index -= 1
+
+        # 将default_prompt和changable_prompts合并
+        result_prompt = self.default_prompt + changable_prompts
+
+        # 添加当前问题
+        result_prompt.append(
            {
                'role': 'user',
                'content': msg
            }
-        ]
+        )

-        token_count = len(msg)
-        # 倒序遍历prompt
-        for i in range(len(self.prompt) - 1, -1, -1):
-            if token_count >= max_tokens:
-                break
+        logging.debug('cut_out: {}\nchangable section tokens: {}\npacked counts: {}\nsession counts: {}'.format(json.dumps(result_prompt, ensure_ascii=False, indent=4),
+                                                                             packed_tokens,
+                                                                             changable_counts,
+                                                                             self.token_counts))

-            # 将prompt加到temp_prompt头部
-            temp_prompt.insert(0, self.prompt[i])
-            token_count += len(self.prompt[i]['content'])
-
-        logging.debug('cut_out: {}'.format(str(temp_prompt)))
-
-        return temp_prompt
+        return result_prompt, changable_counts

    # 持久化session
    def persistence(self):
@@ -291,11 +330,11 @@ class Session:
        subject_number = int(name_spt[1])

        db_inst.persistence_session(subject_type, subject_number, self.create_timestamp, self.last_interact_timestamp,
-                                    json.dumps(self.prompt))
+                                    json.dumps(self.prompt), json.dumps(self.default_prompt), json.dumps(self.token_counts))

    # 重置session
    def reset(self, explicit: bool = False, expired: bool = False, schedule_new: bool = True, use_prompt: str = None):
-        if self.prompt[-1]['role'] != "system":
+        if self.prompt:
            self.persistence()
            if explicit:
                # 触发插件事件
@@ -311,7 +350,10 @@ class Session:

            if expired:
                pkg.utils.context.get_database_manager().set_session_expired(self.name, self.create_timestamp)
-        self.prompt = self.get_default_prompt(use_prompt)
+
+        self.default_prompt = self.get_default_prompt(use_prompt)
+        self.prompt = []
+        self.token_counts = []
        self.create_timestamp = int(time.time())
        self.last_interact_timestamp = int(time.time())
        self.just_switched_to_exist_session = False
@@ -337,9 +379,11 @@ class Session:
            self.last_interact_timestamp = last_one['last_interact_timestamp']
            try:
                self.prompt = json.loads(last_one['prompt'])
+                self.token_counts = json.loads(last_one['token_counts'])
            except json.decoder.JSONDecodeError:
                self.prompt = reset_session_prompt(self.name, last_one['prompt'])
                self.persistence()
+            self.default_prompt = json.loads(last_one['default_prompt']) if last_one['default_prompt'] else []

            self.just_switched_to_exist_session = True
            return self
@@ -356,9 +400,11 @@ class Session:
            self.last_interact_timestamp = next_one['last_interact_timestamp']
            try:
                self.prompt = json.loads(next_one['prompt'])
+                self.token_counts = json.loads(next_one['token_counts'])
            except json.decoder.JSONDecodeError:
                self.prompt = reset_session_prompt(self.name, next_one['prompt'])
                self.persistence()
+            self.default_prompt = json.loads(next_one['default_prompt']) if next_one['default_prompt'] else []

            self.just_switched_to_exist_session = True
            return self
@@ -366,5 +412,11 @@ class Session:
    def list_history(self, capacity: int = 10, page: int = 0):
        return pkg.utils.context.get_database_manager().list_history(self.name, capacity, page)

+    def delete_history(self, index: int) -> bool:
+        return pkg.utils.context.get_database_manager().delete_history(self.name, index)
+
+    def delete_all_history(self) -> bool:
+        return pkg.utils.context.get_database_manager().delete_all_history(self.name)
+
    def draw_image(self, prompt: str):
        return pkg.utils.context.get_openai_manager().request_image(prompt)
--- a/pkg/plugin/host.py
+++ b/pkg/plugin/host.py
@@ -5,6 +5,7 @@ import importlib
 import os
 import pkgutil
 import sys
+import shutil
 import traceback

 import pkg.utils.context as context
@@ -160,6 +161,22 @@ def install_plugin(repo_url: str):
        main.reset_logging()


+def uninstall_plugin(plugin_name: str) -> str:
+    """ 卸载插件 """
+    if plugin_name not in __plugins__:
+        raise Exception("插件不存在")
+    
+    # 获取文件夹路径
+    plugin_path = __plugins__[plugin_name]['path'].replace("\\", "/")
+
+    # 剪切路径为plugins/插件名
+    plugin_path = plugin_path.split("plugins/")[1].split("/")[0]
+
+    # 删除文件夹
+    shutil.rmtree("plugins/"+plugin_path)
+    return "plugins/"+plugin_path
+
+
 class EventContext:
    """ 事件上下文 """
    eid = 0
--- a/pkg/qqbot/blob.py
+++ b/pkg/qqbot/blob.py
@@ -1,5 +1,4 @@
 # 长消息处理相关
-import logging
 import os
 import time
 import base64
@@ -67,7 +66,7 @@ def check_text(text: str) -> list:
    """检查文本是否为长消息，并转换成该使用的消息链组件"""
    if not hasattr(config, 'blob_message_threshold'):
        return [text]
-    
+
    if len(text) > config.blob_message_threshold:
        if not hasattr(config, 'blob_message_strategy'):
            raise AttributeError('未定义长消息处理策略')
@@ -77,8 +76,6 @@ def check_text(text: str) -> list:
            # 转换成图片
            return [text_to_image(text)]
        elif config.blob_message_strategy == 'forward':
-            # 敏感词屏蔽
-            text = context.get_qqbot_manager().reply_filter.process(text)

            # 包装转发消息
            display = ForwardMessageDiaplay(
--- a/pkg/qqbot/cmds/init.py
+++ b/pkg/qqbot/cmds/init.py
--- a/pkg/qqbot/cmds/func/init.py
+++ b/pkg/qqbot/cmds/func/init.py
--- a/pkg/qqbot/cmds/func/draw.py
+++ b/pkg/qqbot/cmds/func/draw.py
@@ -0,0 +1,35 @@
+from ..mgr import AbstractCommandNode, Context
+import logging
+
+from mirai import Image
+import config
+
+
+@AbstractCommandNode.register(
+    parent=None,
+    name="draw",
+    description="使用DALL·E生成图片",
+    usage="!draw <图片提示语>",
+    aliases=[],
+    privilege=1
+)
+class DrawCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        import pkg.openai.session
+
+        reply = []
+        if len(ctx.params) == 0:
+            reply = ["[bot]err: 未提供图片描述文字"]
+        else:
+            session = pkg.openai.session.get_session(ctx.session_name)
+
+            res = session.draw_image(" ".join(ctx.params))
+
+            logging.debug("draw_image result:{}".format(res))
+            reply = [Image(url=res['data'][0]['url'])]
+            if not (hasattr(config, 'include_image_description')
+                    and not config.include_image_description):
+                reply.append(" ".join(ctx.params))
+
+        return True, reply
--- a/pkg/qqbot/cmds/mgr.py
+++ b/pkg/qqbot/cmds/mgr.py
@@ -0,0 +1,330 @@
+import importlib
+import inspect
+import logging
+import copy
+import pkgutil
+import traceback
+import types
+import json
+
+
+__command_list__ = {}
+"""命令树
+
+结构：
+{
+    'cmd1': {
+        'description': 'cmd1 description',
+        'usage': 'cmd1 usage',
+        'aliases': ['cmd1 alias1', 'cmd1 alias2'],
+        'privilege': 0,
+        'parent': None,
+        'cls': <class 'pkg.qqbot.cmds.cmd1.CommandCmd1'>,
+        'sub': [
+            'cmd1-1'
+        ]
+    },
+    'cmd1.cmd1-1: {
+        'description': 'cmd1-1 description',
+        'usage': 'cmd1-1 usage',
+        'aliases': ['cmd1-1 alias1', 'cmd1-1 alias2'],
+        'privilege': 0,
+        'parent': 'cmd1',
+        'cls': <class 'pkg.qqbot.cmds.cmd1.CommandCmd1_1'>,
+        'sub': []
+    },
+    'cmd2': {
+        'description': 'cmd2 description',
+        'usage': 'cmd2 usage',
+        'aliases': ['cmd2 alias1', 'cmd2 alias2'],
+        'privilege': 0,
+        'parent': None,
+        'cls': <class 'pkg.qqbot.cmds.cmd2.CommandCmd2'>,
+        'sub': [
+            'cmd2-1'
+        ]
+    },
+    'cmd2.cmd2-1': {
+        'description': 'cmd2-1 description',
+        'usage': 'cmd2-1 usage',
+        'aliases': ['cmd2-1 alias1', 'cmd2-1 alias2'],
+        'privilege': 0,
+        'parent': 'cmd2',
+        'cls': <class 'pkg.qqbot.cmds.cmd2.CommandCmd2_1'>,
+        'sub': [
+            'cmd2-1-1'
+        ]
+    },
+    'cmd2.cmd2-1.cmd2-1-1': {
+        'description': 'cmd2-1-1 description',
+        'usage': 'cmd2-1-1 usage',
+        'aliases': ['cmd2-1-1 alias1', 'cmd2-1-1 alias2'],
+        'privilege': 0,
+        'parent': 'cmd2.cmd2-1',
+        'cls': <class 'pkg.qqbot.cmds.cmd2.CommandCmd2_1_1'>,
+        'sub': []
+    },
+}
+"""
+
+__tree_index__: dict[str, list] = {}
+"""命令树索引
+
+结构：
+{
+    'pkg.qqbot.cmds.cmd1.CommandCmd1': 'cmd1',  # 顶级指令
+    'pkg.qqbot.cmds.cmd1.CommandCmd1_1': 'cmd1.cmd1-1',  # 类名: 节点路径
+    'pkg.qqbot.cmds.cmd2.CommandCmd2': 'cmd2',
+    'pkg.qqbot.cmds.cmd2.CommandCmd2_1': 'cmd2.cmd2-1',
+    'pkg.qqbot.cmds.cmd2.CommandCmd2_1_1': 'cmd2.cmd2-1.cmd2-1-1',
+}
+"""
+
+
+class Context:
+    """命令执行上下文"""
+    command: str
+    """顶级指令文本"""
+
+    crt_command: str
+    """当前子指令文本"""
+
+    params: list
+    """完整参数列表"""
+
+    crt_params: list
+    """当前子指令参数列表"""
+
+    session_name: str
+    """会话名"""
+
+    text_message: str
+    """指令完整文本"""
+
+    launcher_type: str
+    """指令发起者类型"""
+
+    launcher_id: int
+    """指令发起者ID"""
+
+    sender_id: int
+    """指令发送者ID"""
+
+    is_admin: bool
+    """[过时]指令发送者是否为管理员"""
+
+    privilege: int
+    """指令发送者权限等级"""
+
+    def __init__(self, **kwargs):
+        self.__dict__.update(kwargs)
+
+
+class AbstractCommandNode:
+    """指令抽象类"""
+
+    parent: type
+    """父指令类"""
+
+    name: str
+    """指令名"""
+
+    description: str
+    """指令描述"""
+
+    usage: str
+    """指令用法"""
+
+    aliases: list[str]
+    """指令别名"""
+
+    privilege: int
+    """指令权限等级, 权限大于等于此值的用户才能执行指令"""
+
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        """指令处理函数
+        
+        :param ctx: 指令执行上下文
+
+        :return: (是否执行, 回复列表(若执行))
+
+        若未执行，将自动以下一个参数查找并执行子指令
+        """
+        raise NotImplementedError
+    
+    @classmethod
+    def help(cls) -> str:
+        """获取指令帮助信息"""
+        return '指令: {}\n描述: {}\n用法: \n{}\n别名: {}\n权限: {}'.format(
+            cls.name,
+            cls.description,
+            cls.usage,
+            ', '.join(cls.aliases),
+            cls.privilege
+        )
+
+    @staticmethod
+    def register(
+        parent: type = None,
+        name: str = None,
+        description: str = None,
+        usage: str = None,
+        aliases: list[str] = None,
+        privilege: int = 0
+    ):
+        """注册指令
+        
+        :param cls: 指令类
+        :param name: 指令名
+        :param parent: 父指令类
+        """
+        global __command_list__, __tree_index__
+        
+        def wrapper(cls):
+            cls.name = name
+            cls.parent = parent
+            cls.description = description
+            cls.usage = usage
+            cls.aliases = aliases
+            cls.privilege = privilege
+
+            logging.debug("cls: {}, name: {}, parent: {}".format(cls, name, parent))
+
+            if parent is None:
+                # 顶级指令注册
+                __command_list__[name] = {
+                    'description': cls.description,
+                    'usage': cls.usage,
+                    'aliases': cls.aliases,
+                    'privilege': cls.privilege,
+                    'parent': None,
+                    'cls': cls,
+                    'sub': []
+                }
+                # 更新索引
+                __tree_index__[cls.__module__ + '.' + cls.__name__] = name
+            else:
+                # 获取父节点名称
+                path = __tree_index__[parent.__module__ + '.' + parent.__name__]
+                
+                parent_node = __command_list__[path]
+                # 链接父子指令
+                __command_list__[path]['sub'].append(name)
+                # 注册子指令
+                __command_list__[path + '.' + name] = {
+                    'description': cls.description,
+                    'usage': cls.usage,
+                    'aliases': cls.aliases,
+                    'privilege': cls.privilege,
+                    'parent': path,
+                    'cls': cls,
+                    'sub': []
+                }
+                # 更新索引
+                __tree_index__[cls.__module__ + '.' + cls.__name__] = path + '.' + name
+
+            return cls
+        
+        return wrapper
+
+
+class CommandPrivilegeError(Exception):
+    """指令权限不足或不存在异常"""
+    pass
+
+
+# 传入Context对象，广搜命令树，返回执行结果
+# 若命令被处理，返回reply列表
+# 若命令未被处理，继续执行下一级指令
+# 若命令不存在，报异常
+def execute(context: Context) -> list:
+    """执行指令
+    
+    :param ctx: 指令执行上下文
+
+    :return: 回复列表
+    """
+    global __command_list__
+
+    # 拷贝ctx
+    ctx: Context = copy.deepcopy(context)
+
+    # 从树取出顶级指令
+    node = __command_list__
+    
+    path = ctx.command
+
+    while True:
+        try:
+            logging.debug('执行指令: {}'.format(path))
+            node = __command_list__[path]
+
+            # 检查权限
+            if ctx.privilege < node['privilege']:
+                raise CommandPrivilegeError('权限不足: {}'.format(path))
+            
+            # 执行
+            execed, reply = node['cls'].process(ctx)
+            if execed:
+                return reply
+            else:
+                # 删除crt_params第一个参数
+                ctx.crt_command = ctx.crt_params.pop(0)
+                # 下一个path
+                path = path + '.' + ctx.crt_command
+        except KeyError:
+            traceback.print_exc()
+            raise CommandPrivilegeError('找不到指令: {}'.format(path))
+
+
+def register_all():
+    """启动时调用此函数注册所有指令
+    
+    递归处理pkg.qqbot.cmds包下及其子包下所有模块的所有继承于AbstractCommand的类
+    """
+    # 模块：遍历其中的继承于AbstractCommand的类，进行注册
+    # 包：递归处理包下的模块
+    # 排除__开头的属性
+    global __command_list__, __tree_index__
+
+    import pkg.qqbot.cmds
+
+    def walk(module, prefix, path_prefix):
+        # 排除不处于pkg.qqbot.cmds中的包
+        if not module.__name__.startswith('pkg.qqbot.cmds'):
+            return
+        
+        logging.debug('walk: {}, path: {}'.format(module.__name__, module.__path__))
+        for item in pkgutil.iter_modules(module.__path__):
+            if item.name.startswith('__'):
+                continue
+
+            if item.ispkg:
+                walk(__import__(module.__name__ + '.' + item.name, fromlist=['']), prefix + item.name + '.', path_prefix + item.name + '/')
+            else:
+                m = __import__(module.__name__ + '.' + item.name, fromlist=[''])
+                # for name, cls in inspect.getmembers(m, inspect.isclass):
+                #     # 检查是否为指令类
+                #     if cls.__module__ == m.__name__ and issubclass(cls, AbstractCommandNode) and cls != AbstractCommandNode:
+                #         cls.register(cls, cls.name, cls.parent)
+
+    walk(pkg.qqbot.cmds, '', '')
+    logging.debug(__command_list__)
+
+
+def apply_privileges():
+    """读取cmdpriv.json并应用指令权限"""
+    # 读取内容
+    json_str = ""
+    with open('cmdpriv.json', 'r', encoding="utf-8") as f:
+        json_str = f.read()
+
+    data = json.loads(json_str)
+    for path, priv in data.items():
+        if path == 'comment':
+            continue
+        if __command_list__[path]['privilege'] != priv:
+            logging.debug('应用权限: {} -> {}(default: {})'.format(path, priv, __command_list__[path]['privilege']))
+
+        __command_list__[path]['privilege'] = priv
--- a/pkg/qqbot/cmds/plugin/init.py
+++ b/pkg/qqbot/cmds/plugin/init.py
--- a/pkg/qqbot/cmds/plugin/plugin.py
+++ b/pkg/qqbot/cmds/plugin/plugin.py
@@ -0,0 +1,195 @@
+from ..mgr import AbstractCommandNode, Context
+
+import os
+
+import pkg.plugin.host as plugin_host
+import pkg.utils.updater as updater
+
+
+@AbstractCommandNode.register(
+    parent=None,
+    name="plugin",
+    description="插件管理",
+    usage="!plugin\n!plugin get <插件仓库地址>\!plugin update\n!plugin del <插件名>\n!plugin on <插件名>\n!plugin off <插件名>",
+    aliases=[],
+    privilege=2
+)
+class PluginCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        reply = []
+        plugin_list = plugin_host.__plugins__
+        if len(ctx.params) == 0:
+            # 列出所有插件
+            
+            reply_str = "[bot]所有插件({}):\n".format(len(plugin_host.__plugins__))
+            idx = 0
+            for key in plugin_host.iter_plugins_name():
+                plugin = plugin_list[key]
+                reply_str += "\n#{} {} {}\n{}\nv{}\n作者: {}\n"\
+                    .format((idx+1), plugin['name'],
+                            "[已禁用]" if not plugin['enabled'] else "",
+                            plugin['description'],
+                            plugin['version'], plugin['author'])
+
+                if updater.is_repo("/".join(plugin['path'].split('/')[:-1])):
+                    remote_url = updater.get_remote_url("/".join(plugin['path'].split('/')[:-1]))
+                    if remote_url != "https://github.com/RockChinQ/QChatGPT" and remote_url != "https://gitee.com/RockChin/QChatGPT":
+                        reply_str += "源码: "+remote_url+"\n"
+
+                idx += 1
+
+            reply = [reply_str]
+            return True, reply
+        elif ctx.params[0].startswith("http"):
+            reply = ["[bot]err: 此命令已启用，请使用 !plugin get <插件仓库地址> 进行安装"]
+            return True, reply
+        else:
+            return False, []
+
+    
+@AbstractCommandNode.register(
+    parent=PluginCommand,
+    name="get",
+    description="安装插件",
+    usage="!plugin get <插件仓库地址>",
+    aliases=[],
+    privilege=2
+)
+class PluginGetCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        import threading
+        import logging
+        import pkg.utils.context
+
+        if len(ctx.crt_params) == 0:
+            reply = ["[bot]err: 请提供插件仓库地址"]
+            return True, reply
+        
+        reply = []
+        def closure():
+            try:
+                plugin_host.install_plugin(ctx.crt_params[0])
+                pkg.utils.context.get_qqbot_manager().notify_admin("插件安装成功，请发送 !reload 指令重载插件")
+            except Exception as e:
+                logging.error("插件安装失败:{}".format(e))
+                pkg.utils.context.get_qqbot_manager().notify_admin("插件安装失败:{}".format(e))
+
+        threading.Thread(target=closure, args=()).start()
+        reply = ["[bot]正在安装插件..."]
+        return True, reply
+
+
+@AbstractCommandNode.register(
+    parent=PluginCommand,
+    name="update",
+    description="更新所有插件",
+    usage="!plugin update",
+    aliases=[],
+    privilege=2
+)
+class PluginUpdateCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        import threading
+        import logging
+        plugin_list = plugin_host.__plugins__
+
+        reply = []
+        def closure():
+            import pkg.utils.context
+            updated = []
+            for key in plugin_list:
+                plugin = plugin_list[key]
+                if updater.is_repo("/".join(plugin['path'].split('/')[:-1])):
+                    success = updater.pull_latest("/".join(plugin['path'].split('/')[:-1]))
+                    if success:
+                        updated.append(plugin['name'])
+
+            # 检查是否有requirements.txt
+            pkg.utils.context.get_qqbot_manager().notify_admin("正在安装依赖...")
+            for key in plugin_list:
+                plugin = plugin_list[key]
+                if os.path.exists("/".join(plugin['path'].split('/')[:-1])+"/requirements.txt"):
+                    logging.info("{}检测到requirements.txt，安装依赖".format(plugin['name']))
+                    import pkg.utils.pkgmgr
+                    pkg.utils.pkgmgr.install_requirements("/".join(plugin['path'].split('/')[:-1])+"/requirements.txt")
+
+                    import main
+                    main.reset_logging()
+
+            pkg.utils.context.get_qqbot_manager().notify_admin("已更新插件: {}".format(", ".join(updated)))
+
+        threading.Thread(target=closure).start()
+        reply = ["[bot]正在更新所有插件，请勿重复发起..."]
+        return True, reply
+
+
+@AbstractCommandNode.register(
+    parent=PluginCommand,
+    name="del",
+    description="删除插件",
+    usage="!plugin del <插件名>",
+    aliases=[],
+    privilege=2
+)
+class PluginDelCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        plugin_list = plugin_host.__plugins__
+        reply = []
+
+        if len(ctx.crt_params) < 1:
+            reply = ["[bot]err: 未指定插件名"]
+        else:
+            plugin_name = ctx.crt_params[0]
+            if plugin_name in plugin_list:
+                unin_path = plugin_host.uninstall_plugin(plugin_name)
+                reply = ["[bot]已删除插件: {} ({}), 请发送 !reload 重载插件".format(plugin_name, unin_path)]
+            else:
+                reply = ["[bot]err:未找到插件: {}, 请使用!plugin指令查看插件列表".format(plugin_name)]
+        
+        return True, reply
+
+
+@AbstractCommandNode.register(
+    parent=PluginCommand,
+    name="on",
+    description="启用指定插件",
+    usage="!plugin on <插件名>",
+    aliases=[],
+    privilege=2
+)
+@AbstractCommandNode.register(
+    parent=PluginCommand,
+    name="off",
+    description="禁用指定插件",
+    usage="!plugin off <插件名>",
+    aliases=[],
+    privilege=2
+)
+class PluginOnOffCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        import pkg.plugin.switch as plugin_switch
+
+        plugin_list = plugin_host.__plugins__
+        reply = []
+        
+        print(ctx.params)
+        new_status = ctx.params[0] == 'on'
+
+        if len(ctx.crt_params) < 1:
+            reply = ["[bot]err: 未指定插件名"]
+        else:
+            plugin_name = ctx.crt_params[0]
+            if plugin_name in plugin_list:
+                plugin_list[plugin_name]['enabled'] = new_status
+                plugin_switch.dump_switch()
+                reply = ["[bot]已{}插件: {}".format("启用" if new_status else "禁用", plugin_name)]
+            else:
+                reply = ["[bot]err:未找到插件: {}, 请使用!plugin指令查看插件列表".format(plugin_name)]
+        
+        return True, reply
+
--- a/pkg/qqbot/cmds/session/init.py
+++ b/pkg/qqbot/cmds/session/init.py
--- a/pkg/qqbot/cmds/session/default.py
+++ b/pkg/qqbot/cmds/session/default.py
@@ -0,0 +1,73 @@
+from ..mgr import AbstractCommandNode, Context
+
+
+@AbstractCommandNode.register(
+    parent=None,
+    name="default",
+    description="操作情景预设",
+    usage="!default\n!default set [指定情景预设为默认]",
+    aliases=[],
+    privilege=1
+)
+class DefaultCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        import pkg.openai.session
+        session_name = ctx.session_name
+        params = ctx.params
+        reply = []
+        import config
+
+        if len(params) == 0:
+            # 输出目前所有情景预设
+            import pkg.openai.dprompt as dprompt
+            reply_str = "[bot]当前所有情景预设({}模式):\n\n".format(config.preset_mode)
+
+            prompts = dprompt.mode_inst().list()
+
+            for key in prompts:
+                pro = prompts[key]
+                reply_str += "名称: {}".format(key)
+
+                for r in pro:
+                    reply_str += "\n   - [{}]: {}".format(r['role'], r['content'])
+
+                reply_str += "\n\n"
+
+            reply_str += "\n当前默认情景预设:{}\n".format(dprompt.mode_inst().get_using_name())
+            reply_str += "请使用 !default set <情景预设名称> 来设置默认情景预设"
+            reply = [reply_str]
+        elif params[0] != "set":
+            reply = ["[bot]err: 已弃用，请使用!default set <情景预设名称> 来设置默认情景预设"]
+        else:
+            return False, []
+
+        return True, reply
+
+
+@AbstractCommandNode.register(
+    parent=DefaultCommand,
+    name="set",
+    description="设置默认情景预设",
+    usage="!default set <情景预设名称>",
+    aliases=[],
+    privilege=2
+)
+class DefaultSetCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        reply = []
+
+        if len(ctx.crt_params) == 0:
+            reply = ["[bot]err: 请指定情景预设名称"]
+        elif len(ctx.crt_params) > 0:
+            import pkg.openai.dprompt as dprompt
+            try:
+                full_name = dprompt.mode_inst().set_using_name(ctx.crt_params[0])
+                reply = ["[bot]已设置默认情景预设为:{}".format(full_name)]
+            except Exception as e:
+                reply = ["[bot]err: {}".format(e)]
+        else:
+            reply = ["[bot]err: 仅管理员可设置默认情景预设"]
+
+        return True, reply
--- a/pkg/qqbot/cmds/session/del.py
+++ b/pkg/qqbot/cmds/session/del.py
@@ -0,0 +1,52 @@
+from ..mgr import AbstractCommandNode, Context
+import datetime
+
+
+@AbstractCommandNode.register(
+    parent=None,
+    name="del",
+    description="删除当前会话的历史记录",
+    usage="!del <序号>\n!del all",
+    aliases=[],
+    privilege=1
+)
+class DelCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        import pkg.openai.session
+        session_name = ctx.session_name
+        params = ctx.params
+        reply = []
+        if len(params) == 0:
+            reply = ["[bot]参数不足, 格式: !del <序号>\n可以通过!list查看序号"]
+        else:
+            if params[0] == 'all':
+                return False, []
+            elif params[0].isdigit():
+                if pkg.openai.session.get_session(session_name).delete_history(int(params[0])):
+                    reply = ["[bot]已删除历史会话 #{}".format(params[0])]
+                else:
+                    reply = ["[bot]没有历史会话 #{}".format(params[0])]
+            else:
+                reply = ["[bot]参数错误, 格式: !del <序号>\n可以通过!list查看序号"]
+
+        return True, reply
+
+
+@AbstractCommandNode.register(
+    parent=DelCommand,
+    name="all",
+    description="删除当前会话的全部历史记录",
+    usage="!del all",
+    aliases=[],
+    privilege=1
+)
+class DelAllCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        import pkg.openai.session
+        session_name = ctx.session_name
+        reply = []
+        pkg.openai.session.get_session(session_name).delete_all_history()
+        reply = ["[bot]已删除所有历史会话"]
+        return True, reply
--- a/pkg/qqbot/cmds/session/delhst.py
+++ b/pkg/qqbot/cmds/session/delhst.py
@@ -0,0 +1,50 @@
+from ..mgr import AbstractCommandNode, Context
+
+
+@AbstractCommandNode.register(
+    parent=None,
+    name="delhst",
+    description="删除指定会话的所有历史记录",
+    usage="!delhst <会话名称>\n!delhst all",
+    aliases=[],
+    privilege=2
+)
+class DelHistoryCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        import pkg.openai.session
+        import pkg.utils.context
+        params = ctx.params
+        reply = []
+        if len(params) == 0:
+            reply = [
+            "[bot]err:请输入要删除的会话名: group_<群号> 或者 person_<QQ号>, 或使用 !delhst all 删除所有会话的历史记录"]
+        else:
+            if params[0] == 'all':
+                return False, []
+            else:
+                if pkg.utils.context.get_database_manager().delete_all_history(params[0]):
+                    reply = ["[bot]已删除会话 {} 的所有历史记录".format(params[0])]
+                else:
+                    reply = ["[bot]未找到会话 {} 的历史记录".format(params[0])]
+
+        return True, reply
+    
+
+@AbstractCommandNode.register(
+    parent=DelHistoryCommand,
+    name="all",
+    description="删除所有会话的全部历史记录",
+    usage="!delhst all",
+    aliases=[],
+    privilege=2
+)
+class DelAllHistoryCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        import pkg.utils.context
+        reply = []
+        pkg.utils.context.get_database_manager().delete_all_session_history()
+        reply = ["[bot]已删除所有会话的历史记录"]
+        return True, reply
+    
--- a/pkg/qqbot/cmds/session/last.py
+++ b/pkg/qqbot/cmds/session/last.py
@@ -0,0 +1,28 @@
+from ..mgr import AbstractCommandNode, Context
+import datetime
+
+
+@AbstractCommandNode.register(
+    parent=None,
+    name="last",
+    description="切换前一次对话",
+    usage="!last",
+    aliases=[],
+    privilege=1
+)
+class LastCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        import pkg.openai.session
+        session_name = ctx.session_name
+
+        reply = []
+        result = pkg.openai.session.get_session(session_name).last_session()
+        if result is None:
+            reply = ["[bot]没有前一次的对话"]
+        else:
+            datetime_str = datetime.datetime.fromtimestamp(result.create_timestamp).strftime(
+                '%Y-%m-%d %H:%M:%S')
+            reply = ["[bot]已切换到前一次的对话：\n创建时间:{}\n".format(datetime_str)]
+
+        return True, reply
--- a/pkg/qqbot/cmds/session/list.py
+++ b/pkg/qqbot/cmds/session/list.py
@@ -0,0 +1,67 @@
+from ..mgr import AbstractCommandNode, Context
+import datetime
+import json
+
+
+@AbstractCommandNode.register(
+    parent=None,
+    name='list',
+    description='列出当前会话的所有历史记录',
+    usage='!list\n!list [页数]',
+    aliases=[],
+    privilege=1
+)
+class ListCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        import pkg.openai.session
+        session_name = ctx.session_name
+        params = ctx.params
+        reply = []
+
+        pkg.openai.session.get_session(session_name).persistence()
+        page = 0
+
+        if len(params) > 0:
+            try:
+                page = int(params[0])
+            except ValueError:
+                pass
+
+        results = pkg.openai.session.get_session(session_name).list_history(page=page)
+        if len(results) == 0:
+            reply = ["[bot]第{}页没有历史会话".format(page)]
+        else:
+            reply_str = "[bot]历史会话 第{}页：\n".format(page)
+            current = -1
+            for i in range(len(results)):
+                # 时间(使用create_timestamp转换) 序号 部分内容
+                datetime_obj = datetime.datetime.fromtimestamp(results[i]['create_timestamp'])
+                msg = ""
+                try:
+                    msg = json.loads(results[i]['prompt'])
+                except json.decoder.JSONDecodeError:
+                    msg = pkg.openai.session.reset_session_prompt(session_name, results[i]['prompt'])
+                    # 持久化
+                    pkg.openai.session.get_session(session_name).persistence()
+                if len(msg) >= 2:
+                    reply_str += "#{} 创建:{} {}\n".format(i + page * 10,
+                                                        datetime_obj.strftime("%Y-%m-%d %H:%M:%S"),
+                                                        msg[0]['content'])
+                else:
+                    reply_str += "#{} 创建:{} {}\n".format(i + page * 10,
+                                                        datetime_obj.strftime("%Y-%m-%d %H:%M:%S"),
+                                                        "无内容")
+                if results[i]['create_timestamp'] == pkg.openai.session.get_session(
+                        session_name).create_timestamp:
+                    current = i + page * 10
+
+            reply_str += "\n以上信息倒序排列"
+            if current != -1:
+                reply_str += ",当前会话是 #{}\n".format(current)
+            else:
+                reply_str += ",当前处于全新会话或不在此页"
+
+        reply = [reply_str]
+
+        return True, reply
--- a/pkg/qqbot/cmds/session/next.py
+++ b/pkg/qqbot/cmds/session/next.py
@@ -0,0 +1,28 @@
+from ..mgr import AbstractCommandNode, Context
+import datetime
+
+
+@AbstractCommandNode.register(
+    parent=None,
+    name="next",
+    description="切换后一次对话",
+    usage="!next",
+    aliases=[],
+    privilege=1
+)
+class NextCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        import pkg.openai.session
+        session_name = ctx.session_name
+        reply = []
+
+        result = pkg.openai.session.get_session(session_name).next_session()
+        if result is None:
+            reply = ["[bot]没有后一次的对话"]
+        else:
+            datetime_str = datetime.datetime.fromtimestamp(result.create_timestamp).strftime(
+                '%Y-%m-%d %H:%M:%S')
+            reply = ["[bot]已切换到后一次的对话：\n创建时间:{}\n".format(datetime_str)]
+
+        return True, reply
--- a/pkg/qqbot/cmds/session/prompt.py
+++ b/pkg/qqbot/cmds/session/prompt.py
@@ -0,0 +1,32 @@
+from ..mgr import AbstractCommandNode, Context
+import datetime
+
+
+@AbstractCommandNode.register(
+    parent=None,
+    name="prompt",
+    description="获取当前会话的前文",
+    usage="!prompt",
+    aliases=[],
+    privilege=1
+)
+class PromptCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        import pkg.openai.session
+        session_name = ctx.session_name
+        params = ctx.params
+        reply = []
+
+        msgs = ""
+        session: list = pkg.openai.session.get_session(session_name).prompt
+        for msg in session:
+            if len(params) != 0 and params[0] in ['-all', '-a']:
+                msgs = msgs + "{}: {}\n\n".format(msg['role'], msg['content'])
+            elif len(msg['content']) > 30:
+                msgs = msgs + "[{}]: {}...\n\n".format(msg['role'], msg['content'][:30])
+            else:
+                msgs = msgs + "[{}]: {}\n\n".format(msg['role'], msg['content'])
+        reply = ["[bot]当前对话所有内容：\n{}".format(msgs)]
+
+        return True, reply
--- a/pkg/qqbot/cmds/session/resend.py
+++ b/pkg/qqbot/cmds/session/resend.py
@@ -0,0 +1,30 @@
+from ..mgr import AbstractCommandNode, Context
+import datetime
+
+
+@AbstractCommandNode.register(
+    parent=None,
+    name="resend",
+    description="重新获取上一次问题的回复",
+    usage="!resend",
+    aliases=[],
+    privilege=1
+)
+class ResendCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        import pkg.openai.session
+        import config
+        session_name = ctx.session_name
+        reply = []
+
+        session = pkg.openai.session.get_session(session_name)
+        to_send = session.undo()
+
+        mgr = pkg.utils.context.get_qqbot_manager()
+
+        reply = pkg.qqbot.message.process_normal_message(to_send, mgr, config,
+                                                        ctx.launcher_type, ctx.launcher_id,
+                                                        ctx.sender_id)
+
+        return True, reply
--- a/pkg/qqbot/cmds/session/reset.py
+++ b/pkg/qqbot/cmds/session/reset.py
@@ -0,0 +1,34 @@
+from ..mgr import AbstractCommandNode, Context
+
+import pkg.openai.session
+import pkg.utils.context
+
+
+@AbstractCommandNode.register(
+    parent=None,
+    name='reset',
+    description='重置当前会话',
+    usage='!reset',
+    aliases=[],
+    privilege=1
+)
+class ResetCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        params = ctx.params
+        session_name = ctx.session_name
+        
+        reply = ""
+
+        if len(params) == 0:
+            pkg.openai.session.get_session(session_name).reset(explicit=True)
+            reply = ["[bot]会话已重置"]
+        else:
+            try:
+                import pkg.openai.dprompt as dprompt
+                pkg.openai.session.get_session(session_name).reset(explicit=True, use_prompt=params[0])
+                reply = ["[bot]会话已重置，使用场景预设:{}".format(dprompt.mode_inst().get_full_name(params[0]))]
+            except Exception as e:
+                reply = ["[bot]会话重置失败：{}".format(e)]
+        
+        return True, reply
--- a/pkg/qqbot/cmds/system/init.py
+++ b/pkg/qqbot/cmds/system/init.py
--- a/pkg/qqbot/cmds/system/help.py
+++ b/pkg/qqbot/cmds/system/help.py
@@ -0,0 +1,38 @@
+from ..mgr import AbstractCommandNode, Context, __command_list__
+
+
+@AbstractCommandNode.register(
+    parent=None,
+    name="help",
+    description="显示帮助信息",
+    usage="!help\n!help <指令名称>",
+    aliases=[],
+    privilege=1
+)
+class HelpCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        command_list = __command_list__
+
+        reply = []
+
+        if len(ctx.params) == 0:
+            reply_str = "[bot]当前所有指令:\n\n"
+
+            # 遍历顶级指令
+            for key in command_list:
+                command = command_list[key]
+                if command['parent'] is None:
+                    reply_str += "!{} - {}\n".format(key, command['description'])
+
+            reply_str += "\n请使用 !help <指令名称> 来查看指令的详细信息"
+
+            reply = [reply_str]
+        else:
+            command_name = ctx.params[0]
+            if command_name in command_list:
+                reply = [command_list[command_name]['cls'].help()]
+            else:
+                reply = ["[bot]指令 {} 不存在".format(command_name)]
+
+        return True, reply
--- a/pkg/qqbot/cmds/system/reload.py
+++ b/pkg/qqbot/cmds/system/reload.py
@@ -0,0 +1,23 @@
+from ..mgr import AbstractCommandNode, Context
+import threading
+
+@AbstractCommandNode.register(
+    parent=None,
+    name="reload",
+    description="执行热重载",
+    usage="!reload",
+    aliases=[],
+    privilege=2
+)
+class ReloadCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        reply = []
+
+        import pkg.utils.reloader
+        def reload_task():
+            pkg.utils.reloader.reload_all()
+
+        threading.Thread(target=reload_task, daemon=True).start()
+
+        return True, reply
--- a/pkg/qqbot/cmds/system/update.py
+++ b/pkg/qqbot/cmds/system/update.py
@@ -0,0 +1,38 @@
+from ..mgr import AbstractCommandNode, Context
+import threading
+import traceback
+
+
+@AbstractCommandNode.register(
+    parent=None,
+    name="update",
+    description="更新程序",
+    usage="!update",
+    aliases=[],
+    privilege=2
+)
+class UpdateCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        reply = []
+        import pkg.utils.updater
+        import pkg.utils.reloader
+        import pkg.utils.context
+
+        def update_task():
+            try:
+                if pkg.utils.updater.update_all():
+                    pkg.utils.reloader.reload_all(notify=False)
+                    pkg.utils.context.get_qqbot_manager().notify_admin("更新完成")
+                else:
+                    pkg.utils.context.get_qqbot_manager().notify_admin("无新版本")
+            except Exception as e0:
+                traceback.print_exc()
+                pkg.utils.context.get_qqbot_manager().notify_admin("更新失败:{}".format(e0))
+                return
+
+        threading.Thread(target=update_task, daemon=True).start()
+
+        reply = ["[bot]正在更新，请耐心等待，请勿重复发起更新..."]
+
+        return True, reply
--- a/pkg/qqbot/cmds/system/usage.py
+++ b/pkg/qqbot/cmds/system/usage.py
@@ -0,0 +1,42 @@
+from ..mgr import AbstractCommandNode, Context
+import logging
+
+
+@AbstractCommandNode.register(
+    parent=None,
+    name="usage",
+    description="获取使用情况",
+    usage="!usage",
+    aliases=[],
+    privilege=1
+)
+class UsageCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        import config
+        import pkg.utils.credit as credit
+        import pkg.utils.context
+
+        reply = []
+
+        reply_str = "[bot]各api-key使用情况:\n\n"
+
+        api_keys = pkg.utils.context.get_openai_manager().key_mgr.api_key
+        for key_name in api_keys:
+            text_length = pkg.utils.context.get_openai_manager().audit_mgr \
+                .get_text_length_of_key(api_keys[key_name])
+            image_count = pkg.utils.context.get_openai_manager().audit_mgr \
+                .get_image_count_of_key(api_keys[key_name])
+            reply_str += "{}:\n - 文本长度:{}\n - 图片数量:{}\n".format(key_name, int(text_length),
+                                                                        int(image_count))
+            # 获取此key的额度
+            try:
+                http_proxy = config.openai_config["http_proxy"] if "http_proxy" in config.openai_config else None
+                credit_data = credit.fetch_credit_data(api_keys[key_name], http_proxy)
+                reply_str += " - 使用额度:{:.2f}/{:.2f}\n".format(credit_data['total_used'],credit_data['total_granted'])
+            except Exception as e:
+                logging.warning("获取额度失败:{}".format(e))
+
+        reply = [reply_str]
+
+        return True, reply
--- a/pkg/qqbot/cmds/system/version.py
+++ b/pkg/qqbot/cmds/system/version.py
@@ -0,0 +1,27 @@
+from ..mgr import AbstractCommandNode, Context
+
+
+@AbstractCommandNode.register(
+    parent=None,
+    name="version",
+    description="查看版本信息",
+    usage="!version",
+    aliases=[],
+    privilege=1
+)
+class VersionCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        reply = []
+        import pkg.utils.updater
+    
+        reply_str = "[bot]当前版本:\n{}\n".format(pkg.utils.updater.get_current_version_info())
+        try:
+            if pkg.utils.updater.is_new_version_available():
+                reply_str += "\n有新版本可用，请使用命令 !update 进行更新"
+        except:
+            pass
+
+        reply = [reply_str]
+
+        return True, reply
--- a/pkg/qqbot/command.py
+++ b/pkg/qqbot/command.py
@@ -4,6 +4,7 @@ import json
 import datetime
 import os
 import threading
+import traceback

 import pkg.openai.session
 import pkg.openai.manager
@@ -12,151 +13,12 @@ import pkg.utils.updater
 import pkg.utils.context
 import pkg.qqbot.message
 import pkg.utils.credit as credit
+# import pkg.qqbot.cmds.model as cmdmodel
+import pkg.qqbot.cmds.mgr as cmdmgr

 from mirai import Image


-def config_operation(cmd, params):
-    reply = []
-    config = pkg.utils.context.get_config()
-    reply_str = ""
-    if len(params) == 0:
-        reply = ["[bot]err:请输入配置项"]
-    else:
-        cfg_name = params[0]
-        if cfg_name == 'all':
-            reply_str = "[bot]所有配置项:\n\n"
-            for cfg in dir(config):
-                if not cfg.startswith('__') and not cfg == 'logging':
-                    # 根据配置项类型进行格式化，如果是字典则转换为json并格式化
-                    if isinstance(getattr(config, cfg), str):
-                        reply_str += "{}: \"{}\"\n".format(cfg, getattr(config, cfg))
-                    elif isinstance(getattr(config, cfg), dict):
-                        # 不进行unicode转义，并格式化
-                        reply_str += "{}: {}\n".format(cfg,
-                                                       json.dumps(getattr(config, cfg),
-                                                                  ensure_ascii=False, indent=4))
-                    else:
-                        reply_str += "{}: {}\n".format(cfg, getattr(config, cfg))
-            reply = [reply_str]
-        elif cfg_name in dir(config):
-            if len(params) == 1:
-                # 按照配置项类型进行格式化
-                if isinstance(getattr(config, cfg_name), str):
-                    reply_str = "[bot]配置项{}: \"{}\"\n".format(cfg_name, getattr(config, cfg_name))
-                elif isinstance(getattr(config, cfg_name), dict):
-                    reply_str = "[bot]配置项{}: {}\n".format(cfg_name,
-                                                             json.dumps(getattr(config, cfg_name),
-                                                                        ensure_ascii=False, indent=4))
-                else:
-                    reply_str = "[bot]配置项{}: {}\n".format(cfg_name, getattr(config, cfg_name))
-                reply = [reply_str]
-            else:
-                cfg_value = " ".join(params[1:])
-                # 类型转换，如果是json则转换为字典
-                if cfg_value == 'true':
-                    cfg_value = True
-                elif cfg_value == 'false':
-                    cfg_value = False
-                elif cfg_value.isdigit():
-                    cfg_value = int(cfg_value)
-                elif cfg_value.startswith('{') and cfg_value.endswith('}'):
-                    cfg_value = json.loads(cfg_value)
-                else:
-                    try:
-                        cfg_value = float(cfg_value)
-                    except ValueError:
-                        pass
-
-                # 检查类型是否匹配
-                if isinstance(getattr(config, cfg_name), type(cfg_value)):
-                    setattr(config, cfg_name, cfg_value)
-                    pkg.utils.context.set_config(config)
-                    reply = ["[bot]配置项{}修改成功".format(cfg_name)]
-                else:
-                    reply = ["[bot]err:配置项{}类型不匹配".format(cfg_name)]
-
-        else:
-            reply = ["[bot]err:未找到配置项 {}".format(cfg_name)]
-
-    return reply
-
-
-def plugin_operation(cmd, params, is_admin):
-    reply = []
-
-    import pkg.plugin.host as plugin_host
-    import pkg.utils.updater as updater
-
-    plugin_list = plugin_host.__plugins__
-
-    if len(params) == 0:
-        reply_str = "[bot]所有插件({}):\n".format(len(plugin_host.__plugins__))
-        idx = 0
-        for key in plugin_host.iter_plugins_name():
-            plugin = plugin_list[key]
-            reply_str += "\n#{} {} {}\n{}\nv{}\n作者: {}\n"\
-                .format((idx+1), plugin['name'],
-                        "[已禁用]" if not plugin['enabled'] else "",
-                        plugin['description'],
-                        plugin['version'], plugin['author'])
-
-            if updater.is_repo("/".join(plugin['path'].split('/')[:-1])):
-                remote_url = updater.get_remote_url("/".join(plugin['path'].split('/')[:-1]))
-                if remote_url != "https://github.com/RockChinQ/QChatGPT" and remote_url != "https://gitee.com/RockChin/QChatGPT":
-                    reply_str += "源码: "+remote_url+"\n"
-
-            idx += 1
-
-        reply = [reply_str]
-    elif params[0] == 'update':
-        # 更新所有插件
-        if is_admin:
-            def closure():
-                import pkg.utils.context
-                updated = []
-                for key in plugin_list:
-                    plugin = plugin_list[key]
-                    if updater.is_repo("/".join(plugin['path'].split('/')[:-1])):
-                        success = updater.pull_latest("/".join(plugin['path'].split('/')[:-1]))
-                        if success:
-                            updated.append(plugin['name'])
-
-                # 检查是否有requirements.txt
-                pkg.utils.context.get_qqbot_manager().notify_admin("正在安装依赖...")
-                for key in plugin_list:
-                    plugin = plugin_list[key]
-                    if os.path.exists("/".join(plugin['path'].split('/')[:-1])+"/requirements.txt"):
-                        logging.info("{}检测到requirements.txt，安装依赖".format(plugin['name']))
-                        import pkg.utils.pkgmgr
-                        pkg.utils.pkgmgr.install_requirements("/".join(plugin['path'].split('/')[:-1])+"/requirements.txt")
-
-                        import main
-                        main.reset_logging()
-
-                pkg.utils.context.get_qqbot_manager().notify_admin("已更新插件: {}".format(", ".join(updated)))
-
-            threading.Thread(target=closure).start()
-            reply = ["[bot]正在更新所有插件，请勿重复发起..."]
-        else:
-            reply = ["[bot]err:权限不足"]
-    elif params[0].startswith("http"):
-        if is_admin:
-
-            def closure():
-                try:
-                    plugin_host.install_plugin(params[0])
-                    pkg.utils.context.get_qqbot_manager().notify_admin("插件安装成功，请发送 !reload 指令重载插件")
-                except Exception as e:
-                    logging.error("插件安装失败:{}".format(e))
-                    pkg.utils.context.get_qqbot_manager().notify_admin("插件安装失败:{}".format(e))
-
-            threading.Thread(target=closure, args=()).start()
-            reply = ["[bot]正在安装插件..."]
-        else:
-            reply = ["[bot]err:权限不足，请使用管理员账号私聊发起"]
-    return reply
-

 def process_command(session_name: str, text_message: str, mgr, config,
                    launcher_type: str, launcher_id: int, sender_id: int, is_admin: bool) -> list:
@@ -169,188 +31,32 @@ def process_command(session_name: str, text_message: str, mgr, config,
        cmd = text_message[1:].strip().split(' ')[0]

        params = text_message[1:].strip().split(' ')[1:]
-        if cmd == 'help':
-            reply = ["[bot]" + config.help_message]
-        elif cmd == 'reset':
-            if len(params) == 0:
-                pkg.openai.session.get_session(session_name).reset(explicit=True)
-                reply = ["[bot]会话已重置"]
-            else:
-                pkg.openai.session.get_session(session_name).reset(explicit=True, use_prompt=params[0])
-                reply = ["[bot]会话已重置，使用场景预设:{}".format(params[0])]
-        elif cmd == 'last':
-            result = pkg.openai.session.get_session(session_name).last_session()
-            if result is None:
-                reply = ["[bot]没有前一次的对话"]
-            else:
-                datetime_str = datetime.datetime.fromtimestamp(result.create_timestamp).strftime(
-                    '%Y-%m-%d %H:%M:%S')
-                reply = ["[bot]已切换到前一次的对话：\n创建时间:{}\n".format(datetime_str)]
-        elif cmd == 'next':
-            result = pkg.openai.session.get_session(session_name).next_session()
-            if result is None:
-                reply = ["[bot]没有后一次的对话"]
-            else:
-                datetime_str = datetime.datetime.fromtimestamp(result.create_timestamp).strftime(
-                    '%Y-%m-%d %H:%M:%S')
-                reply = ["[bot]已切换到后一次的对话：\n创建时间:{}\n".format(datetime_str)]
-        elif cmd == 'prompt':
-            msgs = ""
-            session:list = pkg.openai.session.get_session(session_name).prompt
-            for msg in session:
-                if len(params) != 0 and params[0] in ['-all', '-a']:
-                    msgs = msgs + "{}: {}\n\n".format(msg['role'], msg['content'])
-                elif len(msg['content']) > 30:
-                    msgs = msgs + "[{}]: {}...\n\n".format(msg['role'], msg['content'][:30])
-                else:
-                    msgs = msgs + "[{}]: {}\n\n".format(msg['role'], msg['content'])
-            reply = ["[bot]当前对话所有内容：\n{}".format(msgs)]
-        elif cmd == 'list':
-            pkg.openai.session.get_session(session_name).persistence()
-            page = 0

-            if len(params) > 0:
-                try:
-                    page = int(params[0])
-                except ValueError:
-                    pass
+        # 把!~开头的转换成!cfg
+        if cmd.startswith('~'):
+            params = [cmd[1:]] + params
+            cmd = 'cfg'

-            results = pkg.openai.session.get_session(session_name).list_history(page=page)
-            if len(results) == 0:
-                reply = ["[bot]第{}页没有历史会话".format(page)]
-            else:
-                reply_str = "[bot]历史会话 第{}页：\n".format(page)
-                current = -1
-                for i in range(len(results)):
-                    # 时间(使用create_timestamp转换) 序号 部分内容
-                    datetime_obj = datetime.datetime.fromtimestamp(results[i]['create_timestamp'])
-                    msg = ""
-                    try:
-                        msg = json.loads(results[i]['prompt'])
-                    except json.decoder.JSONDecodeError:
-                        msg = pkg.openai.session.reset_session_prompt(session_name, results[i]['prompt'])
-                        # 持久化
-                        pkg.openai.session.get_session(session_name).persistence()
-                    if len(msg) >= 2:
-                        reply_str += "#{} 创建:{} {}\n".format(i + page * 10,
-                                                               datetime_obj.strftime("%Y-%m-%d %H:%M:%S"),
-                                                               msg[1]['content'])
-                    else:
-                        reply_str += "#{} 创建:{} {}\n".format(i + page * 10,
-                                                               datetime_obj.strftime("%Y-%m-%d %H:%M:%S"),
-                                                               "无内容")
-                    if results[i]['create_timestamp'] == pkg.openai.session.get_session(
-                            session_name).create_timestamp:
-                        current = i + page * 10
+        # 包装参数
+        context = cmdmgr.Context(
+            command=cmd,
+            crt_command=cmd,
+            params=params,
+            crt_params=params[:],
+            session_name=session_name,
+            text_message=text_message,
+            launcher_type=launcher_type,
+            launcher_id=launcher_id,
+            sender_id=sender_id,
+            is_admin=is_admin,
+            privilege=2 if is_admin else 1,  # 普通用户1，管理员2
+        )
+        try:
+            reply = cmdmgr.execute(context)
+        except cmdmgr.CommandPrivilegeError as e:
+            reply = ["[bot]err:{}".format(e)]

-                reply_str += "\n以上信息倒序排列"
-                if current != -1:
-                    reply_str += ",当前会话是 #{}\n".format(current)
-                else:
-                    reply_str += ",当前处于全新会话或不在此页"
-
-                reply = [reply_str]
-        elif cmd == 'resend':
-            session = pkg.openai.session.get_session(session_name)
-            to_send = session.undo()
-
-            reply = pkg.qqbot.message.process_normal_message(to_send, mgr, config,
-                                                             launcher_type, launcher_id, sender_id)
-        elif cmd == 'usage':
-            reply_str = "[bot]各api-key使用情况:\n\n"
-
-            api_keys = pkg.utils.context.get_openai_manager().key_mgr.api_key
-            for key_name in api_keys:
-                text_length = pkg.utils.context.get_openai_manager().audit_mgr \
-                    .get_text_length_of_key(api_keys[key_name])
-                image_count = pkg.utils.context.get_openai_manager().audit_mgr \
-                    .get_image_count_of_key(api_keys[key_name])
-                reply_str += "{}:\n - 文本长度:{}\n - 图片数量:{}\n".format(key_name, int(text_length),
-                                                                            int(image_count))
-                # 获取此key的额度
-                try:
-                    credit_data = credit.fetch_credit_data(api_keys[key_name])
-                    reply_str += " - 使用额度:{:.2f}/{:.2f}\n".format(credit_data['total_used'],credit_data['total_granted'])
-                except Exception as e:
-                    logging.warning("获取额度失败:{}".format(e))
-
-            reply = [reply_str]
-        elif cmd == 'draw':
-            if len(params) == 0:
-                reply = ["[bot]err:请输入图片描述文字"]
-            else:
-                session = pkg.openai.session.get_session(session_name)
-
-                res = session.draw_image(" ".join(params))
-
-                logging.debug("draw_image result:{}".format(res))
-                reply = [Image(url=res['data'][0]['url'])]
-                if not (hasattr(config, 'include_image_description')
-                        and not config.include_image_description):
-                    reply.append(" ".join(params))
-        elif cmd == 'version':
-            reply_str = "[bot]当前版本:\n{}\n".format(pkg.utils.updater.get_current_version_info())
-            try:
-                if pkg.utils.updater.is_new_version_available():
-                    reply_str += "\n有新版本可用，请使用命令 !update 进行更新"
-            except:
-                pass
-
-            reply = [reply_str]
-
-        elif cmd == 'plugin':
-            reply = plugin_operation(cmd, params, is_admin)
-
-        elif cmd == 'default':
-            if len(params) == 0:
-                # 输出目前所有情景预设
-                import pkg.openai.dprompt as dprompt
-                reply_str = "[bot]当前所有情景预设:\n\n"
-                for key,value in dprompt.get_prompt_dict().items():
-                    reply_str += "  - {}: {}\n".format(key,value)
-
-                reply_str += "\n当前默认情景预设:{}\n".format(dprompt.get_current())
-                reply_str += "请使用!default <情景预设>来设置默认情景预设"
-                reply = [reply_str]
-            elif len(params) >0  and is_admin:
-                # 设置默认情景
-                import pkg.openai.dprompt as dprompt
-                try:
-                    dprompt.set_current(params[0])
-                    reply = ["[bot]已设置默认情景预设为:{}".format(dprompt.get_current())]
-                except KeyError:
-                    reply = ["[bot]err: 未找到情景预设:{}".format(params[0])]
-            else:
-                reply = ["[bot]err: 仅管理员可设置默认情景预设"]
-        elif cmd == 'reload' and is_admin:
-            def reload_task():
-                pkg.utils.reloader.reload_all()
-
-            threading.Thread(target=reload_task, daemon=True).start()
-        elif cmd == 'update' and is_admin:
-            def update_task():
-                try:
-                    if pkg.utils.updater.update_all():
-                        pkg.utils.reloader.reload_all(notify=False)
-                        pkg.utils.context.get_qqbot_manager().notify_admin("更新完成")
-                    else:
-                        pkg.utils.context.get_qqbot_manager().notify_admin("无新版本")
-                except Exception as e0:
-                    pkg.utils.context.get_qqbot_manager().notify_admin("更新失败:{}".format(e0))
-                    return
-
-            threading.Thread(target=update_task, daemon=True).start()
-
-            reply = ["[bot]正在更新，请耐心等待，请勿重复发起更新..."]
-        elif cmd == 'cfg' and is_admin:
-            reply = config_operation(cmd, params)
-        else:
-            if cmd.startswith("~") and is_admin:
-                config_item = cmd[1:]
-                params = [config_item] + params
-                reply = config_operation("cfg", params)
-            else:
-                reply = ["[bot]err:未知的指令或权限不足: " + cmd]
+        return reply
    except Exception as e:
        mgr.notify_admin("{}指令执行失败:{}".format(session_name, e))
        logging.exception(e)
--- a/pkg/qqbot/filter.py
+++ b/pkg/qqbot/filter.py
@@ -50,8 +50,8 @@ class ReplyFilter:

            # 百度云审核URL
            baidu_url = "https://aip.baidubce.com/rest/2.0/solution/v1/text_censor/v2/user_defined?access_token=" + \
-                str(requests.post("https://aip.baidubce.com/oauth/2.0/token", 
-                      params={"grant_type": "client_credentials", 
+                str(requests.post("https://aip.baidubce.com/oauth/2.0/token",
+                      params={"grant_type": "client_credentials",
                              "client_id": self.baidu_api_key,
                              "client_secret": self.baidu_secret_key}).json().get("access_token"))

--- a/pkg/qqbot/manager.py
+++ b/pkg/qqbot/manager.py
@@ -2,7 +2,6 @@ import asyncio
 import json
 import os
 import threading
-from concurrent.futures import ThreadPoolExecutor

 import mirai.models.bus
 from mirai import At, GroupMessage, MessageEvent, Mirai, StrangerMessage, WebSocketAdapter, HTTPAdapter, \
@@ -66,9 +65,6 @@ def random_responding():
 class QQBotManager:
    retry = 3

-    #线程池控制
-    pool = None
-
    bot: Mirai = None

    reply_filter = None
@@ -78,14 +74,10 @@ class QQBotManager:
    ban_person = []
    ban_group = []

-    def __init__(self, mirai_http_api_config: dict, timeout: int = 60, retry: int = 3, pool_num: int = 10, first_time_init=True):
+    def __init__(self, mirai_http_api_config: dict, timeout: int = 60, retry: int = 3, first_time_init=True):
        self.timeout = timeout
        self.retry = retry

-        self.pool_num = pool_num
-        self.pool = ThreadPoolExecutor(max_workers=self.pool_num)
-        logging.debug("Registered thread pool Size:{}".format(pool_num))
-
        # 加载禁用列表
        if os.path.exists("banlist.py"):
            import banlist
@@ -138,7 +130,10 @@ class QQBotManager:

                self.on_person_message(event)

-            self.go(friend_message_handler, event)
+            pkg.utils.context.get_thread_ctl().submit_user_task(
+                friend_message_handler,
+                event
+            )

        @self.bot.on(StrangerMessage)
        async def on_stranger_message(event: StrangerMessage):
@@ -158,7 +153,10 @@ class QQBotManager:

                self.on_person_message(event)

-            self.go(stranger_message_handler, event)
+            pkg.utils.context.get_thread_ctl().submit_user_task(
+                stranger_message_handler,
+                event
+            )

        @self.bot.on(GroupMessage)
        async def on_group_message(event: GroupMessage):
@@ -178,7 +176,10 @@ class QQBotManager:

                self.on_group_message(event)

-            self.go(group_message_handler, event)
+            pkg.utils.context.get_thread_ctl().submit_user_task(
+                group_message_handler,
+                event
+            )

        def unsubscribe_all():
            """取消所有订阅
--- a/pkg/qqbot/message.py
+++ b/pkg/qqbot/message.py
@@ -1,6 +1,5 @@
 # 普通消息处理模块
 import logging
-import time
 import openai
 import pkg.utils.context
 import pkg.openai.session
@@ -64,7 +63,7 @@ def process_normal_message(text_message: str, mgr, config, launcher_type: str,
                reply = event.get_return_value("reply")

            if not event.is_prevented_default():
-                reply = blob.check_text(prefix + text)
+                reply = [prefix + text]
        except openai.error.APIConnectionError as e:
            err_msg = str(e)
            if err_msg.__contains__('Error communicating with OpenAI'):
@@ -117,8 +116,7 @@ def process_normal_message(text_message: str, mgr, config, launcher_type: str,
                reply = handle_exception("{}会话调用API失败:{}".format(session_name, e),
                                         "[bot]err:RateLimitError,请重试或联系作者，或等待修复")
        except openai.error.InvalidRequestError as e:
-            reply = handle_exception("{}API调用参数错误:{}\n\n这可能是由于config.py中的prompt_submit_length参数或"
-                             "completion_api_params中的max_tokens参数数值过大导致的，请尝试将其降低".format(
+            reply = handle_exception("{}API调用参数错误:{}\n".format(
                             session_name, e), "[bot]err:API调用参数错误，请联系管理员，或等待修复")
        except openai.error.ServiceUnavailableError as e:
            reply = handle_exception("{}API调用服务不可用:{}".format(session_name, e), "[bot]err:API调用服务不可用，请重试或联系管理员，或等待修复")
--- a/pkg/qqbot/process.py
+++ b/pkg/qqbot/process.py
@@ -26,6 +26,7 @@ import pkg.plugin.host as plugin_host
 import pkg.plugin.models as plugin_models
 import pkg.qqbot.ignore as ignore
 import pkg.qqbot.banlist as banlist
+import pkg.qqbot.blob as blob

 processing = []

@@ -157,6 +158,7 @@ def process_message(launcher_type: str, launcher_id: int, text_message: str, mes
                                                 reply[0][:min(100, len(reply[0]))] + (
                                                     "..." if len(reply[0]) > 100 else "")))
                reply = [mgr.reply_filter.process(reply[0])]
+                reply = blob.check_text(reply[0])
            else:
                logging.info("回复[{}]消息".format(session_name))

--- a/pkg/utils/init.py
+++ b/pkg/utils/init.py
@@ -0,0 +1 @@
+from .threadctl import ThreadCtl
--- a/pkg/utils/announcement.py
+++ b/pkg/utils/announcement.py
@@ -0,0 +1,47 @@
+import base64
+import os
+
+import requests
+
+import pkg.utils.network as network
+
+
+def read_latest() -> str:
+    resp = requests.get(
+        url="https://api.github.com/repos/RockChinQ/QChatGPT/contents/res/announcement",
+        proxies=network.wrapper_proxies()
+    )
+    obj_json = resp.json()
+    b64_content = obj_json["content"]
+    # 解码
+    content = base64.b64decode(b64_content).decode("utf-8")
+    return content
+
+
+def read_saved() -> str:
+    # 已保存的在res/announcement_saved
+    # 检查是否存在
+    if not os.path.exists("res/announcement_saved"):
+        with open("res/announcement_saved", "w", encoding="utf-8") as f:
+            f.write("")
+
+    with open("res/announcement_saved", "r", encoding="utf-8") as f:
+        content = f.read()
+
+    return content
+
+
+def write_saved(content: str):
+    # 已保存的在res/announcement_saved
+    with open("res/announcement_saved", "w", encoding="utf-8") as f:
+        f.write(content)
+
+
+def fetch_new() -> str:
+    latest = read_latest()
+    saved = read_saved()
+    if latest.replace(saved, "").strip() == "":
+        return ""
+    else:
+        write_saved(latest)
+        return latest.replace(saved, "").strip()
--- a/pkg/utils/constants.py
+++ b/pkg/utils/constants.py
--- a/pkg/utils/context.py
+++ b/pkg/utils/context.py
@@ -1,50 +1,94 @@
+import threading
+from pkg.utils import ThreadCtl
+
+
 context = {
    'inst': {
        'database.manager.DatabaseManager': None,
        'openai.manager.OpenAIInteract': None,
        'qqbot.manager.QQBotManager': None,
    },
+    'pool_ctl': None,
    'logger_handler': None,
    'config': None,
    'plugin_host': None,
 }
+context_lock = threading.Lock()

-
+### context耦合度非常高，需要大改 ###
 def set_config(inst):
+    context_lock.acquire()
    context['config'] = inst
+    context_lock.release()


 def get_config():
-    return context['config']
+    context_lock.acquire()
+    t = context['config']
+    context_lock.release()
+    return t


 def set_database_manager(inst):
+    context_lock.acquire()
    context['inst']['database.manager.DatabaseManager'] = inst
+    context_lock.release()


 def get_database_manager():
-    return context['inst']['database.manager.DatabaseManager']
+    context_lock.acquire()
+    t = context['inst']['database.manager.DatabaseManager']
+    context_lock.release()
+    return t


 def set_openai_manager(inst):
+    context_lock.acquire()
    context['inst']['openai.manager.OpenAIInteract'] = inst
+    context_lock.release()


 def get_openai_manager():
-    return context['inst']['openai.manager.OpenAIInteract']
+    context_lock.acquire()
+    t = context['inst']['openai.manager.OpenAIInteract']
+    context_lock.release()
+    return t


 def set_qqbot_manager(inst):
+    context_lock.acquire()
    context['inst']['qqbot.manager.QQBotManager'] = inst
+    context_lock.release()


 def get_qqbot_manager():
-    return context['inst']['qqbot.manager.QQBotManager']
+    context_lock.acquire()
+    t = context['inst']['qqbot.manager.QQBotManager']
+    context_lock.release()
+    return t


 def set_plugin_host(inst):
+    context_lock.acquire()
    context['plugin_host'] = inst
+    context_lock.release()


 def get_plugin_host():
-    return context['plugin_host']
+    context_lock.acquire()
+    t = context['plugin_host']
+    context_lock.release()
+    return t
+
+
+def set_thread_ctl(inst):
+    context_lock.acquire()
+    context['pool_ctl'] = inst
+    context_lock.release()
+
+
+def get_thread_ctl() -> ThreadCtl:
+    context_lock.acquire()
+    t: ThreadCtl = context['pool_ctl']
+    context_lock.release()
+    return t
--- a/pkg/utils/credit.py
+++ b/pkg/utils/credit.py
@@ -1,13 +1,19 @@
 # OpenAI账号免费额度剩余查询
 import requests

-
-def fetch_credit_data(api_key: str) -> dict:
+def fetch_credit_data(api_key: str, http_proxy: str) -> dict:
    """OpenAI账号免费额度剩余查询"""
+    proxies = {
+        "http":http_proxy,
+        "https":http_proxy
+    } if http_proxy is not None else None
+
    resp = requests.get(
        url="https://api.openai.com/dashboard/billing/credit_grants",
        headers={
            "Authorization": "Bearer {}".format(api_key),
-        }
+        },
+        proxies=proxies
    )
+
    return resp.json()
--- a/pkg/utils/network.py
+++ b/pkg/utils/network.py
@@ -0,0 +1,9 @@
+
+def wrapper_proxies() -> dict:
+    """获取代理"""
+    import config
+
+    return {
+        "http": config.openai_config['proxy'],
+        "https": config.openai_config['proxy']
+    } if 'proxy' in config.openai_config and (config.openai_config['proxy'] is not None) else None
--- a/pkg/utils/reloader.py
+++ b/pkg/utils/reloader.py
@@ -3,7 +3,7 @@ import threading

 import importlib
 import pkgutil
-import pkg.utils.context
+import pkg.utils.context as context
 import pkg.plugin.host


@@ -22,20 +22,26 @@ def walk(module, prefix='', path_prefix=''):
 def reload_all(notify=True):
    # 解除bot的事件注册
    import pkg
-    pkg.utils.context.get_qqbot_manager().unsubscribe_all()
+    context.get_qqbot_manager().unsubscribe_all()
    # 执行关闭流程
    logging.info("执行程序关闭流程")
    import main
    main.stop()

+    # 删除所有已注册的指令
+    import pkg.qqbot.cmds.mgr as cmdsmgr
+    cmdsmgr.__command_list__ = {}
+    cmdsmgr.__tree_index__ = {}
+
    # 重载所有模块
-    pkg.utils.context.context['exceeded_keys'] = pkg.utils.context.get_openai_manager().key_mgr.exceeded
-    context = pkg.utils.context.context
+    context.context['exceeded_keys'] = context.get_openai_manager().key_mgr.exceeded
+    this_context = context.context
    walk(pkg)
+    importlib.reload(__import__("config-template"))
    importlib.reload(__import__('config'))
    importlib.reload(__import__('main'))
    importlib.reload(__import__('banlist'))
-    pkg.utils.context.context = context
+    context.context = this_context

    # 重载插件
    import plugins
@@ -43,8 +49,16 @@ def reload_all(notify=True):

    # 执行启动流程
    logging.info("执行程序启动流程")
-    threading.Thread(target=main.main, args=(False,), daemon=False).start()
+    main.load_config()
+    context.get_thread_ctl().reload(
+        admin_pool_num=context.get_config().admin_pool_num,
+        user_pool_num=context.get_config().user_pool_num
+    )
+    context.get_thread_ctl().submit_sys_task(
+        main.start,
+        False
+    )

    logging.info('程序启动完成')
    if notify:
-        pkg.utils.context.get_qqbot_manager().notify_admin("重载完成")
+        context.get_qqbot_manager().notify_admin("重载完成")
--- a/pkg/utils/threadctl.py
+++ b/pkg/utils/threadctl.py
@@ -0,0 +1,96 @@
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+
+
+class Pool:
+    '''
+    线程池结构
+    '''
+    pool_num:int = None
+    ctl:ThreadPoolExecutor = None
+    task_list:list = None
+    task_list_lock:threading.Lock = None
+    monitor_type = True
+
+    def __init__(self, pool_num):
+        self.pool_num = pool_num
+        self.ctl = ThreadPoolExecutor(max_workers = self.pool_num)
+        self.task_list = []
+        self.task_list_lock = threading.Lock()
+    
+    def __thread_monitor__(self):
+        while self.monitor_type:
+            for t in self.task_list:
+                if not t.done():
+                    continue
+                try:
+                    self.task_list.pop(self.task_list.index(t))
+                except:
+                    continue
+            time.sleep(1)
+
+
+class ThreadCtl:
+    def __init__(self, sys_pool_num, admin_pool_num, user_pool_num):
+        '''
+        线程池控制类
+        sys_pool_num：分配系统使用的线程池数量(>=8)
+        admin_pool_num：用于处理管理员消息的线程池数量(>=1)
+        user_pool_num：分配用于处理用户消息的线程池的数量(>=1)
+        '''
+        if sys_pool_num < 5:
+            raise Exception("Too few system threads(sys_pool_num needs >= 8, but received {})".format(sys_pool_num))
+        if admin_pool_num < 1:
+            raise Exception("Too few admin threads(admin_pool_num needs >= 1, but received {})".format(admin_pool_num))
+        if user_pool_num < 1:
+            raise Exception("Too few user threads(user_pool_num needs >= 1, but received {})".format(admin_pool_num))
+        self.__sys_pool__ = Pool(sys_pool_num)
+        self.__admin_pool__ = Pool(admin_pool_num)
+        self.__user_pool__ = Pool(user_pool_num)
+        self.submit_sys_task(self.__sys_pool__.__thread_monitor__)
+        self.submit_sys_task(self.__admin_pool__.__thread_monitor__)
+        self.submit_sys_task(self.__user_pool__.__thread_monitor__)
+
+    def __submit__(self, pool: Pool, fn, /, *args, **kwargs ):
+        t = pool.ctl.submit(fn, *args, **kwargs)
+        pool.task_list_lock.acquire()
+        pool.task_list.append(t)
+        pool.task_list_lock.release()
+        return t
+
+    def submit_sys_task(self, fn, /, *args, **kwargs):
+        return self.__submit__(
+            self.__sys_pool__,
+            fn, *args, **kwargs
+        )
+
+    def submit_admin_task(self, fn, /, *args, **kwargs):
+        return self.__submit__(
+            self.__admin_pool__,
+            fn, *args, **kwargs
+        )
+
+    def submit_user_task(self, fn, /, *args, **kwargs):
+        return self.__submit__(
+            self.__user_pool__,
+            fn, *args, **kwargs
+        )
+
+    def shutdown(self):
+        self.__user_pool__.ctl.shutdown(cancel_futures=True)
+        self.__user_pool__.monitor_type = False
+        self.__admin_pool__.ctl.shutdown(cancel_futures=True)
+        self.__admin_pool__.monitor_type = False
+        self.__sys_pool__.monitor_type = False
+        self.__sys_pool__.ctl.shutdown(wait=True, cancel_futures=False)
+
+    def reload(self, admin_pool_num, user_pool_num):
+        self.__user_pool__.ctl.shutdown(cancel_futures=True)
+        self.__user_pool__.monitor_type = False
+        self.__admin_pool__.ctl.shutdown(cancel_futures=True)
+        self.__admin_pool__.monitor_type = False
+        self.__admin_pool__ = Pool(admin_pool_num)
+        self.__user_pool__ = Pool(user_pool_num)
+        self.submit_sys_task(self.__admin_pool__.__thread_monitor__)
+        self.submit_sys_task(self.__user_pool__.__thread_monitor__)
--- a/pkg/utils/updater.py
+++ b/pkg/utils/updater.py
@@ -6,6 +6,7 @@ import requests
 import json

 import pkg.utils.constants
+import pkg.utils.network as network


 def check_dulwich_closure():
@@ -36,7 +37,8 @@ def pull_latest(repo_path: str) -> bool:
 def get_release_list() -> list:
    """获取发行列表"""
    rls_list_resp = requests.get(
-        url="https://api.github.com/repos/RockChinQ/QChatGPT/releases"
+        url="https://api.github.com/repos/RockChinQ/QChatGPT/releases",
+        proxies=network.wrapper_proxies()
    )

    rls_list = rls_list_resp.json()
@@ -83,7 +85,10 @@ def update_all(cli: bool = False) -> bool:
    else:
        print("开始下载最新版本: {}".format(latest_rls['zipball_url']))
    zip_url = latest_rls['zipball_url']
-    zip_resp = requests.get(url=zip_url)
+    zip_resp = requests.get(
+        url=zip_url,
+        proxies=network.wrapper_proxies()
+    )
    zip_data = zip_resp.content

    # 检查temp/updater目录
@@ -126,6 +131,15 @@ def update_all(cli: bool = False) -> bool:
            dst = src.replace(source_root, ".")
            if os.path.exists(dst):
                os.remove(dst)
+
+            # 检查目标文件夹是否存在
+            if not os.path.exists(os.path.dirname(dst)):
+                os.makedirs(os.path.dirname(dst))
+            # 检查目标文件是否存在
+            if not os.path.exists(dst):
+                # 创建目标文件
+                open(dst, "w").close()
+
            shutil.copy(src, dst)

    # 把current_tag写入文件
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,5 +1,5 @@
 requests~=2.28.1
-openai~=0.27.0
+openai~=0.27.2
 dulwich~=0.21.3
 colorlog~=6.6.0
 yiri-mirai~=0.2.6.1
--- a/res/announcement
+++ b/res/announcement
@@ -0,0 +1 @@
+2023/3/31 21:35 【插件兼容性问题】若您使用了revLibs插件，并将主程序升级到了v2.3.0，请立即使用管理员账号向机器人账号发送!plugin update命令更新逆向库插件，以解决由于情景预设重构引起的兼容性问题。
--- a/scenario/default-template.json
+++ b/scenario/default-template.json
@@ -0,0 +1,12 @@
+{
+    "prompt": [
+        {
+            "role": "system",
+            "content": "You are a helpful assistant. 如果我需要帮助，你要说“输入!help获得帮助”"
+        },
+        {
+            "role": "assistant",
+            "content": "好的，我是一个能干的AI助手。 如果你需要帮助，我会说“输入!help获得帮助”"
+        }
+    ]
+}
--- a/tests/token_test/init.py
+++ b/tests/token_test/init.py
--- a/tests/token_test/token_count.py
+++ b/tests/token_test/token_count.py
Author	SHA1	Message	Date
Rock Chin	8164f4b506	Release v2.3.1	2023-04-02 16:32:52 +08:00
Rock Chin	9617be0ca4	fix: 未指定utf-8保存已输出的公告	2023-04-02 16:30:42 +08:00
Rock Chin	f079d7b9fa	fix: Windows上无法读取和应用命令权限配置的问题	2023-04-02 16:24:30 +08:00
Rock Chin	00afda452f	Merge pull request #365 from zyckk4/style-improvements 去除行尾空格	2023-04-02 16:04:52 +08:00
zyckk4	70386abadd	去除行尾空格	2023-04-02 14:43:34 +08:00
Rock Chin	aba9d945b5	doc: 收起功能概述	2023-04-01 09:59:33 +08:00
Rock Chin	ced38490e1	chore: 兼容性问题公告	2023-03-31 21:37:35 +08:00
Rock Chin	ad28b69198	doc: 添加ChatPoeBot插件链接 (#352 )	2023-03-31 21:31:40 +08:00
Rock Chin	7171817de8	Release v2.3.0	2023-03-31 07:42:06 +00:00
GitHub Actions Bot	73f9d674e1	Update cmdpriv-template.json	2023-03-31 07:40:07 +00:00
Rock Chin	5e046399f8	test: 删除测试文件	2023-03-31 07:39:35 +00:00
GitHub Actions Bot	4966cd9ac7	Update cmdpriv-template.json	2023-03-31 07:35:48 +00:00
Rock Chin	da936ecfe3	test: ci	2023-03-31 07:35:11 +00:00
Rock Chin	89e10d43de	ci: 解决所有依赖	2023-03-31 07:34:45 +00:00
Rock Chin	3bf289af69	test: 测试	2023-03-31 07:29:23 +00:00
Rock Chin	c7c9a6c5ca	ci: 运行前完善配置文件	2023-03-31 07:28:33 +00:00
Rock Chin	aee8446a23	test: 测试工作流	2023-03-31 07:25:53 +00:00
Rock Chin	2bb4f1fbb8	ci: 工作流	2023-03-31 07:25:27 +00:00
Rock Chin	6e7b0ee4ff	test: 测试工作流	2023-03-31 07:24:17 +00:00
Rock Chin	204f5b9a54	ci: 工作流语法错误	2023-03-31 07:23:35 +00:00
Rock Chin	8c41e3506f	test: 测试工作流	2023-03-31 07:22:33 +00:00
Rock Chin	c2c33e45b8	ci: 更新工作流文件	2023-03-31 07:21:03 +00:00
Rock Chin	1acaf4e58b	Merge pull request #336 from RockChinQ/cmds-permission-ctrl [Refactor&Feat] 命令节点权限控制	2023-03-31 15:18:44 +08:00
Rock Chin	eca80d5a4c	ci: 添加cmdpriv-template.json的自动化生成脚本	2023-03-31 07:18:08 +00:00
Rock Chin	f538957be9	doc: 更新wiki	2023-03-31 07:06:42 +00:00
Rock Chin	82a839a60a	doc: 完善命令权限功能说明	2023-03-31 07:06:18 +00:00
Rock Chin	df494da9e4	feat: 支持命令限权	2023-03-31 06:49:13 +00:00
Rock Chin	1ea53f7f04	Merge pull request #342 from q123458384/patch-1 Update docker_deploy.md	2023-03-30 22:30:34 +08:00
Rock Chin	ac6d695f6d	doc: 完善主程序容器启动指令的挂载项	2023-03-30 21:26:10 +08:00
Rock Chin	73dccb21f5	feat: 添加指令权限配置文件	2023-03-30 11:29:04 +00:00
Rock Chin	4221102ad5	chore: 删除过时的命令架构文件	2023-03-30 11:12:27 +00:00
Rock Chin	b100f12e7f	refactor: 完成所有指令	2023-03-30 11:11:39 +00:00
Rock Chin	2069ba6836	refactor: system类命令	2023-03-30 03:38:33 +00:00
crosscc	ea57976808	Update docker_deploy.md 2.1中 `network host` 就是开放容器内的所有端口，和 `-p 端口：端口` 不共用 2.1中 `-v ./qq/xxx` 在群晖中不能用，改成了`${PWD}/qq/xxx` 3 中容器名和上面的重复了，映射整个目录会无法运行，改成只映射 config.py 以上是我docker部署中遇到的问题及修改	2023-03-29 16:44:16 +08:00
Rock Chin	4055d3542b	refactor: 完成会话管理相关指令	2023-03-28 13:47:45 +00:00
Rock Chin	0b0271a1f4	refactor: 更改使用装饰器注册命令	2023-03-28 12:53:46 +00:00
Rock Chin	e03585ad4d	feat: 扁平化储存命令	2023-03-28 12:18:19 +00:00
Rock Chin	11a385791e	doc: 添加贡献相关说明	2023-03-28 12:52:37 +08:00
Rock Chin	e228225178	refactor: 指令注册架构	2023-03-28 03:12:19 +00:00
Rock Chin	1c96d971e1	Update bug-report.yml	2023-03-27 21:22:56 +08:00
Rock Chin	b799de7995	refactor: 迁移旧的处理模块	2023-03-27 13:09:40 +00:00
Rock Chin	b01d246555	doc: 删除安装器使用警告	2023-03-27 18:52:40 +08:00
Rock Chin	9363b073cf	Merge pull request #334 from maimierjiafude/patch-1 [Fix] 修改模块无法找到的问题	2023-03-27 18:51:05 +08:00
maimierjiafude	12ca04ac6f	修改模块无法找到的问题	2023-03-27 18:45:29 +08:00
Rock Chin	51737c28bd	Delete 需求建议.md	2023-03-27 11:31:05 +08:00
Rock Chin	50d5ec224a	Create feature-request.yml	2023-03-27 11:30:40 +08:00
Rock Chin	95a7397d14	Update bug-report.yml	2023-03-27 11:23:10 +08:00
Rock Chin	aedac6d22c	Create bug-report.yml	2023-03-27 11:21:45 +08:00
Rock Chin	d522975ecc	Delete 漏洞反馈.yml	2023-03-27 11:17:14 +08:00
Rock Chin	68fda8d7f3	Update 漏洞反馈.yml	2023-03-27 11:16:48 +08:00
Rock Chin	b0cfec9913	Update 漏洞反馈.yml	2023-03-27 11:11:07 +08:00
Rock Chin	ba8eba1581	Update 漏洞反馈.yml	2023-03-27 11:10:41 +08:00
Rock Chin	f9eaed41c1	Update 漏洞反馈.yml	2023-03-27 11:07:16 +08:00
Rock Chin	1202a62df7	Update 漏洞反馈.yml	2023-03-27 11:06:11 +08:00
Rock Chin	8c1f7796f6	Update 漏洞反馈.yml	2023-03-27 11:02:18 +08:00
Rock Chin	42aee35789	Update 漏洞反馈.yml	2023-03-27 11:01:47 +08:00
Rock Chin	b628849caa	Update 漏洞反馈.yml	2023-03-27 11:00:21 +08:00
Rock Chin	031f08b0d4	Rename 漏洞反馈.md to 漏洞反馈.yml	2023-03-27 10:57:40 +08:00
Rock Chin	fab6f9b93f	Update 漏洞反馈.md	2023-03-27 10:57:00 +08:00
GitHub Actions	564c5d937d	Update override-all.json	2023-03-26 15:45:06 +00:00
Rock Chin	2d3bb01487	debug: 测试完毕	2023-03-26 23:44:49 +08:00
GitHub Actions	607ea2d293	Update override-all.json	2023-03-26 15:43:54 +00:00
Rock Chin	d817b53780	debug: 测试工作流	2023-03-26 23:43:34 +08:00
Rock Chin	e8a2cbe06a	Rename update override-all.json to update-override-all.yml	2023-03-26 23:42:42 +08:00
Rock Chin	d2b0577752	Update update override-all.json	2023-03-26 23:41:15 +08:00
Rock Chin	b4edd5cbad	Update update override-all.json	2023-03-26 23:38:38 +08:00
Rock Chin	348477747e	debug: 测试override-all.json工作流	2023-03-26 23:35:44 +08:00
Rock Chin	bb7ee174ea	Create update override-all.json	2023-03-26 23:34:50 +08:00
Rock Chin	ab5add14ef	chore: 完善override-all.json	2023-03-26 15:27:17 +00:00
Rock Chin	44f4820cee	Merge pull request #332 from RockChinQ/reverse-proxy [Feat] 支持反向代理	2023-03-26 22:51:06 +08:00
Rock Chin	8f1609b944	doc: 完善反代地址说明	2023-03-26 14:50:03 +00:00
Rock Chin	66b5b75631	feat: 支持反向代理	2023-03-26 13:50:43 +00:00
Rock Chin	17e293afe8	Merge pull request #325 from RockChinQ/fix-289-full-default-compatibility [Feat] 完善情景预设相关内容	2023-03-26 21:40:36 +08:00
Rock Chin	1cf35f59fd	Merge branch 'master' into fix-289-full-default-compatibility	2023-03-26 21:40:21 +08:00
Rock Chin	bb4b897934	feat(dprompt.py): 解耦完成	2023-03-26 13:28:26 +00:00
Rock Chin	0eaf1af2e3	doc: 添加Python环境冲突警告	2023-03-26 15:25:21 +08:00
Rock Chin	f70c12540b	Merge pull request #327 from mikumifa/master Dockerfile部署	2023-03-25 23:12:52 +08:00
Rock Chin	479fe73c24	doc: 在README.md链接docker教程	2023-03-25 23:12:26 +08:00
Rock Chin	f6cad85476	feat: 使用normal作为情景预设默认模式的名称	2023-03-24 20:02:50 +08:00
mikumifa	888197e6ce	Dockerfile部署	2023-03-24 19:58:27 +08:00
Rock Chin	e634305759	doc: 完善full_scenario的说明	2023-03-24 11:30:53 +00:00
Rock Chin	fe054211f4	chore: 代码格式优化	2023-03-23 23:44:10 +08:00
Rock Chin	f102a29ea0	Merge pull request #323 from RockChinQ/multi-threads-control [Feat] 基于线程池的多线程控制方案	2023-03-23 22:56:51 +08:00
Rock Chin	2b8bd45bcd	Merge branch 'master' into multi-threads-control	2023-03-23 21:43:41 +08:00
Rock Chin	7f730c4be0	Merge pull request #252 from LINSTCL/multi-threads-control 添加线程控制类，修改main结构，修改启动流程	2023-03-23 21:35:22 +08:00
Rock Chin	b6e31cac23	fix: 重载时重复调用load_config()	2023-03-23 21:29:51 +08:00
Rock Chin	9fe4f218d5	chore: config-template格式	2023-03-23 21:09:40 +08:00
LINSTCL	cc38cc2676	修复bug	2023-03-23 16:43:41 +08:00
LINSTCL	f56c6876d1	暂时解决reload后的config无法加载问题	2023-03-23 16:42:15 +08:00
LINSTCL	196e424c88	添加说明	2023-03-23 16:37:01 +08:00
Rock Chin	9270dc2c52	Release v2.2.5	2023-03-20 14:02:38 +00:00
Rock Chin	14aec251b4	Merge pull request #315 from RockChinQ/impl-312 [Feat] 访问GitHub API时使用openai_config中设置的代理地址	2023-03-20 21:49:33 +08:00
Rock Chin	d2a7a57245	feat: 为GitHub API的访问使用代理 (#312 )	2023-03-20 13:40:23 +00:00
Rock Chin	1964fc76c8	doc: 完善wiki指引	2023-03-20 13:25:02 +00:00
Rock Chin	b8d4b490ce	doc: 添加部署说明	2023-03-20 13:12:25 +00:00
Rock Chin	76891e4855	doc: 添加指令说明指引	2023-03-20 13:09:05 +00:00
Rock Chin	3d868b3a39	Merge pull request #308 from RockChinQ/plugin-ctrl-cmd [Feat] 解耦指令处理、完善插件管理指令	2023-03-20 21:04:06 +08:00
Rock Chin	7b56bcf7a9	feat: 添加插件启用禁用指令	2023-03-20 13:02:30 +00:00
Rock Chin	f96ae56bce	feat: 支持指令删除插件 (#286 )	2023-03-20 12:50:25 +00:00
Rock Chin	d52108f4e1	doc: 完善README.md	2023-03-20 12:49:18 +00:00
Rock Chin	5f07b7ad1f	refactor: 完成所有指令重构	2023-03-20 12:06:02 +00:00
Rock Chin	cda10cf1a6	Update 漏洞反馈.md	2023-03-20 19:17:53 +08:00
Rock Chin	d226b8ebc5	doc: 完善文档 (#310 )	2023-03-20 14:46:39 +08:00
Rock Chin	d08794579c	feat: 现有指令占位	2023-03-19 14:33:01 +00:00
Rock Chin	7450494741	Update pull_request_template.md	2023-03-19 20:33:23 +08:00
Rock Chin	36dca7ae2f	feat: 添加指令抽象类	2023-03-19 12:27:21 +00:00
Rock Chin	5dae777e79	doc: 添加wiki为submodule	2023-03-19 09:43:45 +00:00
Rock Chin	e518d172d7	Merge pull request #304 from RockChinQ/bd-check-exception [Perf] 百度云审核的异常处理	2023-03-19 17:13:37 +08:00
Rock Chin	af29277acd	feat: 长消息检查函数不再检查敏感词	2023-03-19 09:06:32 +00:00
Rock Chin	79bfa0792d	feat: 删除print调试信息	2023-03-19 08:45:54 +00:00
Rock Chin	cf23c5d31c	Release v2.2.4	2023-03-19 08:38:07 +00:00
Rock Chin	84418a296b	doc: 完善pr模板	2023-03-19 08:37:23 +00:00
Rock Chin	5f83cc6bb7	Merge pull request #300 from RockChinQ/token-process [Perf] Tokens相关处理逻辑优化	2023-03-19 16:35:25 +08:00
Rock Chin	cde168c93c	doc: full_scenario的编写教程 (#301 )	2023-03-19 08:32:34 +00:00
Rock Chin	fed24c0748	doc: 添加chordfish-k/QChartGPT_Emoticon_Plugin	2023-03-19 13:35:20 +08:00
Rock Chin	b45d11b3c3	Update pull_request_template.md	2023-03-19 11:28:38 +08:00
Rock Chin	84d9af69bb	Update pull_request_template.md	2023-03-19 11:28:17 +08:00
Rock Chin	684d356646	Update pull_request_template.md	2023-03-19 11:17:07 +08:00
Rock Chin	975300c9fc	Create pull_request_template.md	2023-03-19 11:15:45 +08:00
Rock Chin	ca349e33fc	feat: 实现新的前文剪切模式	2023-03-18 15:57:28 +00:00
Rock Chin	ccf62fe95c	doc: 致谢GPT-4内测提供者	2023-03-18 22:28:06 +08:00
Rock Chin	d056cb6769	feat: 数据库接口支持	2023-03-18 12:57:36 +00:00
Rock Chin	b0016eebf9	feat: 添加override-all.json	2023-03-18 20:44:14 +08:00
Rock Chin	0490ad9207	test: token计数测试	2023-03-18 11:26:18 +00:00
Rock Chin	4a20ae236b	doc: README.md格式错误	2023-03-18 09:15:26 +00:00
Rock Chin	9be1c7fc6f	doc: 添加WaitYiYan插件链接	2023-03-18 08:17:51 +00:00
Rock Chin	5621d32b30	doc: GPT-4说明	2023-03-18 04:42:46 +00:00
Rock Chin	b7642fe876	feat: 支持GPT-4 API	2023-03-18 04:38:48 +00:00
Rock Chin	c842485d33	perf: 尝试安装依赖时的逻辑	2023-03-17 07:49:27 +00:00
Rock Chin	341444ef1c	chore: 添加devcontainer配置	2023-03-17 07:39:16 +00:00
Rock Chin	66f5a219d2	feat: 不再提示InvalidRequestError的可能原因	2023-03-16 21:10:10 +08:00
Rock Chin	cf678aa345	feat: 修改日志初始化顺序	2023-03-16 20:55:57 +08:00
Rock Chin	d1549b3df0	chore: 代码格式优化	2023-03-16 20:22:18 +08:00
Rock Chin	002919fffe	doc: 优化README.md格式	2023-03-16 19:38:35 +08:00
Rock Chin	087d097204	feat: 不再默认提供max_tokens	2023-03-16 13:37:48 +08:00
Rock Chin	ca4eeda6f0	doc: 添加oliverkirk-sudo的文字转语音插件	2023-03-16 09:08:00 +08:00
Rock Chin	94543a4708	Merge pull request #282 from systemtang/bugfix [Feat] 修复usage命令的代理问题	2023-03-16 08:53:25 +08:00
Rock Chin	d4738dfb46	Release v2.2.3	2023-03-15 22:50:40 +08:00
Rock Chin	3bdf6810aa	fix: 消息处理时的错误	2023-03-15 22:47:20 +08:00
systemt	f489c2f3b4	修复usage命令的代理问题	2023-03-15 21:04:55 +08:00
Rock Chin	a724bfe155	Release v2.2.2	2023-03-15 20:39:10 +08:00
Rock Chin	179a372bfe	feat: 更改到process.py处理长消息	2023-03-15 20:33:44 +08:00
Rock Chin	651d765ab0	doc: 添加New Bing说明	2023-03-15 17:33:31 +08:00
Rock Chin	7ddc853f63	chore: 忽略保存的公告	2023-03-15 15:50:14 +08:00
Rock Chin	1bd1bfc725	chore: 删除测试公告	2023-03-15 15:47:24 +08:00
Rock Chin	f6ec0fda7a	Merge pull request #280 from RockChinQ/announcement [Feat] 添加公告输出功能	2023-03-15 15:46:58 +08:00
Rock Chin	7be368ae8c	feat: 添加公告功能	2023-03-15 15:43:36 +08:00
Rock Chin	f67db2617b	debug: 测试公告内容1	2023-03-15 15:37:07 +08:00
Rock Chin	ed5bf8100f	chore: 添加公告内容	2023-03-15 15:22:19 +08:00
Rock Chin	0ef8a1c9ae	chore: 为new bing忽略cookies.json	2023-03-15 11:24:45 +08:00
Rock Chin	32460cbf78	doc: 添加GPT-4公告	2023-03-15 11:04:10 +08:00
Rock Chin	6f6c9c222c	doc: 添加网页版GPT-4说明	2023-03-15 10:57:29 +08:00
Rock Chin	438d0ed1ea	Merge pull request #277 from zyckk4/dev chore: 去除多余import	2023-03-14 13:11:47 +08:00
zyckk4	3ef1c71cad	chore: 去除多余import	2023-03-14 13:03:50 +08:00
Rock Chin	aaadf6b8ba	doc: 部署方式依赖项指令	2023-03-14 10:57:02 +08:00
Rock Chin	6af614f319	doc: 整理致谢列表	2023-03-14 10:54:46 +08:00
Rock Chin	c75dbd67df	doc: 整理致谢列表	2023-03-14 10:53:32 +08:00
Rock Chin	dc3d186e2a	Merge pull request #274 from RockChinQ/dependabot/pip/openai-approx-eq-0.27.2 chore(deps): update openai requirement from ~=0.27.0 to ~=0.27.2	2023-03-13 17:48:10 +08:00
dependabot[bot]	44550feddd	chore(deps): update openai requirement from ~=0.27.0 to ~=0.27.2 Updates the requirements on [openai](https://github.com/openai/openai-python) to permit the latest version. - [Release notes](https://github.com/openai/openai-python/releases) - [Commits](https://github.com/openai/openai-python/compare/v0.27.0...v0.27.2) --- updated-dependencies: - dependency-name: openai dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com>	2023-03-13 09:05:46 +00:00
Rock Chin	a0810d5f63	Merge pull request #271 from RockChinQ/config-covering feat: 支持json格式的配置文件 (#265)	2023-03-13 11:05:11 +08:00
Rock Chin	cfc97fb22d	feat: 支持json格式的配置文件 (#265 )	2023-03-13 10:58:15 +08:00
Rock Chin	d67dbe8062	doc: 添加JSON格式情景预设的说明	2023-03-13 10:31:21 +08:00
Rock Chin	e89035e11c	Release v2.2.1	2023-03-12 22:43:39 +08:00
Rock Chin	2ea711e629	fix: 更新包中包含新文件时更新失败	2023-03-12 22:43:02 +08:00
Rock Chin	a716f071be	Release v2.2.0	2023-03-12 20:48:15 +08:00
Rock Chin	3450a91824	Merge pull request #262 from chordfish-k/json_scenario [Feat] 情景预设（人格）完善	2023-03-12 20:40:20 +08:00
Rock Chin	d2c2b457e5	fix: !list指令显示的是机器人第一次回复 (#264 )	2023-03-12 20:31:28 +08:00
Rock Chin	9cd7e49804	feat: 分离储存会话情景预设和对话内容	2023-03-11 23:44:22 +08:00
Rock Chin	e9155e836f	feat: 允许通过前缀指定使用的JSON情景	2023-03-10 23:49:41 +08:00
Rock Chin	ed248539c7	doc: 标记二群已满	2023-03-10 23:33:54 +08:00
Rock Chin	54cc75506f	feat: 使用模板储存默认的json格式的情景预设	2023-03-10 23:26:36 +08:00
Rock Chin	4269c7927e	chore: typo	2023-03-10 23:14:32 +08:00
Rock Chin	064ac7f603	feat: 添加窗口处于暂停模式的提示	2023-03-10 22:50:07 +08:00
Rock Chin	48ccf15273	Merge pull request #263 from RockChinQ/history-deletion [Feat] 支持删除指定当前会话的指定或全部历史记录 (#239)	2023-03-10 22:40:19 +08:00
Rock Chin	b920ced6d4	feat: !delhst 指令支持管理员删除会话历史记录	2023-03-10 21:20:19 +08:00
Rock Chin	69610a674c	perf: 更改help中指令信息帮助	2023-03-10 21:11:55 +08:00
Rock Chin	1828e34190	feat: 支持删除指定当前会话的指定或全部历史记录 (#239 )	2023-03-10 21:04:20 +08:00
chordfish	d53f4e3917	adjust:修改，去除neko.json，以及一些占位的变量等	2023-03-10 19:37:29 +08:00
chordfish	01706d5b4e	Delete mesugaki.json	2023-03-10 16:17:47 +08:00
chordfish	8916b8a450	Update manager.py	2023-03-10 16:17:07 +08:00
chordfish	ed33af5638	Update README.md	2023-03-10 14:10:54 +08:00
chordfish	c94a9e1ae6	bug:修复上次更新后不响应的问题	2023-03-10 13:55:56 +08:00
chordfish	e2e93afd06	bug:修复上次更新后不响应的问题	2023-03-10 13:03:25 +08:00
chordfish	a810158d5b	bug:修复上次更新后不响应的问题	2023-03-10 12:43:07 +08:00
chordfish	5a5ebb95fc	bug:修复上次更新后不响应的问题	2023-03-10 12:35:58 +08:00
chordfish	61dd9e29c0	Merge branch 'master' into json_scenario	2023-03-10 10:20:18 +08:00
chordfish	ac65d81ba1	adjust：整理代码，仅添加json方式的prompt读取	2023-03-10 10:13:40 +08:00
LINSTCL	3aca987176	暴力修复程序无法退出的bug	2023-03-10 09:35:59 +08:00
chordfish	7288d3cb15	删除一部分注释和调试信息	2023-03-09 21:20:59 +08:00
chordfish	7477c7c67f	删除一部分注释和调试内容	2023-03-09 21:16:15 +08:00
chordfish	453952859e	Merge branch 'full_scenario'	2023-03-09 21:08:47 +08:00
chordfish	85d46089e3	已按要求修改	2023-03-09 19:53:31 +08:00
chordfish	3b55f706de	修正防人格否定的一个Bug	2023-03-09 19:22:37 +08:00
chordfish	f448276423	Merge commit '830ee704da0903a8922dc757381cdf6fd68870a3'	2023-03-09 18:34:03 +08:00
chordfish	830ee704da	Bug修复	2023-03-09 18:32:39 +08:00
chordfish	393369e446	Merge branch 'master' of https://github.com/chordfish-k/QChatGPT	2023-03-09 18:29:37 +08:00
chordfish	2cc6a09905	Bug修复	2023-03-09 18:29:31 +08:00
chordfish	d7d9d88e16	适配线程版本	2023-03-09 17:56:57 +08:00
chordfish	357d6aaf75	更新配置文件	2023-03-09 15:52:18 +08:00
chordfish	8059c422e3	Update README.md	2023-03-09 14:48:21 +08:00
chordfish	b336e1334d	Update README.md	2023-03-09 14:47:39 +08:00
chordfish	12a0942ddb	初步追加通过json导入messages数组的方式进行情景预设	2023-03-09 14:44:33 +08:00
Rock Chin	7e5a77f77e	doc: 添加致谢 https://github.com/qq255204159	2023-03-08 16:16:41 +08:00
LINSTCL	e0caeb5dd2	Fix bugs	2023-03-08 16:08:09 +08:00
LINSTCL	77076f3bdd	添加线程控制类，修改main结构，修改启动流程	2023-03-08 15:21:37 +08:00
				`@@ -0,0 +1 @@`
				`2023/3/31 21:35 【插件兼容性问题】若您使用了revLibs插件，并将主程序升级到了v2.3.0，请立即使用管理员账号向机器人账号发送!plugin update命令更新逆向库插件，以解决由于情景预设重构引起的兼容性问题。`