Release v2.3.3

[Fix] help_message问题、额度检测接口问题

.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"
+}

.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

.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
+      

.github/ISSUE_TEMPLATE/漏洞反馈.md

@@ -1,22 +0,0 @@
----
-name: 漏洞反馈
-about: 报错或漏洞请使用这个模板创建
-title: "[BUG]"
-labels: 'bug'
-assignees: ''
-
----
-
-**运行环境**
-- 部署方式：
-    手动部署/自动部署/Docker部署
-- 系统环境：
-    例如： Centos x64
-- Python环境（仅手动部署填写）：
-    例如： Python 3.10.9
-
-**描述漏洞**  
-什么时候发生的，mirai还是主程序，越详细越好
-
-**完整报错信息**  
-完整的报错信息

.github/ISSUE_TEMPLATE/需求建议.md

@@ -1,10 +0,0 @@
----
-name: 需求建议
-about: 软件优化建议请使用这个模板创建
-title: "[ENHANCE]"
-labels: 'enhancement'
-assignees: ''
-
----
-
-不是需求建议请勿填写此模板！！！！

.github/dependabot.yml

@@ -0,0 +1,15 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "pip" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"
+    allow:
+      - dependency-name: "yiri-mirai"
+      - dependency-name: "dulwich"
+      - dependency-name: "openai"

.github/pull_request_template.md

@@ -0,0 +1,25 @@
+## 概述
+
+实现/解决/优化的内容: 
+
+### 事务
+
+- [ ] 已阅读仓库[贡献指引](../CONTRIBUTING.md)
+- [ ] 已与维护者在issues或其他平台沟通此PR大致内容
+
+## 以下内容可在起草PR后、合并PR前逐步完成
+
+### 功能
+
+- [ ] 已编写完善的配置文件字段说明（若有新增）
+- [ ] 已编写面向用户的新功能说明（若有必要）
+- [ ] 已测试新功能或更改
+
+### 兼容性
+
+- [ ] 已处理版本兼容性
+- [ ] 已处理插件兼容问题
+
+### 风险
+
+可能导致或已知的问题: 

.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

.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

.gitignore

@@ -3,4 +3,18 @@ config.py
 __pycache__/
 database.db
 qchatgpt.log
-config.py
+/banlist.py
+plugins/
+!plugins/__init__.py
+/revcfg.py
+prompts/
+logs/
+sensitive.json
+temp/
+current_tag
+scenario/
+!scenario/default-template.json
+override.json
+cookies.json
+res/announcement_saved
+cmdpriv.json

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "QChatGPT.wiki"]
+	path = QChatGPT.wiki
+	url = https://github.com/RockChinQ/QChatGPT.wiki.git

CONTRIBUTING.md

@@ -0,0 +1,19 @@
+## 参与项目
+
+欢迎为此项目贡献代码或其他支持，以使您的点子或众人期待的功能成为现实，助力社区成长。  
+
+### 贡献形式
+
+- 提交PR，解决issues中提到的bug或期待的功能
+- 提交PR，实现您设想的功能（请先提出issue与作者沟通）
+- 优化代码架构，使各个模块的组织更加整洁优雅
+- 在issues中提出发现的bug或者期待的功能
+- 为本项目在其他社交平台撰写文章、制作视频等
+- 为本项目的衍生项目作出贡献，或开发插件增加功能
+
+### 如何开始
+
+- 加入本项目交流群，一同探讨项目相关事务
+- 解决本项目或衍生项目的issues中亟待解决的问题
+- 阅读并完善本项目文档
+- 在各个社交媒体撰写本项目教程等

Dockerfile

@@ -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" ] 

README.md

@@ -1,29 +1,147 @@
 # QChatGPT🤖
 
+> 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)  
+
 - 到[项目Wiki](https://github.com/RockChinQ/QChatGPT/wiki)可了解项目详细信息
-- 由bilibili TheLazy制作的[视频教程](https://www.bilibili.com/video/BV15v4y1X7aP)
-- 测试号: 2196084348
-- 交流、答疑群: 204785790 
-  - **进群提问前请您`确保`已经找遍文档和issue均无法解决**  
-  - **进群提问前请您`确保`已经找遍文档和issue均无法解决**  
+- ~~由bilibili TheLazy制作的[视频教程](https://www.bilibili.com/video/BV15v4y1X7aP)~~（寄了，求大佬做个新的）
+- 交流、答疑群: ~~204785790~~（已满）、~~691226829~~（已满）、656285629  
   - **进群提问前请您`确保`已经找遍文档和issue均无法解决**  
 - QQ频道机器人见[QQChannelChatGPT](https://github.com/Soulter/QQChannelChatGPT)
+- 欢迎各种形式的贡献，请查看[贡献指引](CONTRIBUTING.md)
 
-通过调用OpenAI GPT-3模型提供的Completion API来实现一个更加智能的QQ机器人  
+通过调用OpenAI的ChatGPT等语言模型来实现一个更加智能的QQ机器人  
+
+## 🍺模型适配一览
+
+<details>
+<summary>点击此处展开</summary>
+
+### 文字对话
+
+- OpenAI GPT-3.5模型(ChatGPT API), 本项目原生支持, 默认使用
+- 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)接入
+
+### 故事续写
+
+- NovelAI API, 由[插件](https://github.com/dominoar/QCPNovelAi)接入
+
+### 图片绘制
+
+- OpenAI DALL·E模型, 本项目原生支持, 使用方法查看[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)
+- NovelAI API, 由[插件](https://github.com/dominoar/QCPNovelAi)接入
+
+### 语音生成
+
+- TTS+VITS, 由[插件](https://github.com/dominoar/QChatPlugins)接入
+- Plachta/VITS-Umamusume-voice-synthesizer, 由[插件](https://github.com/oliverkirk-sudo/chat_voice)接入
+
+
+</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)
+<details>
+<summary>点击此处展开概述</summary>
+
+<details>
+<summary>✅支持敏感词过滤，避免账号风险</summary>
+
+  - 难以监测机器人与用户对话时的内容，故引入此功能以减少机器人风险
+  - 加入了百度云内容审核，在`config.py`中修改`baidu_check`的值，并填写`baidu_api_key`和`baidu_secret_key`以开启此功能
+  - 编辑`sensitive.json`，并在`config.py`中修改`sensitive_word_filter`的值以开启此功能
+</details>
+
+<details>
+<summary>✅群内多种响应规则，不必at</summary>
+
+  - 默认回复`ai`作为前缀或`@`机器人的消息
+  - 详细见`config.py`中的`response_rules`字段
+</details>
+
+<details>
+<summary>✅完善的多api-key管理，超额自动切换</summary>
+
+  - 支持配置多个`api-key`，内部统计使用量并在超额时自动切换
+  - 请在`config.py`中修改`openai_config`的值以设置`api-key`
+  - 可以在`config.py`中修改`api_key_fee_threshold`来自定义切换阈值
+  - 运行期间向机器人说`!usage`以查看当前使用情况
+</details>
+
+<details>
+<summary>✅支持预设指令文字</summary>
+
+  - 支持以自然语言预设文字，自定义机器人人格等信息
+  - 详见`config.py`中的`default_prompt`部分
+  - 支持设置多个预设情景，并通过!reset、!default等指令控制，详细请查看[wiki指令](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)
+</details>
+
+<details>
+<summary>✅支持对话、绘图等模型，可玩性更高</summary>
+
+  - 现已支持OpenAI的对话`Completion API`和绘图`Image API`
+  - 向机器人发送指令`!draw <prompt>`即可使用绘图模型
+</details>
+<details>
+<summary>✅支持指令控制热重载、热更新</summary>
+
+  - 允许在运行期间修改`config.py`或其他代码后，以管理员账号向机器人发送指令`!reload`进行热重载，无需重启
+  - 运行期间允许以管理员账号向机器人发送指令`!update`进行热更新，拉取远程最新代码并执行热重载
+</details>
+<details>
+<summary>✅支持插件加载🧩</summary>
+
+  - 自行实现插件加载器及相关支持
+  - 详细查看[插件使用页](https://github.com/RockChinQ/QChatGPT/wiki/%E6%8F%92%E4%BB%B6%E4%BD%BF%E7%94%A8)
+</details>
+<details>
+<summary>✅私聊、群聊黑名单机制</summary>
+
+  - 支持将人或群聊加入黑名单以忽略其消息
+  - 详见Wiki`加入黑名单`节
+</details>
+<details>
+<summary>✅长消息处理策略</summary>
+
+  - 支持将长消息转换成图片或消息记录组件，避免消息刷屏
+  - 请查看`config.py`中`blob_message_strategy`等字段
+</details>
+<details>
+<summary>✅回复速度限制</summary>
+
+  - 支持限制单会话内每分钟可进行的对话次数
+  - 具有“等待”和“丢弃”两种策略
+    - “等待”策略：在获取到回复后，等待直到此次响应时间达到对话响应时间均值
+    - “丢弃”策略：此分钟内对话次数达到限制时，丢弃之后的对话
+  - 详细请查看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），可跳过此步骤，直接进行之后的部署，完成后按照相关插件的文档进行配置即可
 
-> [只需 1 元搞定 ChatGPT 注册](https://zhuanlan.zhihu.com/p/589470082)  
+参考以下文章自行注册
+
+> [国内注册ChatGPT的方法(100%可用)](https://www.pythonthree.com/register-openai-chatgpt/)  
 > [手把手教你如何注册ChatGPT，超级详细](https://guxiaobei.com/51461)
 
 注册成功后请前往[个人中心查看](https://beta.openai.com/account/api-keys)api_key  
@@ -36,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)）进行部署
 
 - 安装器目前仅支持部分平台，请到仓库文档查看，其他平台请手动部署
@@ -49,10 +169,7 @@
 <details>
 <summary>手动部署适用于所有平台</summary>
 
-- 请使用Python 3.9.x以上版本  
-- 请注意OpenAI账号额度消耗  
-  - 每个账户仅有18美元免费额度，如未绑定银行卡，则会在超出时报错  
-  - OpenAI收费标准：默认使用的`text-davinci-003`模型 0.02美元/千字  
+- 请使用Python 3.9.x以上版本   
 
 #### 配置Mirai
 
@@ -71,8 +188,7 @@ cd QChatGPT
 2. 安装依赖
 
 ```bash
-pip3 install yiri-mirai openai colorlog func_timeout
-pip3 install dulwich
+pip3 install requests yiri-mirai openai colorlog func_timeout dulwich Pillow
 ```
 
 3. 运行一次主程序，生成配置文件
@@ -95,17 +211,58 @@ python3 main.py
 
 **常见问题**
 
-- mirai登录提示`QQ版本过低`，见[此issue](https://github.com/RockChinQ/QChatGPT/issues/38)
+- mirai登录提示`QQ版本过低`，见[此issue](https://github.com/RockChinQ/QChatGPT/issues/137)
 - 如提示安装`uvicorn`或`hypercorn`请*不要*安装，这两个不是必需的，目前存在未知原因bug
 - 如报错`TypeError: As of 3.10, the *loop* parameter was removed from Lock() since it is no longer necessary`, 请参考 [此处](https://github.com/RockChinQ/QChatGPT/issues/5)
 
-
 </details>
 
 ## 🚀使用
 
-查看[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)  
 
-## 👍赞赏
+## 🧩插件生态
 
-<img alt="赞赏码" src="res/mm_reward_qrcode_1672840549070.png" width="400" height="400"/>
+现已支持自行开发插件对功能进行扩展或自定义程序行为  
+详见[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`目录下即可使用
+
+- `cmdcn` - 主程序指令中文形式
+- `hello_plugin` - 在收到消息`hello`时回复相应消息
+- `urlikethisijustsix` - 收到冒犯性消息时回复相应消息
+
+### 更多
+
+欢迎提交新的插件
+
+- [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/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) 为本项目开发多种插件
+- [@万神的星空](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"/> -->

banlist-template.py

@@ -0,0 +1,20 @@
+# 是否启用禁用列表
+enable = True
+
+# 禁用规则（黑名单）
+# person为个人，其中的QQ号会被禁止与机器人进行私聊或群聊交互
+# 示例: person = [2854196310, 1234567890, 9876543210]
+# group为群组，其中的群号会被禁止与机器人进行交互
+# 示例: group = [123456789, 987654321, 1234567890]
+#
+# 支持正则表达式，字符串都将被识别为正则表达式，例如：
+# person = [12345678, 87654321, "2854.*"]
+# group = [123456789, 987654321, "1234.*"]
+# 若要排除某个QQ号或群号（即允许使用），可以在前面加上"!"，例如：
+# person = ["!1234567890"]
+# group = ["!987654321"]
+# 排除规则优先级高于包含规则，即如果同时存在包含规则和排除规则，排除规则将生效，例如：
+# person = ["1234.*", "!1234567890"]
+# 那么1234567890将不会被禁用，而其他以1234开头的QQ号都会被禁用
+person = [2854196310]  # 2854196310是Q群管家机器人的QQ号，默认屏蔽以免出现循环
+group = [204785790, 691226829]  # 本项目交流群的群号，默认屏蔽，避免在交流群测试机器人

cmdpriv-template.json

@@ -0,0 +1,28 @@
+{
+    "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,
+    "cmd": 1,
+    "help": 1,
+    "reload": 2,
+    "update": 2,
+    "usage": 1,
+    "version": 1
+}

config-template.py

@@ -20,65 +20,166 @@ mirai_http_api_config = {
 
 # [必需] OpenAI的配置
 # api_key: OpenAI的API Key
+# http_proxy: 请求OpenAI时使用的代理，None为不使用，https和socks5暂不能使用
 # 若只有一个api-key，请直接修改以下内容中的"openai_api_key"为你的api-key
+#
 # 如准备了多个api-key，可以以字典的形式填写，程序会自动选择可用的api-key
-# 例如{
-#       "api0": "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
-#       "api1": "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
-#     }
+# 例如
+# openai_config = {
+#     "api_key": {
+#         "default": "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+#         "key1": "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+#         "key2": "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+#     },
+#     "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,
+    "reverse_proxy": None
 }
 
-# 管理员QQ号，用于接收报错等通知及执行管理员级别指令，为0时关闭此功能
+# [必需] 管理员QQ号，用于接收报错等通知及执行管理员级别指令
+# 支持多个管理员，可以使用list形式设置，例如：
+# admin_qq = [12345678, 87654321]
 admin_qq = 0
 
 # 情景预设（机器人人格）
 # 每个会话的预设信息，影响所有会话，无视指令重置
 # 可以通过这个字段指定某些情况的回复，可直接用自然语言描述指令
-# 例如: 如果我之后想获取帮助，请你说“输入!help获取帮助”，
+# 例如:
+# default_prompt = "如果我之后想获取帮助，请你说“输入!help获取帮助”"
 #   这样用户在不知所措的时候机器人就会提示其输入!help获取帮助
 # 可参考 https://github.com/PlexPt/awesome-chatgpt-prompts-zh
-default_prompt = "如果我之后想获取帮助，请你说“输入!help获取帮助”"
+#
+# 如果需要多个情景预设，并在运行期间方便切换，请使用字典的形式填写，例如
+# default_prompt = {
+#   "default": "如果我之后想获取帮助，请你说“输入!help获取帮助”",
+#   "linux-terminal": "我想让你充当 Linux 终端。我将输入命令，您将回复终端应显示的内容。",
+#   "en-dict": "我想让你充当英英词典，对于给出的英文单词，你要给出其中文意思以及英文解释，并且给出一个例句，此外不要有其他反馈。",
+# }
+#
+# 在使用期间即可通过指令：
+# !reset [名称]
+#   来使用指定的情景预设重置会话
+# 例如：
+# !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机器人也会响应
 # 支持消息前缀匹配及正则表达式匹配
-# 注意：由消息前缀(prefix)匹配的消息中将会删除此前缀，正则表达式匹配的消息不会删除匹配的部分
+# 支持设置是否响应at消息、随机响应概率
+# 注意：由消息前缀(prefix)匹配的消息中将会删除此前缀，正则表达式(regexp)匹配的消息不会删除匹配的部分
 #      前缀匹配优先级高于正则表达式匹配
 # 正则表达式简明教程：https://www.runoob.com/regexp/regexp-tutorial.html
 response_rules = {
+    "at": True,  # 是否响应at机器人的消息
     "prefix": ["/ai", "!ai", "！ai", "ai"],
-    "regexp": []  # "为什么.*", "怎么?样.*", "怎么.*", "如何.*", "[Hh]ow to.*", "[Ww]hy not.*", "[Ww]hat is.*", ".*怎么办", ".*咋办"
+    "regexp": [],  # "为什么.*", "怎么?样.*", "怎么.*", "如何.*", "[Hh]ow to.*", "[Ww]hy not.*", "[Ww]hat is.*", ".*怎么办", ".*咋办"
+    "random_rate": 0.0,  # 随机响应概率，0.0-1.0，0.0为不随机响应，1.0为响应所有消息, 仅在前几项判断不通过时生效
 }
 
-# 单个api-key的费用警告阈值
-# 当使用此api-key进行请求所消耗的费用估算达到此阈值时，会在控制台输出警告并通知管理员
-# 若之后还有未使用超过此值的api-key，则会切换到新的api-key进行请求
-# 单位：美元
-api_key_fee_threshold = 18.0
+# 消息忽略规则
+# 适用于私聊及群聊
+# 符合此规则的消息将不会被响应
+# 支持消息前缀匹配及正则表达式匹配
+# 此设置优先级高于response_rules
+# 用以过滤mirai等其他层级的指令
+# @see https://github.com/RockChinQ/QChatGPT/issues/165
+ignore_rules = {
+    "prefix": ["/"],
+    "regexp": []
+}
 
-# 是否根据估算的使用费用切换api-key
-# 设置为False将只在接口报错超额时自动切换
-auto_switch_api_key = False
+# 是否检查收到的消息中是否包含敏感词
+# 若收到的消息无法通过下方指定的敏感词检查策略，则发送提示信息
+income_msg_check = False
 
 # 敏感词过滤开关，以同样数量的*代替敏感词回复
 # 请在sensitive.json中添加敏感词
 sensitive_word_filter = True
 
-# 每次向OpenAI接口发送对话记录上下文的字符数
-# 最大不超过(4096 - max_tokens)个字符，max_tokens为上述completion_api_params中的max_tokens
-# 注意：较大的prompt_submit_length会导致OpenAI账户额度消耗更快
-prompt_submit_length = 1024
+# 是否启用百度云内容安全审核
+# 注册方式查看 https://cloud.baidu.com/doc/ANTIPORN/s/Wkhu9d5iy
+baidu_check = False
 
-# OpenAI的completion API的参数
+# 百度云API_KEY 24位英文数字字符串
+baidu_api_key = ""
+
+# 百度云SECRET_KEY 32位的英文数字字符串
+baidu_secret_key = ""
+
+# 不合规消息自定义返回
+inappropriate_message_tips = "[百度云]请珍惜机器人，当前返回内容不合规"
+
+# 启动时是否发送赞赏码
+# 仅当使用量已经超过2048字时发送
+encourage_sponsor_at_start = True
+
+# 每次向OpenAI接口发送对话记录上下文的字符数
+# 最大不超过(4096 - max_tokens)个字符，max_tokens为下方completion_api_params中的max_tokens
+# 注意：较大的prompt_submit_length会导致OpenAI账户额度消耗更快
+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'
+#    'text-davinci-002'
+#    'code-davinci-002'
+#    'code-cushman-001'
+#    'text-curie-001'
+#    'text-babbage-001'
+#    'text-ada-001'
+#
 # 具体请查看OpenAI的文档: https://beta.openai.com/docs/api-reference/completions/create
+# 请将内容修改到config.py中，请勿修改config-template.py
 completion_api_params = {
-    "model": "text-davinci-003",
-    "temperature": 0.6,  # 数值越低得到的回答越理性，取值范围[0, 1]
-    "max_tokens": 512,  # 每次向OpenAI请求的最大字符数, 不高于4096
+    "model": "gpt-3.5-turbo",
+    "temperature": 0.9,  # 数值越低得到的回答越理性，取值范围[0, 1]
     "top_p": 1,  # 生成的文本的文本与要求的符合度, 取值范围[0, 1]
     "frequency_penalty": 0.2,
     "presence_penalty": 1.0,
@@ -90,31 +191,82 @@ image_api_params = {
     "size": "256x256",  # 图片尺寸，支持256x256, 512x512, 1024x1024
 }
 
-# 回复消息时是否引用原消息
+# 群内回复消息时是否引用原消息
 quote_origin = True
 
 # 回复绘图时是否包含图片描述
 include_image_description = True
 
 # 消息处理的超时时间，单位为秒
-process_message_timeout = 15
-
-# 机器人的配置
-# user_name: 管理员(主人)的名字
-# bot_name: 机器人的名字
-user_name = 'You'
-bot_name = 'Bot'
+process_message_timeout = 30
 
 # 回复消息时是否显示[GPT]前缀
 show_prefix = False
 
+# 应用长消息处理策略的阈值
+# 当回复消息长度超过此值时，将使用长消息处理策略
+blob_message_threshold = 256
+
+# 长消息处理策略
+# - "image": 将长消息转换为图片发送
+# - "forward": 将长消息转换为转发消息组件发送
+blob_message_strategy = "forward"
+
+# 文字转图片时使用的字体文件路径
+# 当策略为"image"时生效
+#   若在Windows系统下，程序会自动使用Windows自带的微软雅黑字体
+#   若未填写或不存在且不是Windows，将禁用文字转图片功能，改为使用转发消息组件
+font_path = ""
+
 # 消息处理超时重试次数
 retry_times = 3
 
+# 消息处理出错时是否向用户隐藏错误详细信息
+# 设置为True时，仅向管理员发送错误详细信息
+# 设置为False时，向用户及管理员发送错误详细信息
+hide_exce_info_to_user = False
+
+# 消息处理出错时向用户发送的提示信息
+# 仅当hide_exce_info_to_user为True时生效
+# 设置为空字符串时，不发送提示信息
+alter_tip_message = '出错了，请稍后再试'
+
+# 线程池相关配置
+# 该参数决定机器人可以同时处理几个人的消息，超出线程池数量的请求会被阻塞，不会被丢弃
+# 如果你不清楚该参数的意义，请不要更改
+# 程序运行本身线程池，无代码层面修改请勿更改
+sys_pool_num = 8
+
+# 执行管理员请求和指令的线程池并行线程数量，一般和管理员数量相等
+admin_pool_num = 2
+
+# 执行用户请求和指令的线程池并行线程数量
+# 如需要更高的并发，可以增大该值
+user_pool_num = 6
+
 # 每个会话的过期时间，单位为秒
 # 默认值20分钟
 session_expire_time = 60 * 20
 
+# 会话限速
+# 单会话内每分钟可进行的对话次数
+# 若不需要限速，可以设置为一个很大的值
+# 默认值60次，基本上不会触发限速
+rate_limitation = 60
+
+# 会话限速策略
+# - "wait": 每次对话获取到回复时，等待一定时间再发送回复，保证其不会超过限速均值
+# - "drop": 此分钟内，若对话次数超过限速次数，则丢弃之后的对话，每自然分钟重置
+rate_limit_strategy = "wait"
+
+# drop策略时，超过限速均值时，丢弃的对话的提示信息
+# 仅当rate_limitation_strategy为"drop"时生效
+# 若设置为空字符串，则不发送提示信息
+rate_limit_drop_tip = "本分钟对话次数超过限速次数，此对话被丢弃"
+
+# 是否在启动时进行依赖库更新
+upgrade_dependencies = True
+
 # 是否上报统计信息
 # 用于统计机器人的使用情况，不会收集任何用户信息
 # 仅上报时间、字数使用量、绘图使用量，其他信息不会上报
@@ -131,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)

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
+```
+

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))

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)

main.py

@@ -1,4 +1,5 @@
 import importlib
+import json
 import os
 import shutil
 import threading
@@ -6,25 +7,35 @@ import time
 
 import logging
 import sys
+import traceback
 
-import mirai.exceptions
-import websockets.exceptions
+sys.path.append(".")
 
 try:
     import colorlog
 except ImportError:
-    print("未安装colorlog,请查看 https://github.com/RockChinQ/qcg-installer/issues/15")
-    sys.exit(1)
+    # 尝试安装
+    import pkg.utils.pkgmgr as pkgmgr
+    try:
+        pkgmgr.install_requirements("requirements.txt")
+        import colorlog
+    except ImportError:
+        print("依赖不满足,请查看 https://github.com/RockChinQ/qcg-installer/issues/15")
+        sys.exit(1)
 import colorlog
 
-sys.path.append(".")
+import requests
+import websockets.exceptions
+from urllib3.exceptions import InsecureRequestWarning
+import pkg.utils.context
+
 
 log_colors_config = {
     'DEBUG': 'green',  # cyan white
     'INFO': 'white',
     'WARNING': 'yellow',
     'ERROR': 'red',
-    'CRITICAL': 'bold_red',
+    'CRITICAL': 'cyan',
 }
 
 
@@ -35,52 +46,168 @@ def init_db():
     database.initialize_database()
 
 
+def ensure_dependencies():
+    import pkg.utils.pkgmgr as pkgmgr
+    pkgmgr.run_pip(["install", "openai", "Pillow", "--upgrade",
+                    "-i", "https://pypi.douban.com/simple/",
+                    "--trusted-host", "pypi.douban.com"])
+
+
 known_exception_caught = False
 
+log_file_name = "qchatgpt.log"
+
+
+def init_runtime_log_file():
+    """为此次运行生成日志文件
+    格式: qchatgpt-yyyy-MM-dd-HH-mm-ss.log
+    """
+    global log_file_name
+
+    # 检查logs目录是否存在
+    if not os.path.exists("logs"):
+        os.mkdir("logs")
+
+    # 检查本目录是否有qchatgpt.log，若有，移动到logs目录
+    if os.path.exists("qchatgpt.log"):
+        shutil.move("qchatgpt.log", "logs/qchatgpt.legacy.log")
+
+    log_file_name = "logs/qchatgpt-%s.log" % time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime())
+    
+
+def reset_logging():
+    global log_file_name
+
+    import config
+
+    if pkg.utils.context.context['logger_handler'] is not None:
+        logging.getLogger().removeHandler(pkg.utils.context.context['logger_handler'])
+
+    for handler in logging.getLogger().handlers:
+        logging.getLogger().removeHandler(handler)
+
+    logging.basicConfig(level=config.logging_level,  # 设置日志输出格式
+                        filename=log_file_name,  # log日志输出的文件位置和文件名
+                        format="[%(asctime)s.%(msecs)03d] %(filename)s (%(lineno)d) - [%(levelname)s] : %(message)s",
+                        # 日志输出的格式
+                        # -8表示占位符，让输出左对齐，输出长度都为8位
+                        datefmt="%Y-%m-%d %H:%M:%S"  # 时间输出的格式
+                        )
+    sh = logging.StreamHandler()
+    sh.setLevel(config.logging_level)
+    sh.setFormatter(colorlog.ColoredFormatter(
+        fmt="%(log_color)s[%(asctime)s.%(msecs)03d] %(filename)s (%(lineno)d) - [%(levelname)s] : "
+            "%(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+        log_colors=log_colors_config
+    ))
+    logging.getLogger().addHandler(sh)
+    pkg.utils.context.context['logger_handler'] = sh
+    return sh
+
+
+# 临时函数，用于加载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之后会被执行"""
 
-def main(first_time_init=False):
     global known_exception_caught
+    import pkg.utils.context
+
+    config = pkg.utils.context.get_config()
+    # 更新openai库到最新版本
+    if not hasattr(config, 'upgrade_dependencies') or config.upgrade_dependencies:
+        print("正在更新依赖库，请等待...")
+        if not hasattr(config, 'upgrade_dependencies'):
+            print("这个操作不是必须的,如果不想更新,请在config.py中添加upgrade_dependencies=False")
+        else:
+            print("这个操作不是必须的,如果不想更新,请在config.py中将upgrade_dependencies设置为False")
+        try:
+            ensure_dependencies()
+        except Exception as e:
+            print("更新openai库失败:{}, 请忽略或自行更新".format(e))
 
     known_exception_caught = False
     try:
-        # 导入config.py
-        assert os.path.exists('config.py')
 
-        config = importlib.import_module('config')
-
-        import pkg.utils.context
-        pkg.utils.context.set_config(config)
-
-        if pkg.utils.context.context['logger_handler'] is not None:
-            logging.getLogger().removeHandler(pkg.utils.context.context['logger_handler'])
-
-        logging.basicConfig(level=config.logging_level,  # 设置日志输出格式
-                            filename='qchatgpt.log',  # log日志输出的文件位置和文件名
-                            format="[%(asctime)s.%(msecs)03d] %(filename)s (%(lineno)d) - [%(levelname)s] : %(message)s",
-                            # 日志输出的格式
-                            # -8表示占位符，让输出左对齐，输出长度都为8位
-                            datefmt="%Y-%m-%d %H:%M:%S"  # 时间输出的格式
-                            )
-        sh = logging.StreamHandler()
-        sh.setLevel(config.logging_level)
-        sh.setFormatter(colorlog.ColoredFormatter(
-            fmt="%(log_color)s[%(asctime)s.%(msecs)03d] %(filename)s (%(lineno)d) - [%(levelname)s] : "
-                "%(message)s",
-            datefmt="%Y-%m-%d %H:%M:%S",
-            log_colors=log_colors_config
-        ))
-        logging.getLogger().addHandler(sh)
+        sh = reset_logging()
+        pkg.utils.context.context['logger_handler'] = sh
 
         # 检查是否设置了管理员
         if not (hasattr(config, 'admin_qq') and config.admin_qq != 0):
-            logging.warning("未设置管理员QQ,管理员权限指令及运行告警将无法使用,如需设置请修改config.py中的admin_qq字段")
+            # logging.warning("未设置管理员QQ,管理员权限指令及运行告警将无法使用,如需设置请修改config.py中的admin_qq字段")
+            while True:
+                try:
+                    config.admin_qq = int(input("未设置管理员QQ,管理员权限指令及运行告警将无法使用,请输入管理员QQ号: "))
+                    # 写入到文件
+
+                    # 读取文件
+                    config_file_str = ""
+                    with open("config.py", "r", encoding="utf-8") as f:
+                        config_file_str = f.read()
+                    # 替换
+                    config_file_str = config_file_str.replace("admin_qq = 0", "admin_qq = " + str(config.admin_qq))
+                    # 写入
+                    with open("config.py", "w", encoding="utf-8") as f:
+                        f.write(config_file_str)
+
+                    print("管理员QQ已设置，如需修改请修改config.py中的admin_qq字段")
+                    time.sleep(4)
+                    break
+                except ValueError:
+                    print("请输入数字")
 
         import pkg.openai.manager
         import pkg.database.manager
         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()
+
+        # 配置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()
 
@@ -96,7 +223,15 @@ def main(first_time_init=False):
                                                timeout=config.process_message_timeout, retry=config.retry_times,
                                                first_time_init=first_time_init)
 
-        if first_time_init:  # 不是热重载之后的启动,则不启动新的bot线程
+        # 加载插件
+        import pkg.plugin.host
+        pkg.plugin.host.load_plugins()
+
+        pkg.plugin.host.initialize_plugins()
+
+        if first_time_init:  # 不是热重载之后的启动,则启动新的bot线程
+
+            import mirai.exceptions
 
             def run_bot_wrapper():
                 global known_exception_caught
@@ -105,16 +240,16 @@ def main(first_time_init=False):
                 except TypeError as e:
                     if str(e).__contains__("argument 'debug'"):
                         logging.error(
-                            "连接bot失败:{}, 请查看 https://github.com/RockChinQ/QChatGPT/issues/82".format(e))
+                            "连接bot失败:{}, 解决方案: https://github.com/RockChinQ/QChatGPT/issues/82".format(e))
                         known_exception_caught = True
                     elif str(e).__contains__("As of 3.10, the *loop*"):
                         logging.error(
-                            "Websockets版本过低:{}, 请查看 https://github.com/RockChinQ/QChatGPT/issues/5".format(e))
+                            "Websockets版本过低:{}, 解决方案: https://github.com/RockChinQ/QChatGPT/issues/5".format(e))
                         known_exception_caught = True
 
                 except websockets.exceptions.InvalidStatus as e:
                     logging.error(
-                        "mirai-api-http端口无法使用:{}, 请查看 https://github.com/RockChinQ/QChatGPT/issues/22".format(
+                        "mirai-api-http端口无法使用:{}, 解决方案: https://github.com/RockChinQ/QChatGPT/issues/22".format(
                             e))
                     known_exception_caught = True
                 except mirai.exceptions.NetworkError as e:
@@ -123,19 +258,36 @@ def main(first_time_init=False):
                 except Exception as e:
                     if str(e).__contains__("404"):
                         logging.error(
-                            "mirai-api-http端口无法使用:{}, 请查看 https://github.com/RockChinQ/QChatGPT/issues/22".format(
+                            "mirai-api-http端口无法使用:{}, 解决方案: https://github.com/RockChinQ/QChatGPT/issues/22".format(
                                 e))
                         known_exception_caught = True
+                    elif str(e).__contains__("signal only works in main thread"):
+                        logging.error(
+                            "hypercorn异常:{}, 解决方案: https://github.com/RockChinQ/QChatGPT/issues/86".format(
+                                e))
+                        known_exception_caught = True
+                    elif str(e).__contains__("did not receive a valid HTTP"):
+                        logging.error(
+                            "mirai-api-http端口无法使用:{}, 解决方案: https://github.com/RockChinQ/QChatGPT/issues/22".format(
+                                e))
                     else:
                         logging.error(
-                            "捕捉到未知异常:{}, 请前往 https://github.com/RockChinQ/issues 查找或提issue".format(e))
+                            "捕捉到未知异常:{}, 请前往 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“ ,并且不回复消息,请查看 '
@@ -145,28 +297,55 @@ def main(first_time_init=False):
         else:
             logging.info('热重载完成')
 
-    while True:
-        try:
-            time.sleep(10)
-            if qqbot != pkg.utils.context.get_qqbot_manager():  # 已经reload了
-                logging.info("以前的main流程由于reload退出")
-                break
-        except KeyboardInterrupt:
-            stop()
+    # 发送赞赏码
+    if hasattr(config, 'encourage_sponsor_at_start') \
+        and config.encourage_sponsor_at_start \
+        and pkg.utils.context.get_openai_manager().audit_mgr.get_total_text_length() >= 2048:
 
-            print("程序退出")
-            sys.exit(0)
+        logging.info("发送赞赏码")
+        from mirai import MessageChain, Plain, Image
+        import pkg.utils.constants
+        message_chain = MessageChain([
+            Plain("自2022年12月初以来，开发者已经花费了大量时间和精力来维护本项目，如果您觉得本项目对您有帮助，欢迎赞赏开发者，"
+                  "以支持项目稳定运行😘"),
+            Image(base64=pkg.utils.constants.alipay_qr_b64),
+            Image(base64=pkg.utils.constants.wechat_qr_b64),
+            Plain("BTC: 3N4Azee63vbBB9boGv9Rjf4N5SocMe5eCq\nXMR: 89LS21EKQuDGkyQoe2nDupiuWXk4TVD6FALvSKv5owfmeJEPFpHeMsZLYtLiJ6GxLrhsRe5gMs6MyMSDn4GNQAse2Mae4KE\n\n"),
+            Plain("(本消息仅在启动时发送至管理员，如果您不想再看到此消息，请在config.py中将encourage_sponsor_at_start设置为False)")
+        ])
+        pkg.utils.context.get_qqbot_manager().notify_admin_message_chain(message_chain)
 
+    time.sleep(5)
+    import pkg.utils.updater
+    try:
+        if pkg.utils.updater.is_new_version_available():
+            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:
+        import pkg.plugin.host
+        pkg.plugin.host.unload_plugins()
+
         qqbot_inst = pkg.utils.context.get_qqbot_manager()
         assert isinstance(qqbot_inst, pkg.qqbot.manager.QQBotManager)
 
-        pkg.utils.context.get_openai_manager().key_mgr.dump_fee()
         for session in pkg.openai.session.sessions:
             logging.info('持久化session: %s', session)
             pkg.openai.session.sessions[session].persistence()
@@ -176,29 +355,96 @@ 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中填写配置')
         sys.exit(0)
 
+    # 检查是否有banlist.py,如果没有就把banlist-template.py复制一份
+    if not os.path.exists('banlist.py'):
+        shutil.copy('banlist-template.py', 'banlist.py')
+
+    # 检查是否有sensitive.json
+    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/")
+
+    # 检查并创建plugins、prompts目录
+    check_path = ["plugins", "prompts"]
+    for path in check_path:
+        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)
 
     elif len(sys.argv) > 1 and sys.argv[1] == 'update':
-        try:
-            from dulwich import porcelain
-
-            repo = porcelain.open_repo('.')
-            porcelain.pull(repo)
-        except ModuleNotFoundError:
-            print("dulwich模块未安装,请查看 https://github.com/RockChinQ/QChatGPT/issues/77")
+        print("正在进行程序更新...")
+        import pkg.utils.updater as updater
+        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)
+
+    pkg.utils.context.get_thread_ctl().submit_sys_task(
+        start,
+        True
+    )
+
+    # 主线程循环
+    while True:
+        try:
+            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()
 
-    main(True)

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"
+}

pkg/audit/__init__.py

@@ -0,0 +1,3 @@
+"""
+审计相关操作
+"""

pkg/audit/gatherer.py

@@ -1,3 +1,7 @@
+"""
+使用量统计以及数据上报功能实现
+"""
+
 import hashlib
 import json
 import logging
@@ -5,14 +9,16 @@ import logging
 import requests
 
 import pkg.utils.context
-
-version = "0.1.0"
+import pkg.utils.updater
 
 
 class DataGatherer:
     """数据收集器"""
+
     usage = {}
-    """以key值md5为key,{
+    """各api-key的使用量
+    
+    以key值md5为key,{
         "text": {
             "text-davinci-003": 文字量:int,
         },
@@ -21,22 +27,38 @@ class DataGatherer:
         }
     }为值的字典"""
 
+    version_str = "undetermined"
+
     def __init__(self):
         self.load_from_db()
+        try:
+            self.version_str = pkg.utils.updater.get_current_tag()  # 从updater模块获取版本号
+        except:
+            pass
 
     def report_to_server(self, subservice_name: str, count: int):
+        """向中央服务器报告使用量
+
+        只会报告此次请求的使用量，不会报告总量。
+        不包含除版本号、使用类型、使用量以外的任何信息，仅供开发者分析使用情况。
+        """
         try:
             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, version, 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:
             return
 
-    def report_text_model_usage(self, model, text):
-        key_md5 = pkg.utils.context.get_openai_manager().key_mgr.get_using_key_md5()
+    def get_usage(self, key_md5):
+        return self.usage[key_md5] if key_md5 in self.usage else {}
+
+    def report_text_model_usage(self, model, total_tokens):
+        """调用方报告文字模型请求文字使用量"""
+
+        key_md5 = pkg.utils.context.get_openai_manager().key_mgr.get_using_key_md5()  # 以key的md5进行储存
 
         if key_md5 not in self.usage:
             self.usage[key_md5] = {}
@@ -47,13 +69,15 @@ class DataGatherer:
         if model not in self.usage[key_md5]["text"]:
             self.usage[key_md5]["text"][model] = 0
 
-        length = int((len(text.encode('utf-8')) - len(text)) / 2 + len(text))
+        length = total_tokens
         self.usage[key_md5]["text"][model] += length
         self.dump_to_db()
 
         self.report_to_server("text", length)
 
     def report_image_model_usage(self, size):
+        """调用方报告图片模型请求图片使用量"""
+
         key_md5 = pkg.utils.context.get_openai_manager().key_mgr.get_using_key_md5()
 
         if key_md5 not in self.usage:
@@ -71,6 +95,7 @@ class DataGatherer:
         self.report_to_server("image", 1)
 
     def get_text_length_of_key(self, key):
+        """获取指定api-key (明文) 的文字总使用量(本地记录)"""
         key_md5 = hashlib.md5(key.encode('utf-8')).hexdigest()
         if key_md5 not in self.usage:
             return 0
@@ -80,6 +105,8 @@ class DataGatherer:
         return sum(self.usage[key_md5]["text"].values())
 
     def get_image_count_of_key(self, key):
+        """获取指定api-key (明文) 的图片总使用量(本地记录)"""
+
         key_md5 = hashlib.md5(key.encode('utf-8')).hexdigest()
         if key_md5 not in self.usage:
             return 0
@@ -88,6 +115,15 @@ class DataGatherer:
         # 遍历其中所有模型，求和
         return sum(self.usage[key_md5]["image"].values())
 
+    def get_total_text_length(self):
+        """获取所有api-key的文字总使用量(本地记录)"""
+        total = 0
+        for key in self.usage:
+            if "text" not in self.usage[key]:
+                continue
+            total += sum(self.usage[key]["text"].values())
+        return total
+
     def dump_to_db(self):
         pkg.utils.context.get_database_manager().dump_usage_json(self.usage)
 

pkg/database/__init__.py

@@ -0,0 +1,3 @@
+"""
+数据库操作封装
+"""

pkg/database/manager.py

@@ -1,3 +1,6 @@
+"""
+数据库管理模块
+"""
 import hashlib
 import json
 import logging
@@ -9,9 +12,9 @@ import sqlite3
 import pkg.utils.context
 
 
-# 数据库管理
-# 为其他模块提供数据库操作接口
 class DatabaseManager:
+    """封装数据库底层操作，并提供方法给上层使用"""
+
     conn = None
     cursor = None
 
@@ -23,21 +26,25 @@ class DatabaseManager:
 
     # 连接到数据库文件
     def reconnect(self):
+        """连接到数据库"""
         self.conn = sqlite3.connect('database.db', check_same_thread=False)
         self.cursor = self.conn.cursor()
 
     def close(self):
         self.conn.close()
 
-    def execute(self, *args, **kwargs) -> Cursor:
+    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
 
     # 初始化数据库的函数
     def initialize_database(self):
-        self.execute("""
+        """创建数据表"""
+
+        self.__execute__("""
         create table if not exists `sessions` (
             `id` INTEGER PRIMARY KEY AUTOINCREMENT,
             `name` varchar(255) not null,
@@ -46,20 +53,31 @@ 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 '[]'
         )
         """)
 
-        # self.execute("""
-        # create table if not exists `api_key_usage`(
-        #     `id` INTEGER PRIMARY KEY AUTOINCREMENT,
-        #     `key_md5` varchar(255) not null,
-        #     `timestamp` bigint not null,
-        #     `usage` bigint not null
-        # )
-        # """)
+        # 检查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("""
+
+        self.__execute__("""
         create table if not exists `account_fee`(
             `id` INTEGER PRIMARY KEY AUTOINCREMENT,
             `key_md5` varchar(255) not null,
@@ -68,7 +86,7 @@ class DatabaseManager:
         )
         """)
 
-        self.execute("""
+        self.__execute__("""
         create table if not exists `account_usage`(
             `id` INTEGER PRIMARY KEY AUTOINCREMENT,
             `json` text not null
@@ -78,47 +96,49 @@ 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
         # 如果有，就更新prompt和last_interact_timestamp
         # 如果没有，就插入一条新的记录
-        self.execute("""
+        self.__execute__("""
         select count(*) from `sessions` where `type` = '{}' and `number` = {} and `create_timestamp` = {}
         """.format(subject_type, subject_number, create_timestamp))
         count = self.cursor.fetchone()[0]
         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))
+            self.__execute__(sql,
+                             ("{}_{}".format(subject_type, subject_number), subject_type, subject_number, create_timestamp,
+                          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,
-                               subject_number, create_timestamp))
+            self.__execute__(sql, (last_interact_timestamp, prompt, token_counts, subject_type,
+                                   subject_number, create_timestamp))
 
     # 显式关闭一个session
     def explicit_close_session(self, session_name: str, create_timestamp: int):
-        self.execute("""
+        self.__execute__("""
         update `sessions` set `status` = 'explicitly_closed' where `name` = '{}' and `create_timestamp` = {}
         """.format(session_name, create_timestamp))
 
     def set_session_ongoing(self, session_name: str, create_timestamp: int):
-        self.execute("""
+        self.__execute__("""
         update `sessions` set `status` = 'on_going' where `name` = '{}' and `create_timestamp` = {}
         """.format(session_name, create_timestamp))
 
     # 设置session为过期
     def set_session_expired(self, session_name: str, create_timestamp: int):
-        self.execute("""
+        self.__execute__("""
         update `sessions` set `status` = 'expired' where `name` = '{}' and `create_timestamp` = {}
         """.format(session_name, create_timestamp))
 
@@ -126,8 +146,8 @@ class DatabaseManager:
     def load_valid_sessions(self) -> dict:
         # 从数据库中加载所有还没过期的session
         config = pkg.utils.context.get_config()
-        self.execute("""
-        select `name`, `type`, `number`, `create_timestamp`, `last_interact_timestamp`, `prompt`, `status`
+        self.__execute__("""
+        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()
@@ -140,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':
@@ -148,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,8 +183,8 @@ class DatabaseManager:
     # 获取此session_name前一个session的数据
     def last_session(self, session_name: str, cursor_timestamp: int):
 
-        self.execute("""
-        select `name`, `type`, `number`, `create_timestamp`, `last_interact_timestamp`, `prompt`, `status`
+        self.__execute__("""
+        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))
@@ -176,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`
+        self.__execute__("""
+            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))
@@ -205,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, replace: str = ""):
-        self.execute("""
-        select `name`, `type`, `number`, `create_timestamp`, `last_interact_timestamp`, `prompt`, `status`
+    def list_history(self, session_name: str, capacity: int, page: int):
+        self.__execute__("""
+        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()
@@ -230,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 if replace == "" else prompt.replace(replace, "")
+                '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...')
@@ -255,22 +312,22 @@ class DatabaseManager:
                 usage_count = usage[key_md5]
             # 将使用量存进数据库
             # 先检查是否已存在
-            self.execute("""
+            self.__execute__("""
             select count(*) from `api_key_usage` where `key_md5` = '{}'""".format(key_md5))
             result = self.cursor.fetchone()
             if result[0] == 0:
                 # 不存在则插入
-                self.execute("""
+                self.__execute__("""
                 insert into `api_key_usage` (`key_md5`, `usage`,`timestamp`) values ('{}', {}, {})
                 """.format(key_md5, usage_count, int(time.time())))
             else:
                 # 存在则更新，timestamp设置为当前
-                self.execute("""
+                self.__execute__("""
                 update `api_key_usage` set `usage` = {}, `timestamp` = {} where `key_md5` = '{}'
                 """.format(usage_count, int(time.time()), key_md5))
 
     def load_api_key_usage(self):
-        self.execute("""
+        self.__execute__("""
         select `key_md5`, `usage` from `api_key_usage`
         """)
         results = self.cursor.fetchall()
@@ -281,63 +338,25 @@ class DatabaseManager:
             usage[key_md5] = usage_count
         return usage
 
-    def dump_api_key_fee(self, api_keys: dict, fee: dict):
-        logging.debug("dumping api key fee...")
-        logging.debug(api_keys)
-        logging.debug(fee)
-        for api_key in api_keys:
-            # 计算key的md5值
-            key_md5 = hashlib.md5(api_keys[api_key].encode('utf-8')).hexdigest()
-            # 获取使用量
-            fee_count = 0
-            if key_md5 in fee:
-                fee_count = fee[key_md5]
-            # 将使用量存进数据库
-            # 先检查是否已存在
-            self.execute("""
-            select count(*) from `account_fee` where `key_md5` = '{}'""".format(key_md5))
-            result = self.cursor.fetchone()
-            if result[0] == 0:
-                # 不存在则插入
-                self.execute("""
-                insert into `account_fee` (`key_md5`, `fee`,`timestamp`) values ('{}', {}, {})
-                """.format(key_md5, fee_count, int(time.time())))
-            else:
-                # 存在则更新，timestamp设置为当前
-                self.execute("""
-                update `account_fee` set `fee` = {}, `timestamp` = {} where `key_md5` = '{}'
-                """.format(fee_count, int(time.time()), key_md5))
-
-    def load_api_key_fee(self):
-        self.execute("""
-        select `key_md5`, `fee` from `account_fee`
-        """)
-        results = self.cursor.fetchall()
-        fee = {}
-        for result in results:
-            key_md5 = result[0]
-            fee_count = result[1]
-            fee[key_md5] = fee_count
-        return fee
-
     def dump_usage_json(self, usage: dict):
+
         json_str = json.dumps(usage)
-        self.execute("""
+        self.__execute__("""
         select count(*) from `account_usage`""")
         result = self.cursor.fetchone()
         if result[0] == 0:
             # 不存在则插入
-            self.execute("""
+            self.__execute__("""
             insert into `account_usage` (`json`) values ('{}')
             """.format(json_str))
         else:
             # 存在则更新
-            self.execute("""
+            self.__execute__("""
             update `account_usage` set `json` = '{}' where `id` = 1
             """.format(json_str))
 
     def load_usage_json(self):
-        self.execute("""
+        self.__execute__("""
         select `json` from `account_usage` order by id desc limit 1
         """)
         result = self.cursor.fetchone()

pkg/openai/__init__.py

@@ -0,0 +1 @@
+"""OpenAI 接口处理及会话管理相关"""

pkg/openai/dprompt.py

@@ -0,0 +1,145 @@
+# 多情景预设值管理
+import json
+import logging
+import config
+import os
+
+# __current__ = "default"
+# """当前默认使用的情景预设的名称
+
+# 由管理员使用`!default <名称>`指令切换
+# """
+
+# __prompts_from_files__ = {}
+# """从文件中读取的情景预设值"""
+
+# __scenario_from_files__ = {}
+
+
+__universal_first_reply__ = "ok, I'll follow your commands."
+"""通用首次回复"""
+
+
+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
+
+    if config.preset_mode == "default":
+        config.preset_mode = "normal"
+
+    return scenario_mode_mapping[config.preset_mode]

pkg/openai/keymgr.py

@@ -2,27 +2,28 @@
 import hashlib
 import logging
 
-import pkg.database.manager
-import pkg.qqbot.manager
-import pkg.utils.context
+import pkg.plugin.host as plugin_host
+import pkg.plugin.models as plugin_models
 
 
 class KeysManager:
     api_key = {}
-
-    # api-key的使用量
-    # 其中键为api-key的md5值，值为使用量
-    fee = {}
-
-    api_key_fee_threshold = 18.0
+    """所有api-key"""
 
     using_key = ""
+    """当前使用的api-key"""
 
     alerted = []
+    """已提示过超额的key
+    
+    记录在此以避免重复提示
+    """
 
-    # 在此list中的都是经超额报错标记过的api-key
-    # 记录的是key值，仅在运行时有效
     exceeded = []
+    """已超额的key
+    
+    供自动切换功能识别
+    """
 
     def get_using_key(self):
         return self.using_key
@@ -31,13 +32,6 @@ class KeysManager:
         return hashlib.md5(self.using_key.encode('utf-8')).hexdigest()
 
     def __init__(self, api_key):
-        # if hasattr(config, 'api_key_usage_threshold'):
-        #     self.api_key_usage_threshold = config.api_key_usage_threshold
-
-        config = pkg.utils.context.get_config()
-        if hasattr(config, 'api_key_fee_threshold'):
-            self.api_key_fee_threshold = config.api_key_fee_threshold
-        self.load_fee()
 
         if type(api_key) is dict:
             self.api_key = api_key
@@ -48,27 +42,32 @@ class KeysManager:
         elif type(api_key) is list:
             for i in range(len(api_key)):
                 self.api_key[str(i)] = api_key[i]
-
-        self.auto_switch()
         # 从usage中删除未加载的api-key的记录
         # 不删了，也许会运行时添加曾经有记录的api-key
 
-        if 'exceeded_keys' in pkg.utils.context.context and pkg.utils.context.context['exceeded_keys'] is not None:
-            self.exceeded = pkg.utils.context.context['exceeded_keys']
+        self.auto_switch()
+
+    def auto_switch(self) -> tuple[bool, str]:
+        """尝试切换api-key
+
+        Returns:
+            是否切换成功, 切换后的api-key的别名
+        """
 
-    # 根据tested自动切换到可用的api-key
-    # 返回是否切换成功, 切换后的api-key的别名
-    def auto_switch(self) -> (bool, str):
-        self.dump_fee()
         for key_name in self.api_key:
             if self.api_key[key_name] not in self.exceeded:
                 self.using_key = self.api_key[key_name]
+
                 logging.info("使用api-key:" + key_name)
+
+                # 触发插件事件
+                args = {
+                    "key_name": key_name,
+                    "key_list": self.api_key.keys()
+                }
+                _ = plugin_host.emit(plugin_models.KeySwitched, **args)
+
                 return True, key_name
-            # if self.get_fee(self.api_key[key_name]) < self.api_key_fee_threshold:
-            #     self.using_key = self.api_key[key_name]
-            #     logging.info("使用api-key:" + key_name)
-            #     return True, key_name
 
         self.using_key = list(self.api_key.values())[0]
         logging.info("使用api-key:" + list(self.api_key.keys())[0])
@@ -78,14 +77,9 @@ class KeysManager:
     def add(self, key_name, key):
         self.api_key[key_name] = key
 
-    # 设置当前使用的api-key使用量超限
-    # 这是在尝试调用api时发生超限异常时调用的
     def set_current_exceeded(self):
-        # md5 = hashlib.md5(self.using_key.encode('utf-8')).hexdigest()
-        # self.usage[md5] = self.api_key_usage_threshold
-        # self.fee[md5] = self.api_key_fee_threshold
+        """设置当前使用的api-key使用量超限"""
         self.exceeded.append(self.using_key)
-        self.dump_fee()
 
     def get_key_name(self, api_key):
         """根据api-key获取其别名"""
@@ -93,45 +87,3 @@ class KeysManager:
             if self.api_key[key_name] == api_key:
                 return key_name
         return ""
-
-    def get_fee(self, api_key):
-        md5 = hashlib.md5(api_key.encode('utf-8')).hexdigest()
-        if md5 not in self.fee:
-            self.fee[md5] = 0
-        return self.fee[md5]
-
-    def report_fee(self, fee: float) -> bool:
-        logging.debug("report fee:" + str(fee))
-
-        md5 = hashlib.md5(self.using_key.encode('utf-8')).hexdigest()
-        if md5 not in self.fee:
-            self.fee[md5] = 0
-
-        self.fee[md5] += fee
-
-        config = pkg.utils.context.get_config()
-        if self.fee[md5] >= self.api_key_fee_threshold and \
-                hasattr(config, 'auto_switch_api_key') and config.auto_switch_api_key:
-            switch_result, key_name = self.auto_switch()
-
-            # 检查是否切换到新的
-            if switch_result:
-                if key_name not in self.alerted:
-                    # 通知管理员
-                    pkg.utils.context.get_qqbot_manager().notify_admin("api-key已切换到:" + key_name)
-                    self.alerted.append(key_name)
-                    return True
-            else:
-                if key_name not in self.alerted:
-                    # 通知管理员
-                    pkg.utils.context.get_qqbot_manager().notify_admin("api-key已用完，无未使用的api-key可供切换")
-                    self.alerted.append(key_name)
-                    return False
-        return False
-
-    def dump_fee(self):
-        pkg.utils.context.get_database_manager().dump_api_key_fee(api_keys=self.api_key, fee=self.fee)
-
-    def load_fee(self):
-        self.fee = pkg.utils.context.get_database_manager().load_api_key_fee()
-        logging.info("load fee:" + str(self.fee))

pkg/openai/manager.py

@@ -3,14 +3,16 @@ import logging
 import openai
 
 import pkg.openai.keymgr
-import pkg.openai.pricing as pricing
 import pkg.utils.context
 import pkg.audit.gatherer
+from pkg.openai.modelmgr import ModelRequest, create_openai_model_request
 
 
-# 为其他模块提供与OpenAI交互的接口
 class OpenAIInteract:
-    api_params = {}
+    """OpenAI 接口封装
+
+    将文字接口和图片接口封装供调用方使用
+    """
 
     key_mgr: pkg.openai.keymgr.KeysManager = None
 
@@ -21,37 +23,65 @@ class OpenAIInteract:
     }
 
     def __init__(self, api_key: str):
-        # self.api_key = api_key
 
         self.key_mgr = pkg.openai.keymgr.KeysManager(api_key)
         self.audit_mgr = pkg.audit.gatherer.DataGatherer()
 
+        logging.info("文字总使用量：%d", self.audit_mgr.get_total_text_length())
+
         openai.api_key = self.key_mgr.get_using_key()
 
         pkg.utils.context.set_openai_manager(self)
 
     # 请求OpenAI Completion
-    def request_completion(self, prompt, stop):
+    def request_completion(self, prompts) -> tuple[str, int]:
+        """请求补全接口回复
+
+        Parameters:
+            prompts (str): 提示语
+
+        Returns:
+            str: 回复
+        """
+
         config = pkg.utils.context.get_config()
-        response = openai.Completion.create(
-            prompt=prompt,
-            stop=stop,
-            timeout=config.process_message_timeout,
+
+        # 根据模型选择使用的接口
+        ai: ModelRequest = create_openai_model_request(
+            config.completion_api_params['model'],
+            'user',
+            config.openai_config["http_proxy"] if "http_proxy" in config.openai_config else None
+        )
+        ai.request(
+            prompts,
             **config.completion_api_params
         )
+        response = ai.get_response()
 
-        self.audit_mgr.report_text_model_usage(config.completion_api_params['model'],
-                                               prompt + response['choices'][0]['text'])
+        logging.debug("OpenAI response: %s", response)
 
-        switched = self.key_mgr.report_fee(pricing.language_base_price(config.completion_api_params['model'],
-                                                                       prompt + response['choices'][0]['text']))
-        if switched:
-            openai.api_key = self.key_mgr.get_using_key()
+        # 记录使用量
+        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 response
+        return ai.get_message(), current_round_token
 
-    def request_image(self, prompt):
+    def request_image(self, prompt) -> dict:
+        """请求图片接口回复
 
+        Parameters:
+            prompt (str): 提示语
+
+        Returns:
+            dict: 响应
+        """
         config = pkg.utils.context.get_config()
         params = config.image_api_params if hasattr(config, "image_api_params") else self.default_image_api_params
 
@@ -63,10 +93,5 @@ class OpenAIInteract:
 
         self.audit_mgr.report_image_model_usage(params['size'])
 
-        switched = self.key_mgr.report_fee(pricing.image_price(params['size']))
-
-        if switched:
-            openai.api_key = self.key_mgr.get_using_key()
-
         return response
 

pkg/openai/modelmgr.py

@@ -1,7 +1,30 @@
-# 提供与模型交互的抽象接口
+"""OpenAI 接口底层封装
+
+目前使用的对话接口有：
+ChatCompletion - gpt-3.5-turbo 等模型
+Completion - text-davinci-003 等模型
+此模块封装此两个接口的请求实现，为上层提供统一的调用方式
+"""
+import openai, logging, threading, asyncio
+import openai.error as aiE
 
 COMPLETION_MODELS = {
-    'text-davinci-003'
+    'text-davinci-003',
+    'text-davinci-002',
+    'code-davinci-002',
+    'code-cushman-001',
+    'text-curie-001',
+    'text-babbage-001',
+    'text-ada-001',
+}
+
+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 = {
@@ -13,22 +36,153 @@ IMAGE_MODELS = {
 }
 
 
-# ModelManager
-# 由session包含
-class ModelMgr(object):
+class ModelRequest:
+    """模型接口请求父类"""
 
-    using_completion_model = ""
-    using_edit_model = ""
-    using_image_model = ""
+    can_chat = False
+    runtime: threading.Thread = None
+    ret = {}
+    proxy: str = None
+    request_ready = True
+    error_info: str = "若在没有任何错误的情况下看到这句话，请带着配置文件上报Issues"
 
-    def __init__(self):
-        pass
+    def __init__(self, model_name, user_name, request_fun, http_proxy:str = None, time_out = None):
+        self.model_name = model_name
+        self.user_name = user_name
+        self.request_fun = request_fun
+        self.time_out = time_out
+        if http_proxy != None:
+            self.proxy = http_proxy
+            openai.proxy = self.proxy
+            self.request_ready = False
 
-    def get_using_completion_model(self):
-        return self.using_completion_model
+    async def __a_request__(self, **kwargs):
+        """异步请求"""
 
-    def get_using_edit_model(self):
-        return self.using_edit_model
+        try:
+            self.ret:dict = await self.request_fun(**kwargs)
+            self.request_ready = True
+        except aiE.APIConnectionError as e:
+            self.error_info = "{}\n请检查网络连接或代理是否正常".format(e)
+            raise ConnectionError(self.error_info)
+        except ValueError as e:
+            self.error_info = "{}\n该错误可能是由于http_proxy格式设置错误引起的"
+        except Exception as e:
+            self.error_info = "{}\n由于请求异常产生的未知错误，请查看日志".format(e)
+            raise Exception(self.error_info)
 
-    def get_using_image_model(self):
-        return self.using_image_model
+    def request(self, **kwargs):
+        """向接口发起请求"""
+
+        if self.proxy != None: #异步请求
+            self.request_ready = False
+            loop = asyncio.new_event_loop()
+            self.runtime = threading.Thread(
+                target=loop.run_until_complete,
+                args=(self.__a_request__(**kwargs),)
+            )
+            self.runtime.start()
+        else: #同步请求
+            self.ret = self.request_fun(**kwargs)
+
+    def __msg_handle__(self, msg):
+        """将prompt dict转换成接口需要的格式"""
+        return msg
+    
+    def ret_handle(self):
+        '''
+        API消息返回处理函数
+        若重写该方法，应检查异步线程状态，或在需要检查处super该方法
+        '''
+        if self.runtime != None and isinstance(self.runtime, threading.Thread):
+            self.runtime.join(self.time_out)
+        if self.request_ready:
+            return
+        raise Exception(self.error_info)
+
+    def get_total_tokens(self):
+        try:
+            return self.ret['usage']['total_tokens']
+        except:
+            return 0
+
+    def get_message(self):
+        return self.message
+
+    def get_response(self):
+        return self.ret
+
+
+class ChatCompletionModel(ModelRequest):
+    """ChatCompletion接口的请求实现"""
+
+    Chat_role = ['system', 'user', 'assistant']
+    def __init__(self, model_name, user_name, http_proxy:str = None, **kwargs):
+        if http_proxy == None:
+            request_fun = openai.ChatCompletion.create
+        else:
+            request_fun = openai.ChatCompletion.acreate
+        self.can_chat = True
+        super().__init__(model_name, user_name, request_fun, http_proxy, **kwargs)
+
+    def request(self, prompts, **kwargs):
+        prompts = self.__msg_handle__(prompts)
+        kwargs['messages'] = prompts
+        super().request(**kwargs)
+        self.ret_handle()
+
+    def __msg_handle__(self, msgs):
+        temp_msgs = []
+        # 把msgs拷贝进temp_msgs
+        for msg in msgs:
+            temp_msgs.append(msg.copy())
+        return temp_msgs
+
+    def get_message(self):
+        return self.ret["choices"][0]["message"]['content'] #需要时直接加载加快请求速度，降低内存消耗
+
+
+class CompletionModel(ModelRequest):
+    """Completion接口的请求实现"""
+
+    def __init__(self, model_name, user_name, http_proxy:str = None, **kwargs):
+        if http_proxy == None:
+            request_fun = openai.Completion.create
+        else:
+            request_fun = openai.Completion.acreate
+        super().__init__(model_name, user_name, request_fun, http_proxy, **kwargs)
+
+    def request(self, prompts, **kwargs):
+        prompts = self.__msg_handle__(prompts)
+        kwargs['prompt'] = prompts
+        super().request(**kwargs)
+        self.ret_handle()
+
+    def __msg_handle__(self, msgs):
+        prompt = ''
+        for msg in msgs:
+            prompt = prompt + "{}: {}\n".format(msg['role'], msg['content'])
+        # for msg in msgs:
+        #     if msg['role'] == 'assistant':
+        #         prompt = prompt + "{}\n".format(msg['content'])
+        #     else:
+        #         prompt = prompt + "{}:{}\n".format(msg['role'] , msg['content'])
+        prompt = prompt + "assistant: "
+        return prompt
+
+    def get_message(self):
+        return self.ret["choices"][0]["text"]
+
+
+def create_openai_model_request(model_name: str, user_name: str = 'user', http_proxy:str = None) -> ModelRequest:
+    """使用给定的模型名称创建模型请求对象"""
+    if model_name in CHAT_COMPLETION_MODELS:
+        model = ChatCompletionModel(model_name, user_name, http_proxy)
+    elif model_name in COMPLETION_MODELS:
+        model = CompletionModel(model_name, user_name, http_proxy)
+    else :
+        log = "找不到模型[{}]，请检查配置文件".format(model_name)
+        logging.error(log)
+        raise IndexError(log)
+    logging.debug("使用接口[{}]创建模型请求[{}]".format(model.__class__.__name__, model_name))
+    return model

pkg/openai/pricing.bak.py

@@ -1,3 +1,6 @@
+# 计费模块
+# 已弃用 https://github.com/RockChinQ/QChatGPT/issues/81
+
 import logging
 
 pricing = {

pkg/openai/session.py

@@ -1,11 +1,21 @@
+"""主线使用的会话管理模块
+
+每个人、每个群单独一个session，session内部保留了对话的上下文，
+"""
+
 import logging
 import threading
 import time
+import json
 
 import pkg.openai.manager
+import pkg.openai.modelmgr
 import pkg.database.manager
 import pkg.utils.context
 
+import pkg.plugin.host as plugin_host
+import pkg.plugin.models as plugin_models
+
 # 运行时保存的所有session
 sessions = {}
 
@@ -15,8 +25,38 @@ class SessionOfflineStatus:
     EXPLICITLY_CLOSED = 'explicitly_closed'
 
 
+# 重置session.prompt
+def reset_session_prompt(session_name, prompt):
+    # 备份原始数据
+    bak_path = 'logs/{}-{}.bak'.format(
+        session_name,
+        time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime())
+    )
+    f = open(bak_path, 'w+')
+    f.write(prompt)
+    f.close()
+    # 生成新数据
+    config = pkg.utils.context.get_config()
+    prompt = [
+        {
+            'role': 'system',
+            'content': config.default_prompt['default'] if type(config.default_prompt) == dict else config.default_prompt
+        }
+    ]
+    # 警告
+    logging.warning(
+        """
+用户[{}]的数据已被重置，有可能是因为数据版本过旧或存储错误
+原始数据将备份在：
+{}""".format(session_name, bak_path)
+    )  # 为保证多行文本格式正确故无缩进
+    return prompt
+
+
 # 从数据加载session
 def load_sessions():
+    """从数据库加载sessions"""
+
     global sessions
 
     db_inst = pkg.utils.context.get_database_manager()
@@ -30,7 +70,14 @@ def load_sessions():
         temp_session.name = session_name
         temp_session.create_timestamp = session_data[session_name]['create_timestamp']
         temp_session.last_interact_timestamp = session_data[session_name]['last_interact_timestamp']
-        temp_session.prompt = session_data[session_name]['prompt']
+        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
 
@@ -51,38 +98,26 @@ def dump_session(session_name: str):
         del sessions[session_name]
 
 
-# def blocked_func(lock: threading.Lock):
-#
-#     def decorator(func):
-#         def wrapper(*args, **kwargs):
-#             print('lock acquire,{}'.format(lock))
-#             lock.acquire()
-#             try:
-#                 return func(*args, **kwargs)
-#             finally:
-#                 lock.release()
-#
-#         return wrapper
-#
-#     return decorator
-
-
 # 通用的OpenAI API交互session
 # session内部保留了对话的上下文，
 # 收到用户消息后，将上下文提交给OpenAI API生成回复
 class Session:
     name = ''
 
-    prompt = ""
+    prompt = []
+    """使用list来保存会话中的回合"""
 
-    import config
+    token_counts = []
+    """每个回合的token数量"""
 
-    user_name = config.user_name if hasattr(config, 'user_name') and config.user_name != '' else 'You'
-    bot_name = config.bot_name if hasattr(config, 'bot_name') and config.bot_name != '' else 'Bot'
+    default_prompt = []
+    """本session的默认prompt"""
 
     create_timestamp = 0
+    """会话创建时间"""
 
     last_interact_timestamp = 0
+    """上次交互(产生回复)时间"""
 
     just_switched_to_exist_session = False
 
@@ -102,22 +137,27 @@ class Session:
             logging.debug('{},lock release successfully,{}'.format(self.name, self.response_lock))
 
     # 从配置文件获取会话预设信息
-    def get_default_prompt(self):
-        config = pkg.utils.context.get_config()
-        user_name = config.user_name if hasattr(config, 'user_name') and config.user_name != '' else 'You'
-        bot_name = config.bot_name if hasattr(config, 'bot_name') and config.bot_name != '' else 'Bot'
-        return user_name + ":{}\n".format(config.default_prompt if hasattr(config, 'default_prompt') \
-                                                                   and config.default_prompt != "" else '') + \
-            bot_name + ":好的\n"
+    def get_default_prompt(self, use_default: str = None):
+        import pkg.openai.dprompt as dprompt
+
+        if use_default is None:
+            use_default = dprompt.mode_inst().get_using_name()
+
+        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):
@@ -136,6 +176,17 @@ class Session:
             config = pkg.utils.context.get_config()
             if int(time.time()) - self.last_interact_timestamp > config.session_expire_time:
                 logging.info('session {} 已过期'.format(self.name))
+
+                # 触发插件事件
+                args = {
+                    'session_name': self.name,
+                    'session': self,
+                    'session_expire_time': config.session_expire_time
+                }
+                event = pkg.plugin.host.emit(plugin_models.SessionExpired, **args)
+                if event.is_prevented_default():
+                    return
+
                 self.reset(expired=True, schedule_new=False)
 
                 # 删除此session
@@ -145,64 +196,120 @@ class Session:
     # 请求回复
     # 这个函数是阻塞的
     def append(self, text: str) -> str:
+        """向session中添加一条消息，返回接口回复"""
+
         self.last_interact_timestamp = int(time.time())
 
-        # max_rounds = config.prompt_submit_round_amount if hasattr(config, 'prompt_submit_round_amount') else 7
+        # 触发插件事件
+        if not self.prompt:
+            args = {
+                'session_name': self.name,
+                'session': self,
+                'default_prompt': self.default_prompt,
+            }
+
+            event = pkg.plugin.host.emit(plugin_models.SessionFirstMessageReceived, **args)
+            if event.is_prevented_default():
+                return None
+
         config = pkg.utils.context.get_config()
-        max_rounds = 1000  # 不再限制回合数
         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请求补全
-        response = pkg.utils.context.get_openai_manager().request_completion(
-            self.cut_out(self.prompt + self.user_name + ':' +
-                         text + '\n' + self.bot_name + ':',
-                         max_rounds, max_length),
-            self.user_name + ':')
+        message, total_token = pkg.utils.context.get_openai_manager().request_completion(
+            prompts,
+        )
 
-        self.prompt += self.user_name + ':' + text + '\n' + self.bot_name + ':'
-        # print(response)
-        # 处理回复
-        res_test = response["choices"][0]["text"]
-        res_ans = res_test
+        # 成功获取，处理回复
+        res_test = message
+        res_ans = res_test.strip()
 
-        # 去除开头可能的提示
-        res_ans_spt = res_test.split("\n\n")
-        if len(res_ans_spt) > 1:
-            del (res_ans_spt[0])
-            res_ans = '\n\n'.join(res_ans_spt)
+        # 将此次对话的双方内容加入到prompt中
+        self.prompt.append({'role': 'user', 'content': text})
+        self.prompt.append({'role': 'assistant', 'content': res_ans})
 
-        self.prompt += "{}".format(res_ans) + '\n'
+        # 向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()
 
-        return res_ans
+        return res_ans if res_ans[0] != '\n' else res_ans[1:]
 
-    # 从尾部截取prompt里不多于max_rounds个回合，长度不大于max_tokens的字符串
-    # 保证都是完整的对话
-    def cut_out(self, prompt: str, max_rounds: int, max_tokens: int) -> str:
-        # 分隔出每个回合
-        rounds_spt_by_user_name = prompt.split(self.user_name + ':')
+    # 删除上一回合并返回上一回合的问题
+    def undo(self) -> str:
+        self.last_interact_timestamp = int(time.time())
 
-        result = ''
+        # 删除最后两个消息
+        if len(self.prompt) < 2:
+            raise Exception('之前无对话，无法撤销')
 
-        checked_rounds = 0
-        # 从后往前遍历，加到result前面，检查result是否符合要求
-        for i in range(len(rounds_spt_by_user_name) - 1, 0, -1):
-            result_temp = self.user_name + ':' + rounds_spt_by_user_name[i] + result
-            checked_rounds += 1
+        question = self.prompt[-2]['content']
+        self.prompt = self.prompt[:-2]
+        self.token_counts = self.token_counts[:-1]
 
-            if checked_rounds > max_rounds:
+        # 返回上一回合的问题
+        return question
+
+    # 构建对话体
+    def cut_out(self, msg: str, max_tokens: int) -> tuple[list, list]:
+        """将现有prompt进行切割处理，使得新的prompt长度不超过max_tokens
+
+        :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
 
-            if int((len(result_temp.encode('utf-8')) - len(result_temp)) / 2 + len(result_temp)) > 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]
 
-            result = result_temp
+            changable_index -= 2
+            token_count_index -= 1
 
-        logging.debug('cut_out: {}'.format(result))
-        return result
+        # 将default_prompt和changable_prompts合并
+        result_prompt = self.default_prompt + changable_prompts
+
+        # 添加当前问题
+        result_prompt.append(
+            {
+                'role': 'user',
+                'content': msg
+            }
+        )
+
+        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))
+
+        return result_prompt, changable_counts
 
     # 持久化session
     def persistence(self):
@@ -217,18 +324,30 @@ class Session:
         subject_number = int(name_spt[1])
 
         db_inst.persistence_session(subject_type, subject_number, self.create_timestamp, self.last_interact_timestamp,
-                                    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):
-        if self.prompt != self.get_default_prompt():
+    def reset(self, explicit: bool = False, expired: bool = False, schedule_new: bool = True, use_prompt: str = None):
+        if self.prompt:
             self.persistence()
             if explicit:
+                # 触发插件事件
+                args = {
+                    'session_name': self.name,
+                    'session': self
+                }
+
+                # 此事件不支持阻止默认行为
+                _ = pkg.plugin.host.emit(plugin_models.SessionExplicitReset, **args)
+
                 pkg.utils.context.get_database_manager().explicit_close_session(self.name, self.create_timestamp)
 
             if expired:
                 pkg.utils.context.get_database_manager().set_session_expired(self.name, self.create_timestamp)
-        self.prompt = self.get_default_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
@@ -252,7 +371,13 @@ class Session:
 
             self.create_timestamp = last_one['create_timestamp']
             self.last_interact_timestamp = last_one['last_interact_timestamp']
-            self.prompt = last_one['prompt']
+            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
@@ -267,14 +392,25 @@ class Session:
 
             self.create_timestamp = next_one['create_timestamp']
             self.last_interact_timestamp = next_one['last_interact_timestamp']
-            self.prompt = next_one['prompt']
+            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
 
     def list_history(self, capacity: int = 10, page: int = 0):
-        return pkg.utils.context.get_database_manager().list_history(self.name, capacity, page,
-                                                                     self.get_default_prompt())
+        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)

pkg/plugin/__init__.py

@@ -0,0 +1,4 @@
+"""插件支持包
+
+包含插件基类、插件宿主以及部分API接口
+"""

pkg/plugin/host.py

@@ -0,0 +1,341 @@
+# 插件管理模块
+import asyncio
+import logging
+import importlib
+import os
+import pkgutil
+import sys
+import shutil
+import traceback
+
+import pkg.utils.context as context
+import pkg.plugin.switch as switch
+import pkg.plugin.settings as settings
+
+from mirai import Mirai
+
+__plugins__ = {}
+"""插件列表
+
+示例:
+{
+    "example": {
+        "path": "plugins/example/main.py",
+        "enabled: True,
+        "name": "example",
+        "description": "example",
+        "version": "0.0.1",
+        "author": "RockChinQ",
+        "class": <class 'plugins.example.ExamplePlugin'>,
+        "hooks": {
+            "person_message": [
+                <function ExamplePlugin.person_message at 0x0000020E1D1B8D38>
+            ]
+        },
+        "instance": None
+    }
+}
+"""
+
+__plugins_order__ = []
+"""插件顺序"""
+
+
+def generate_plugin_order():
+    """根据__plugin__生成插件初始顺序，无视是否启用"""
+    global __plugins_order__
+    __plugins_order__ = []
+    for plugin_name in __plugins__:
+        __plugins_order__.append(plugin_name)
+
+
+def iter_plugins():
+    """按照顺序迭代插件"""
+    for plugin_name in __plugins_order__:
+        yield __plugins__[plugin_name]
+
+
+def iter_plugins_name():
+    """迭代插件名"""
+    for plugin_name in __plugins_order__:
+        yield plugin_name
+
+
+__current_module_path__ = ""
+
+
+def walk_plugin_path(module, prefix='', path_prefix=''):
+    global __current_module_path__
+    """遍历插件路径"""
+    for item in pkgutil.iter_modules(module.__path__):
+        if item.ispkg:
+            logging.debug("扫描插件包: plugins/{}".format(path_prefix + item.name))
+            walk_plugin_path(__import__(module.__name__ + '.' + item.name, fromlist=['']),
+                             prefix + item.name + '.', path_prefix + item.name + '/')
+        else:
+            try:
+                logging.debug("扫描插件模块: plugins/{}".format(path_prefix + item.name + '.py'))
+                __current_module_path__ = "plugins/"+path_prefix + item.name + '.py'
+
+                importlib.import_module(module.__name__ + '.' + item.name)
+                logging.info('加载模块: plugins/{} 成功'.format(path_prefix + item.name + '.py'))
+            except:
+                logging.error('加载模块: plugins/{} 失败: {}'.format(path_prefix + item.name + '.py', sys.exc_info()))
+                traceback.print_exc()
+
+
+def load_plugins():
+    """加载插件"""
+    logging.info("加载插件")
+    PluginHost()
+    walk_plugin_path(__import__('plugins'))
+
+    logging.debug(__plugins__)
+
+    # 加载开关数据
+    switch.load_switch()
+
+    # 生成初始顺序
+    generate_plugin_order()
+    # 加载插件顺序
+    settings.load_settings()
+
+
+def initialize_plugins():
+    """初始化插件"""
+    logging.info("初始化插件")
+    import pkg.plugin.models as models
+    for plugin in iter_plugins():
+        if not plugin['enabled']:
+            continue
+        try:
+            models.__current_registering_plugin__ = plugin['name']
+            plugin['instance'] = plugin["class"](plugin_host=context.get_plugin_host())
+            logging.info("插件 {} 已初始化".format(plugin['name']))
+        except:
+            logging.error("插件{}初始化时发生错误: {}".format(plugin['name'], sys.exc_info()))
+
+
+def unload_plugins():
+    """卸载插件"""
+    # 不再显式卸载插件，因为当程序结束时，插件的析构函数会被系统执行
+    # for plugin in __plugins__.values():
+    #     if plugin['enabled'] and plugin['instance'] is not None:
+    #         if not hasattr(plugin['instance'], '__del__'):
+    #             logging.warning("插件{}没有定义析构函数".format(plugin['name']))
+    #         else:
+    #             try:
+    #                 plugin['instance'].__del__()
+    #                 logging.info("卸载插件: {}".format(plugin['name']))
+    #                 plugin['instance'] = None
+    #             except:
+    #                 logging.error("插件{}卸载时发生错误: {}".format(plugin['name'], sys.exc_info()))
+
+
+def install_plugin(repo_url: str):
+    """安装插件，从git储存库获取并解决依赖"""
+    try:
+        import pkg.utils.pkgmgr
+        pkg.utils.pkgmgr.ensure_dulwich()
+    except:
+        pass
+
+    try:
+        import dulwich
+    except ModuleNotFoundError:
+        raise Exception("dulwich模块未安装,请查看 https://github.com/RockChinQ/QChatGPT/issues/77")
+
+    from dulwich import porcelain
+
+    logging.info("克隆插件储存库: {}".format(repo_url))
+    repo = porcelain.clone(repo_url, "plugins/"+repo_url.split(".git")[0].split("/")[-1]+"/", checkout=True)
+
+    # 检查此目录是否包含requirements.txt
+    if os.path.exists("plugins/"+repo_url.split(".git")[0].split("/")[-1]+"/requirements.txt"):
+        logging.info("检测到requirements.txt，正在安装依赖")
+        import pkg.utils.pkgmgr
+        pkg.utils.pkgmgr.install_requirements("plugins/"+repo_url.split(".git")[0].split("/")[-1]+"/requirements.txt")
+
+        import main
+        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
+    """事件编号"""
+
+    name = ""
+
+    __prevent_default__ = False
+    """是否阻止默认行为"""
+
+    __prevent_postorder__ = False
+    """是否阻止后续插件的执行"""
+
+    __return_value__ = {}
+    """ 返回值 
+    示例:
+    {
+        "example": [
+            'value1',
+            'value2',
+            3,
+            4,
+            {
+                'key1': 'value1',
+            },
+            ['value1', 'value2']
+        ]
+    }
+    """
+
+    def add_return(self, key: str, ret):
+        """添加返回值"""
+        if key not in self.__return_value__:
+            self.__return_value__[key] = []
+        self.__return_value__[key].append(ret)
+
+    def get_return(self, key: str):
+        """获取key的所有返回值"""
+        if key in self.__return_value__:
+            return self.__return_value__[key]
+        return None
+
+    def get_return_value(self, key: str):
+        """获取key的首个返回值"""
+        if key in self.__return_value__:
+            return self.__return_value__[key][0]
+        return None
+
+    def prevent_default(self):
+        """阻止默认行为"""
+        self.__prevent_default__ = True
+
+    def prevent_postorder(self):
+        """阻止后续插件执行"""
+        self.__prevent_postorder__ = True
+
+    def is_prevented_default(self):
+        """是否阻止默认行为"""
+        return self.__prevent_default__
+
+    def is_prevented_postorder(self):
+        """是否阻止后序插件执行"""
+        return self.__prevent_postorder__
+
+    def __init__(self, name: str):
+        self.name = name
+        self.eid = EventContext.eid
+        self.__prevent_default__ = False
+        self.__prevent_postorder__ = False
+        self.__return_value__ = {}
+        EventContext.eid += 1
+
+
+def emit(event_name: str, **kwargs) -> EventContext:
+    """触发事件"""
+    import pkg.utils.context as context
+    if context.get_plugin_host() is None:
+        return None
+    return context.get_plugin_host().emit(event_name, **kwargs)
+
+
+class PluginHost:
+    """插件宿主"""
+
+    def __init__(self):
+        context.set_plugin_host(self)
+
+    def get_runtime_context(self) -> context:
+        """获取运行时上下文（pkg.utils.context模块的对象）
+
+        此上下文用于和主程序其他模块交互（数据库、QQ机器人、OpenAI接口等）
+        详见pkg.utils.context模块
+        其中的context变量保存了其他重要模块的类对象，可以使用这些对象进行交互
+        """
+        return context
+
+    def get_bot(self) -> Mirai:
+        """获取机器人对象"""
+        return context.get_qqbot_manager().bot
+
+    def send_person_message(self, person, message):
+        """发送私聊消息"""
+        asyncio.run(self.get_bot().send_friend_message(person, message))
+
+    def send_group_message(self, group, message):
+        """发送群消息"""
+        asyncio.run(self.get_bot().send_group_message(group, message))
+
+    def notify_admin(self, message):
+        """通知管理员"""
+        context.get_qqbot_manager().notify_admin(message)
+
+    def emit(self, event_name: str, **kwargs) -> EventContext:
+        """触发事件"""
+        import json
+
+        event_context = EventContext(event_name)
+        logging.debug("触发事件: {} ({})".format(event_name, event_context.eid))
+        for plugin in iter_plugins():
+            
+            if not plugin['enabled']:
+                continue
+
+            # if plugin['instance'] is None:
+            #     # 从关闭状态切到开启状态之后，重新加载插件
+            #     try:
+            #         plugin['instance'] = plugin["class"](plugin_host=self)
+            #         logging.info("插件 {} 已初始化".format(plugin['name']))
+            #     except:
+            #         logging.error("插件 {} 初始化时发生错误: {}".format(plugin['name'], sys.exc_info()))
+            #         continue
+
+            if 'hooks' not in plugin or event_name not in plugin['hooks']:
+                continue
+
+            hooks = []
+            if event_name in plugin["hooks"]:
+                hooks = plugin["hooks"][event_name]
+            for hook in hooks:
+                try:
+                    already_prevented_default = event_context.is_prevented_default()
+
+                    kwargs['host'] = context.get_plugin_host()
+                    kwargs['event'] = event_context
+
+                    hook(plugin['instance'], **kwargs)
+
+                    if event_context.is_prevented_default() and not already_prevented_default:
+                        logging.debug("插件 {} 已要求阻止事件 {} 的默认行为".format(plugin['name'], event_name))
+
+                except Exception as e:
+                    logging.error("插件{}触发事件{}时发生错误".format(plugin['name'], event_name))
+                    logging.error(traceback.format_exc())
+
+            # print("done:{}".format(plugin['name']))
+            if event_context.is_prevented_postorder():
+                logging.debug("插件 {} 阻止了后序插件的执行".format(plugin['name']))
+                break
+
+        logging.debug("事件 {} ({}) 处理完毕，返回值: {}".format(event_name, event_context.eid,
+                                                                event_context.__return_value__))
+
+        return event_context

pkg/plugin/models.py

@@ -0,0 +1,223 @@
+import logging
+
+import pkg.plugin.host as host
+import pkg.utils.context
+
+PersonMessageReceived = "person_message_received"
+"""收到私聊消息时，在判断是否应该响应前触发
+    kwargs:
+        launcher_type: str 发起对象类型(group/person)
+        launcher_id: int 发起对象ID(群号/QQ号)
+        sender_id: int 发送者ID(QQ号)
+        message_chain: mirai.models.message.MessageChain 消息链
+"""
+
+GroupMessageReceived = "group_message_received"
+"""收到群聊消息时，在判断是否应该响应前触发（所有群消息）
+    kwargs:
+        launcher_type: str 发起对象类型(group/person)
+        launcher_id: int 发起对象ID(群号/QQ号)
+        sender_id: int 发送者ID(QQ号)
+        message_chain: mirai.models.message.MessageChain 消息链
+"""
+
+PersonNormalMessageReceived = "person_normal_message_received"
+"""判断为应该处理的私聊普通消息时触发
+    kwargs:
+        launcher_type: str 发起对象类型(group/person)
+        launcher_id: int 发起对象ID(群号/QQ号)
+        sender_id: int 发送者ID(QQ号)
+        text_message: str 消息文本
+        
+    returns (optional):
+        alter: str 修改后的消息文本
+        reply: list 回复消息组件列表
+"""
+
+PersonCommandSent = "person_command_sent"
+"""判断为应该处理的私聊指令时触发
+    kwargs:
+        launcher_type: str 发起对象类型(group/person)
+        launcher_id: int 发起对象ID(群号/QQ号)
+        sender_id: int 发送者ID(QQ号)
+        command: str 指令
+        params: list[str] 参数列表
+        text_message: str 完整指令文本
+        is_admin: bool 是否为管理员
+    
+    returns (optional):
+        alter: str 修改后的完整指令文本
+        reply: list 回复消息组件列表
+"""
+
+GroupNormalMessageReceived = "group_normal_message_received"
+"""判断为应该处理的群聊普通消息时触发
+    kwargs:
+        launcher_type: str 发起对象类型(group/person)
+        launcher_id: int 发起对象ID(群号/QQ号)
+        sender_id: int 发送者ID(QQ号)
+        text_message: str 消息文本
+        
+    returns (optional):
+        alter: str 修改后的消息文本
+        reply: list 回复消息组件列表
+"""
+
+GroupCommandSent = "group_command_sent"
+"""判断为应该处理的群聊指令时触发
+    kwargs:
+        launcher_type: str 发起对象类型(group/person)
+        launcher_id: int 发起对象ID(群号/QQ号)
+        sender_id: int 发送者ID(QQ号)
+        command: str 指令
+        params: list[str] 参数列表
+        text_message: str 完整指令文本
+        is_admin: bool 是否为管理员
+    
+    returns (optional):
+        alter: str 修改后的完整指令文本
+        reply: list 回复消息组件列表
+"""
+
+NormalMessageResponded = "normal_message_responded"
+"""获取到对普通消息的文字响应时触发
+    kwargs:
+        launcher_type: str 发起对象类型(group/person)
+        launcher_id: int 发起对象ID(群号/QQ号)
+        sender_id: int 发送者ID(QQ号)
+        session: pkg.openai.session.Session 会话对象
+        prefix: str 回复文字消息的前缀
+        response_text: str 响应文本
+    
+    returns (optional):
+        prefix: str 修改后的回复文字消息的前缀
+        reply: list 替换回复消息组件列表
+"""
+
+SessionFirstMessageReceived = "session_first_message_received"
+"""会话被第一次交互时触发
+    kwargs:
+        session_name: str 会话名称(<launcher_type>_<launcher_id>)
+        session: pkg.openai.session.Session 会话对象
+        default_prompt: str 预设值
+"""
+
+SessionExplicitReset = "session_reset"
+"""会话被用户手动重置时触发，此事件不支持阻止默认行为
+    kwargs:
+        session_name: str 会话名称(<launcher_type>_<launcher_id>)
+        session: pkg.openai.session.Session 会话对象
+"""
+
+SessionExpired = "session_expired"
+"""会话过期时触发
+    kwargs:
+        session_name: str 会话名称(<launcher_type>_<launcher_id>)
+        session: pkg.openai.session.Session 会话对象
+        session_expire_time: int 已设置的会话过期时间(秒)
+"""
+
+KeyExceeded = "key_exceeded"
+"""api-key超额时触发
+    kwargs:
+        key_name: str 超额的api-key名称
+        usage: dict 超额的api-key使用情况
+        exceeded_keys: list[str] 超额的api-key列表
+"""
+
+KeySwitched = "key_switched"
+"""api-key超额切换成功时触发，此事件不支持阻止默认行为
+    kwargs:
+        key_name: str 切换成功的api-key名称
+        key_list: list[str] api-key列表
+"""
+
+
+def on(event: str):
+    """注册事件监听器
+    :param
+        event: str 事件名称
+    """
+    return Plugin.on(event)
+
+
+__current_registering_plugin__ = ""
+
+
+class Plugin:
+    """插件基类"""
+
+    host: host.PluginHost
+    """插件宿主，提供插件的一些基础功能"""
+
+    @classmethod
+    def on(cls, event):
+        """事件处理器装饰器
+
+        :param
+            event: 事件类型
+        :return:
+            None
+        """
+        global __current_registering_plugin__
+
+        def wrapper(func):
+            plugin_hooks = host.__plugins__[__current_registering_plugin__]["hooks"]
+
+            if event not in plugin_hooks:
+                plugin_hooks[event] = []
+            plugin_hooks[event].append(func)
+
+            # print("registering hook: p='{}', e='{}', f={}".format(__current_registering_plugin__, event, func))
+
+            host.__plugins__[__current_registering_plugin__]["hooks"] = plugin_hooks
+
+            return func
+
+        return wrapper
+
+
+def register(name: str, description: str, version: str, author: str):
+    """注册插件, 此函数作为装饰器使用
+
+    Args:
+        name (str): 插件名称
+        description (str): 插件描述
+        version (str): 插件版本
+        author (str): 插件作者
+
+    Returns:
+        None
+    """
+    global __current_registering_plugin__
+
+    __current_registering_plugin__ = name
+    # print("registering plugin: n='{}', d='{}', v={}, a='{}'".format(name, description, version, author))
+    host.__plugins__[name] = {
+        "name": name,
+        "description": description,
+        "version": version,
+        "author": author,
+        "hooks": {},
+        "path": host.__current_module_path__,
+        "enabled": True,
+        "instance": None,
+    }
+
+    def wrapper(cls: Plugin):
+        cls.name = name
+        cls.description = description
+        cls.version = version
+        cls.author = author
+        cls.host = pkg.utils.context.get_plugin_host()
+        cls.enabled = True
+        cls.path = host.__current_module_path__
+
+        # 存到插件列表
+        host.__plugins__[name]["class"] = cls
+
+        logging.info("插件注册完成: n='{}', d='{}', v={}, a='{}' ({})".format(name, description, version, author, cls))
+
+        return cls
+
+    return wrapper

pkg/plugin/settings.py

@@ -0,0 +1,84 @@
+import json
+import os
+
+import pkg.plugin.host as host
+import logging
+
+
+def wrapper_dict_from_runtime_context() -> dict:
+    """从变量中包装settings.json的数据字典"""
+    settings = {
+        "order": []
+    }
+
+    for plugin_name in host.__plugins_order__:
+        settings["order"].append(plugin_name)
+
+    return settings
+
+
+def apply_settings(settings: dict):
+    """将settings.json数据应用到变量中"""
+    if "order" in settings:
+        host.__plugins_order__ = settings["order"]
+
+
+def dump_settings():
+    """保存settings.json数据"""
+    logging.debug("保存plugins/settings.json数据")
+
+    settings = wrapper_dict_from_runtime_context()
+
+    with open("plugins/settings.json", "w", encoding="utf-8") as f:
+        json.dump(settings, f, indent=4, ensure_ascii=False)
+
+
+def load_settings():
+    """加载settings.json数据"""
+    logging.debug("加载plugins/settings.json数据")
+
+    # 读取plugins/settings.json
+    settings = {
+    }
+
+    # 检查文件是否存在
+    if not os.path.exists("plugins/settings.json"):
+        # 不存在则创建
+        with open("plugins/settings.json", "w", encoding="utf-8") as f:
+            json.dump(wrapper_dict_from_runtime_context(), f, indent=4, ensure_ascii=False)
+
+    with open("plugins/settings.json", "r", encoding="utf-8") as f:
+        settings = json.load(f)
+
+    if settings is None:
+        settings = {
+        }
+
+    # 检查每个设置项
+    if "order" not in settings:
+        settings["order"] = []
+
+    settings_modified = False
+
+    settings_copy = settings.copy()
+
+    # 检查settings中多余的插件项
+
+    # order
+    for plugin_name in settings_copy["order"]:
+        if plugin_name not in host.__plugins_order__:
+            settings["order"].remove(plugin_name)
+            settings_modified = True
+
+    # 检查settings中缺少的插件项
+
+    # order
+    for plugin_name in host.__plugins_order__:
+        if plugin_name not in settings_copy["order"]:
+            settings["order"].append(plugin_name)
+            settings_modified = True
+
+    apply_settings(settings)
+
+    if settings_modified:
+        dump_settings()

pkg/plugin/switch.py

@@ -0,0 +1,89 @@
+# 控制插件的开关
+import json
+import logging
+import os
+
+import pkg.plugin.host as host
+
+
+def wrapper_dict_from_plugin_list() -> dict:
+    """将插件列表转换为开关json"""
+    switch = {}
+
+    for plugin_name in host.__plugins__:
+        plugin = host.__plugins__[plugin_name]
+
+        switch[plugin_name] = {
+            "path": plugin["path"],
+            "enabled": plugin["enabled"],
+        }
+
+    return switch
+
+
+def apply_switch(switch: dict):
+    """将开关数据应用到插件列表中"""
+    # print("将开关数据应用到插件列表中")
+    # print(switch)
+    for plugin_name in switch:
+        host.__plugins__[plugin_name]["enabled"] = switch[plugin_name]["enabled"]
+
+
+def dump_switch():
+    """保存开关数据"""
+    logging.debug("保存开关数据")
+    # 将开关数据写入plugins/switch.json
+
+    switch = wrapper_dict_from_plugin_list()
+
+    with open("plugins/switch.json", "w", encoding="utf-8") as f:
+        json.dump(switch, f, indent=4, ensure_ascii=False)
+
+
+def load_switch():
+    """加载开关数据"""
+    logging.debug("加载开关数据")
+    # 读取plugins/switch.json
+
+    switch = {}
+
+    # 检查文件是否存在
+    if not os.path.exists("plugins/switch.json"):
+        # 不存在则创建
+        with open("plugins/switch.json", "w", encoding="utf-8") as f:
+            json.dump(switch, f, indent=4, ensure_ascii=False)
+
+    with open("plugins/switch.json", "r", encoding="utf-8") as f:
+        switch = json.load(f)
+
+    if switch is None:
+        switch = {}
+
+    switch_modified = False
+
+    switch_copy = switch.copy()
+    # 检查switch中多余的和path不相符的
+    for plugin_name in switch_copy:
+        if plugin_name not in host.__plugins__:
+            del switch[plugin_name]
+            switch_modified = True
+        elif switch[plugin_name]["path"] != host.__plugins__[plugin_name]["path"]:
+            # 删除此不相符的
+            del switch[plugin_name]
+            switch_modified = True
+
+    # 检查plugin中多余的
+    for plugin_name in host.__plugins__:
+        if plugin_name not in switch:
+            switch[plugin_name] = {
+                "path": host.__plugins__[plugin_name]["path"],
+                "enabled": host.__plugins__[plugin_name]["enabled"],
+            }
+            switch_modified = True
+
+    # 应用开关数据
+    apply_switch(switch)
+
+    # 如果switch有修改，保存
+    if switch_modified:
+        dump_switch()

pkg/qqbot/banlist.py

@@ -0,0 +1,50 @@
+import pkg.utils.context
+
+
+def is_banned(launcher_type: str, launcher_id: int, sender_id: int) -> bool:
+    if not pkg.utils.context.get_qqbot_manager().enable_banlist:
+        return False
+    
+    result = False
+    
+    if launcher_type == 'group':
+        # 检查是否显式声明发起人QQ要被person忽略
+        if sender_id in pkg.utils.context.get_qqbot_manager().ban_person:
+            result = True
+        else:
+            for group_rule in pkg.utils.context.get_qqbot_manager().ban_group:
+                if type(group_rule) == int:
+                    if group_rule == launcher_id:  # 此群群号被禁用
+                        result = True
+                elif type(group_rule) == str:
+                    if group_rule.startswith('!'):
+                        # 截取!后面的字符串作为表达式，判断是否匹配
+                        reg_str = group_rule[1:]
+                        import re
+                        if re.match(reg_str, str(launcher_id)):  # 被豁免，最高级别
+                            result = False
+                            break
+                    else:
+                        # 判断是否匹配regexp
+                        import re
+                        if re.match(group_rule, str(launcher_id)):  # 此群群号被禁用
+                            result = True
+                    
+    else:
+        # ban_person, 与群规则相同
+        for person_rule in pkg.utils.context.get_qqbot_manager().ban_person:
+            if type(person_rule) == int:
+                if person_rule == launcher_id:
+                    result = True
+            elif type(person_rule) == str:
+                if person_rule.startswith('!'):
+                    reg_str = person_rule[1:]
+                    import re
+                    if re.match(reg_str, str(launcher_id)):
+                        result = False
+                        break
+                else:
+                    import re
+                    if re.match(person_rule, str(launcher_id)):
+                        result = True
+    return result

pkg/qqbot/blob.py

@@ -0,0 +1,102 @@
+# 长消息处理相关
+import os
+import time
+import base64
+
+import config
+from mirai.models.message import MessageComponent, MessageChain, Image
+from mirai.models.message import ForwardMessageNode
+from mirai.models.base import MiraiBaseModel
+from typing import List
+import pkg.utils.context as context
+import pkg.utils.text2img as text2img
+
+
+class ForwardMessageDiaplay(MiraiBaseModel):
+    title: str = "群聊的聊天记录"
+    brief: str = "[聊天记录]"
+    source: str = "聊天记录"
+    preview: List[str] = []
+    summary: str = "查看x条转发消息"
+
+
+class Forward(MessageComponent):
+    """合并转发。"""
+    type: str = "Forward"
+    """消息组件类型。"""
+    display: ForwardMessageDiaplay
+    """显示信息"""
+    node_list: List[ForwardMessageNode]
+    """转发消息节点列表。"""
+    def __init__(self, *args, **kwargs):
+        if len(args) == 1:
+            self.node_list = args[0]
+            super().__init__(**kwargs)
+        super().__init__(*args, **kwargs)
+
+    def __str__(self):
+        return '[聊天记录]'
+
+
+def text_to_image(text: str) -> MessageComponent:
+    """将文本转换成图片"""
+    # 检查temp文件夹是否存在
+    if not os.path.exists('temp'):
+        os.mkdir('temp')
+    img_path = text2img.text_to_image(text_str=text, save_as='temp/{}.png'.format(int(time.time())))
+    
+    compressed_path, size = text2img.compress_image(img_path, outfile="temp/{}_compressed.png".format(int(time.time())))
+    # 读取图片，转换成base64
+    with open(compressed_path, 'rb') as f:
+        img = f.read()
+
+    b64 = base64.b64encode(img)
+
+    # 删除图片
+    os.remove(img_path)
+
+    # 判断compressed_path是否存在
+    if os.path.exists(compressed_path):
+        os.remove(compressed_path)
+    # 返回图片
+    return Image(base64=b64.decode('utf-8'))
+
+
+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('未定义长消息处理策略')
+
+        # logging.info("长消息: {}".format(text))
+        if config.blob_message_strategy == 'image':
+            # 转换成图片
+            return [text_to_image(text)]
+        elif config.blob_message_strategy == 'forward':
+
+            # 包装转发消息
+            display = ForwardMessageDiaplay(
+                title='群聊的聊天记录',
+                brief='[聊天记录]',
+                source='聊天记录',
+                preview=["bot: "+text],
+                summary="查看1条转发消息"
+            )
+
+            node = ForwardMessageNode(
+                sender_id=config.mirai_http_api_config['qq'],
+                sender_name='bot',
+                message_chain=MessageChain([text])
+            )
+
+            forward = Forward(
+                display=display,
+                node_list=[node]
+            )
+
+            return [forward]
+    else:
+        return [text]

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

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

pkg/qqbot/cmds/plugin/plugin.py

@@ -0,0 +1,200 @@
+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():
+            try:
+                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)))
+            except Exception as e:
+                logging.error("插件更新失败:{}".format(e))
+                pkg.utils.context.get_qqbot_manager().notify_admin("插件更新失败:{} 请尝试手动更新插件".format(e))
+
+
+        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
+

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

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

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
+    

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

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

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

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

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

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

pkg/qqbot/cmds/system/cmd.py

@@ -0,0 +1,39 @@
+from ..mgr import AbstractCommandNode, Context, __command_list__
+
+
+@AbstractCommandNode.register(
+    parent=None,
+    name="cmd",
+    description="显示指令列表",
+    usage="!cmd\n!cmd <指令名称>",
+    aliases=[],
+    privilege=1
+)
+class CmdCommand(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请使用 !cmd <指令名称> 来查看指令的详细信息"
+
+            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
+    

pkg/qqbot/cmds/system/cmds.py

@@ -0,0 +1,39 @@
+from ..mgr import AbstractCommandNode, Context, __command_list__
+
+
+@AbstractCommandNode.register(
+    parent=None,
+    name="cmd",
+    description="显示指令列表",
+    usage="!help\n!help <指令名称>",
+    aliases=[],
+    privilege=1
+)
+class CmdCommand(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请使用 !cmd <指令名称> 来查看指令的详细信息"
+
+            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
+    

pkg/qqbot/cmds/system/help.py

@@ -0,0 +1,19 @@
+from ..mgr import AbstractCommandNode, Context
+
+
+@AbstractCommandNode.register(
+    parent=None,
+    name="help",
+    description="显示自定义的帮助信息",
+    usage="!help",
+    aliases=[],
+    privilege=1
+)
+class HelpCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        import config
+        reply = [(config.help_message if hasattr(config, 'help_message') else "") + "\n请输入 !cmds 查看指令列表"]
+
+        return True, reply
+    

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

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

pkg/qqbot/cmds/system/usage.py

@@ -0,0 +1,35 @@
+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))
+
+        reply = [reply_str]
+
+        return True, reply

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

pkg/qqbot/command.py

@@ -0,0 +1,65 @@
+# 指令处理模块
+import logging
+import json
+import datetime
+import os
+import threading
+import traceback
+
+import pkg.openai.session
+import pkg.openai.manager
+import pkg.utils.reloader
+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 process_command(session_name: str, text_message: str, mgr, config,
+                    launcher_type: str, launcher_id: int, sender_id: int, is_admin: bool) -> list:
+    reply = []
+    try:
+        logging.info(
+            "[{}]发起指令:{}".format(session_name, text_message[:min(20, len(text_message))] + (
+                "..." if len(text_message) > 20 else "")))
+
+        cmd = text_message[1:].strip().split(' ')[0]
+
+        params = text_message[1:].strip().split(' ')[1:]
+
+        # 把!~开头的转换成!cfg
+        if cmd.startswith('~'):
+            params = [cmd[1:]] + params
+            cmd = 'cfg'
+
+        # 包装参数
+        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)]
+
+        return reply
+    except Exception as e:
+        mgr.notify_admin("{}指令执行失败:{}".format(session_name, e))
+        logging.exception(e)
+        reply = ["[bot]err:{}".format(e)]
+
+    return reply

pkg/qqbot/filter.py

@@ -1,18 +1,84 @@
+# 敏感词过滤模块
 import re
+import requests
+import json
+import logging
 
 
 class ReplyFilter:
-
     sensitive_words = []
+    mask = "*"
+    mask_word = ""
 
-    def __init__(self, sensitive_words: list):
+    # 默认值( 兼容性考虑 )
+    baidu_check = False
+    baidu_api_key = ""
+    baidu_secret_key = ""
+    inappropriate_message_tips = "[百度云]请珍惜机器人，当前返回内容不合规"
+
+    def __init__(self, sensitive_words: list, mask: str = "*", mask_word: str = ""):
         self.sensitive_words = sensitive_words
+        self.mask = mask
+        self.mask_word = mask_word
+        import config
+        if hasattr(config, 'baidu_check') and hasattr(config, 'baidu_api_key') and hasattr(config, 'baidu_secret_key'):
+            self.baidu_check = config.baidu_check
+            self.baidu_api_key = config.baidu_api_key
+            self.baidu_secret_key = config.baidu_secret_key
+            self.inappropriate_message_tips = config.inappropriate_message_tips
+
+    def is_illegal(self, message: str) -> bool:
+        processed = self.process(message)
+        if processed != message:
+            return True
+        return False
 
     def process(self, message: str) -> str:
+
+        # 本地关键词屏蔽
         for word in self.sensitive_words:
             match = re.findall(word, message)
             if len(match) > 0:
                 for i in range(len(match)):
-                    message = message.replace(match[i], "*" * len(match[i]))
+                    if self.mask_word == "":
+                        message = message.replace(match[i], self.mask * len(match[i]))
+                    else:
+                        message = message.replace(match[i], self.mask_word)
 
+        # 百度云审核
+        if self.baidu_check:
+
+            # 百度云审核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",
+                              "client_id": self.baidu_api_key,
+                              "client_secret": self.baidu_secret_key}).json().get("access_token"))
+
+            # 百度云审核
+            payload = "text=" + message
+            logging.info("向百度云发送:" + payload)
+            headers = {'Content-Type': 'application/x-www-form-urlencoded', 'Accept': 'application/json'}
+
+            if isinstance(payload, str):
+                payload = payload.encode('utf-8')
+
+            response = requests.request("POST", baidu_url, headers=headers, data=payload)
+            response_dict = json.loads(response.text)
+
+            if "error_code" in response_dict:
+                error_msg = response_dict.get("error_msg")
+                logging.warning(f"百度云判定出错，错误信息：{error_msg}")
+                conclusion = f"百度云判定出错，错误信息：{error_msg}\n以下是原消息：{message}"
+            else:
+                conclusion = response_dict["conclusion"]
+                if conclusion in ("合规"):
+                    logging.info(f"百度云判定结果：{conclusion}")
+                    return message
+                else:
+                    logging.warning(f"百度云判定结果：{conclusion}")
+                    conclusion = self.inappropriate_message_tips
+            # 返回百度云审核结果
+            return conclusion
+        
         return message

pkg/qqbot/ignore.py

@@ -0,0 +1,19 @@
+import re
+
+
+def ignore(msg: str) -> bool:
+    """检查消息是否应该被忽略"""
+    import config
+    
+    if not hasattr(config, 'ignore_rules'):
+        return False
+    
+    if 'prefix' in config.ignore_rules:
+        for rule in config.ignore_rules['prefix']:
+            if msg.startswith(rule):
+                return True
+
+    if 'regexp' in config.ignore_rules:
+        for rule in config.ignore_rules['regexp']:
+            if re.search(rule, msg):
+                return True

pkg/qqbot/manager.py

@@ -4,8 +4,9 @@ import os
 import threading
 
 import mirai.models.bus
-from mirai import At, GroupMessage, MessageEvent, Mirai, Plain, StrangerMessage, WebSocketAdapter, HTTPAdapter, \
+from mirai import At, GroupMessage, MessageEvent, Mirai, StrangerMessage, WebSocketAdapter, HTTPAdapter, \
     FriendMessage, Image
+from func_timeout import func_set_timeout
 
 import pkg.openai.session
 import pkg.openai.manager
@@ -16,15 +17,12 @@ import pkg.qqbot.filter
 import pkg.qqbot.process as processor
 import pkg.utils.context
 
-
-# 并行运行
-def go(func, args=()):
-    thread = threading.Thread(target=func, args=args, daemon=True)
-    thread.start()
+import pkg.plugin.host as plugin_host
+import pkg.plugin.models as plugin_models
 
 
 # 检查消息是否符合泛响应匹配机制
-def check_response_rule(text: str) -> (bool, str):
+def check_response_rule(text: str):
     config = pkg.utils.context.get_config()
     if not hasattr(config, 'response_rules'):
         return False, ''
@@ -47,25 +45,58 @@ def check_response_rule(text: str) -> (bool, str):
     return False, ""
 
 
+def response_at():
+    config = pkg.utils.context.get_config()
+    if 'at' not in config.response_rules:
+        return True
+
+    return config.response_rules['at']
+
+
+def random_responding():
+    config = pkg.utils.context.get_config()
+    if 'random_rate' in config.response_rules:
+        import random
+        return random.random() < config.response_rules['random_rate']
+    return False
+
+
 # 控制QQ消息输入输出的类
 class QQBotManager:
     retry = 3
 
-    bot = None
+    bot: Mirai = None
 
     reply_filter = None
 
-    def __init__(self, mirai_http_api_config: dict, timeout: int = 60, retry: int = 3, first_time_init=True):
+    enable_banlist = False
 
+    ban_person = []
+    ban_group = []
+
+    def __init__(self, mirai_http_api_config: dict, timeout: int = 60, retry: int = 3, first_time_init=True):
         self.timeout = timeout
         self.retry = retry
 
+        # 加载禁用列表
+        if os.path.exists("banlist.py"):
+            import banlist
+            self.enable_banlist = banlist.enable
+            self.ban_person = banlist.person
+            self.ban_group = banlist.group
+            logging.info("加载禁用列表: person: {}, group: {}".format(self.ban_person, self.ban_group))
+
         config = pkg.utils.context.get_config()
         if os.path.exists("sensitive.json") \
                 and config.sensitive_word_filter is not None \
                 and config.sensitive_word_filter:
             with open("sensitive.json", "r", encoding="utf-8") as f:
-                self.reply_filter = pkg.qqbot.filter.ReplyFilter(json.load(f)['words'])
+                sensitive_json = json.load(f)
+                self.reply_filter = pkg.qqbot.filter.ReplyFilter(
+                    sensitive_words=sensitive_json['words'],
+                    mask=sensitive_json['mask'] if 'mask' in sensitive_json else '*',
+                    mask_word=sensitive_json['mask_word'] if 'mask_word' in sensitive_json else ''
+                )
         else:
             self.reply_filter = pkg.qqbot.filter.ReplyFilter([])
 
@@ -82,15 +113,73 @@ class QQBotManager:
         # Caution: 注册新的事件处理器之后，请务必在unsubscribe_all中编写相应的取消订阅代码
         @self.bot.on(FriendMessage)
         async def on_friend_message(event: FriendMessage):
-            go(self.on_person_message, (event,))
+
+            def friend_message_handler(event: FriendMessage):
+
+                # 触发事件
+                args = {
+                    "launcher_type": "person",
+                    "launcher_id": event.sender.id,
+                    "sender_id": event.sender.id,
+                    "message_chain": event.message_chain,
+                }
+                plugin_event = plugin_host.emit(plugin_models.PersonMessageReceived, **args)
+
+                if plugin_event.is_prevented_default():
+                    return
+
+                self.on_person_message(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):
-            go(self.on_person_message, (event,))
+
+            def stranger_message_handler(event: StrangerMessage):
+                # 触发事件
+                args = {
+                    "launcher_type": "person",
+                    "launcher_id": event.sender.id,
+                    "sender_id": event.sender.id,
+                    "message_chain": event.message_chain,
+                }
+                plugin_event = plugin_host.emit(plugin_models.PersonMessageReceived, **args)
+
+                if plugin_event.is_prevented_default():
+                    return
+
+                self.on_person_message(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):
-            go(self.on_group_message, (event,))
+
+            def group_message_handler(event: GroupMessage):
+                # 触发事件
+                args = {
+                    "launcher_type": "group",
+                    "launcher_id": event.group.id,
+                    "sender_id": event.sender.id,
+                    "message_chain": event.message_chain,
+                }
+                plugin_event = plugin_host.emit(plugin_models.GroupMessageReceived, **args)
+
+                if plugin_event.is_prevented_default():
+                    return
+
+                self.on_group_message(event)
+
+            pkg.utils.context.get_thread_ctl().submit_user_task(
+                group_message_handler,
+                event
+            )
 
         def unsubscribe_all():
             """取消所有订阅
@@ -107,6 +196,9 @@ class QQBotManager:
 
         self.unsubscribe_all = unsubscribe_all
 
+    def go(self, func, *args, **kwargs):
+        self.pool.submit(func, *args, **kwargs)
+
     def first_time_init(self, mirai_http_api_config: dict):
         """热重载后不再运行此函数"""
 
@@ -142,6 +234,7 @@ class QQBotManager:
 
     # 私聊消息处理
     def on_person_message(self, event: MessageEvent):
+        import config
         reply = ''
 
         if event.sender.id == self.bot.qq:
@@ -154,12 +247,21 @@ class QQBotManager:
                 failed = 0
                 for i in range(self.retry):
                     try:
-                        reply = processor.process_message('person', event.sender.id, str(event.message_chain),
-                                                          event.message_chain,
-                                                          event.sender.id)
+                        
+                        @func_set_timeout(config.process_message_timeout)
+                        def time_ctrl_wrapper():
+                            reply = processor.process_message('person', event.sender.id, str(event.message_chain),
+                                                            event.message_chain,
+                                                            event.sender.id)
+                            return reply
+                        
+                        reply = time_ctrl_wrapper()
                         break
                     except FunctionTimedOut:
+                        logging.warning("person_{}: 超时，重试中({})".format(event.sender.id, i))
                         pkg.openai.session.get_session('person_{}'.format(event.sender.id)).release_response_lock()
+                        if "person_{}".format(event.sender.id) in pkg.qqbot.process.processing:
+                            pkg.qqbot.process.processing.remove('person_{}'.format(event.sender.id))
                         failed += 1
                         continue
 
@@ -173,7 +275,7 @@ class QQBotManager:
 
     # 群消息处理
     def on_group_message(self, event: GroupMessage):
-
+        import config
         reply = ''
 
         def process(text=None) -> str:
@@ -185,13 +287,21 @@ class QQBotManager:
             failed = 0
             for i in range(self.retry):
                 try:
-                    replys = processor.process_message('group', event.group.id,
-                                                       str(event.message_chain).strip() if text is None else text,
-                                                       event.message_chain,
-                                                       event.sender.id)
+                    @func_set_timeout(config.process_message_timeout)
+                    def time_ctrl_wrapper():
+                        replys = processor.process_message('group', event.group.id,
+                                                        str(event.message_chain).strip() if text is None else text,
+                                                        event.message_chain,
+                                                        event.sender.id)
+                        return replys
+                    
+                    replys = time_ctrl_wrapper()
                     break
                 except FunctionTimedOut:
+                    logging.warning("group_{}: 超时，重试中({})".format(event.group.id, i))
                     pkg.openai.session.get_session('group_{}'.format(event.group.id)).release_response_lock()
+                    if "group_{}".format(event.group.id) in pkg.qqbot.process.processing:
+                        pkg.qqbot.process.processing.remove('group_{}'.format(event.group.id))
                     failed += 1
                     continue
 
@@ -204,14 +314,19 @@ class QQBotManager:
 
         if Image in event.message_chain:
             pass
-        elif At(self.bot.qq) not in event.message_chain:
-            check, result = check_response_rule(str(event.message_chain).strip())
-
-            if check:
-                reply = process(result.strip())
         else:
-            # 直接调用
-            reply = process()
+            if At(self.bot.qq) in event.message_chain and response_at():
+                # 直接调用
+                reply = process()
+            else:
+                check, result = check_response_rule(str(event.message_chain).strip())
+
+                if check:
+                    reply = process(result.strip())
+                # 检查是否随机响应
+                elif random_responding():
+                    logging.info("随机响应group_{}消息".format(event.group.id))
+                    reply = process()
 
         if reply:
             return self.send(event, reply)
@@ -219,7 +334,25 @@ class QQBotManager:
     # 通知系统管理员
     def notify_admin(self, message: str):
         config = pkg.utils.context.get_config()
-        if hasattr(config, "admin_qq") and config.admin_qq != 0:
+        if hasattr(config, "admin_qq") and config.admin_qq != 0 and config.admin_qq != []:
             logging.info("通知管理员:{}".format(message))
-            send_task = self.bot.send_friend_message(config.admin_qq, "[bot]{}".format(message))
-            threading.Thread(target=asyncio.run, args=(send_task,)).start()
+            if type(config.admin_qq) == int:
+                send_task = self.bot.send_friend_message(config.admin_qq, "[bot]{}".format(message))
+                threading.Thread(target=asyncio.run, args=(send_task,)).start()
+            else:
+                for adm in config.admin_qq:
+                    send_task = self.bot.send_friend_message(adm, "[bot]{}".format(message))
+                    threading.Thread(target=asyncio.run, args=(send_task,)).start()
+
+
+    def notify_admin_message_chain(self, message):
+        config = pkg.utils.context.get_config()
+        if hasattr(config, "admin_qq") and config.admin_qq != 0 and config.admin_qq != []:
+            logging.info("通知管理员:{}".format(message))
+            if type(config.admin_qq) == int:
+                send_task = self.bot.send_friend_message(config.admin_qq, message)
+                threading.Thread(target=asyncio.run, args=(send_task,)).start()
+            else:
+                for adm in config.admin_qq:
+                    send_task = self.bot.send_friend_message(adm, message)
+                    threading.Thread(target=asyncio.run, args=(send_task,)).start()

pkg/qqbot/message.py

@@ -0,0 +1,128 @@
+# 普通消息处理模块
+import logging
+import openai
+import pkg.utils.context
+import pkg.openai.session
+
+import pkg.plugin.host as plugin_host
+import pkg.plugin.models as plugin_models
+import pkg.qqbot.blob as blob
+
+
+def handle_exception(notify_admin: str = "", set_reply: str = "") -> list:
+    """处理异常，当notify_admin不为空时，会通知管理员，返回通知用户的消息"""
+    import config
+    pkg.utils.context.get_qqbot_manager().notify_admin(notify_admin)
+    if hasattr(config, 'hide_exce_info_to_user') and config.hide_exce_info_to_user:
+        if hasattr(config, 'alter_tip_message'):
+            return [config.alter_tip_message] if config.alter_tip_message else []
+        else:
+            return ["[bot]出错了，请重试或联系管理员"]
+    else:
+        return [set_reply]
+
+
+def process_normal_message(text_message: str, mgr, config, launcher_type: str,
+                           launcher_id: int, sender_id: int) -> list:
+    session_name = f"{launcher_type}_{launcher_id}"
+    logging.info("[{}]发送消息:{}".format(session_name, text_message[:min(20, len(text_message))] + (
+        "..." if len(text_message) > 20 else "")))
+
+    session = pkg.openai.session.get_session(session_name)
+
+    unexpected_exception_times = 0
+
+    max_unexpected_exception_times = 3
+
+    reply = []
+    while True:
+        if unexpected_exception_times >= max_unexpected_exception_times:
+            reply = handle_exception(notify_admin=f"{session_name}，多次尝试失败。", set_reply=f"[bot]多次尝试失败，请重试或联系管理员")
+            break
+        try:
+            prefix = "[GPT]" if hasattr(config, "show_prefix") and config.show_prefix else ""
+
+            text = session.append(text_message)
+
+            # 触发插件事件
+            args = {
+                "launcher_type": launcher_type,
+                "launcher_id": launcher_id,
+                "sender_id": sender_id,
+                "session": session,
+                "prefix": prefix,
+                "response_text": text
+            }
+
+            event = pkg.plugin.host.emit(plugin_models.NormalMessageResponded, **args)
+
+            if event.get_return_value("prefix") is not None:
+                prefix = event.get_return_value("prefix")
+
+            if event.get_return_value("reply") is not None:
+                reply = event.get_return_value("reply")
+
+            if not event.is_prevented_default():
+                reply = [prefix + text]
+        except openai.error.APIConnectionError as e:
+            err_msg = str(e)
+            if err_msg.__contains__('Error communicating with OpenAI'):
+                reply = handle_exception("{}会话调用API失败:{}\n请尝试关闭网络代理来解决此问题。".format(session_name, e),
+                                         "[bot]err:调用API失败，请重试或联系管理员，或等待修复")
+            else:
+                reply = handle_exception("{}会话调用API失败:{}".format(session_name, e), "[bot]err:调用API失败，请重试或联系管理员，或等待修复")
+        except openai.error.RateLimitError as e:
+            logging.debug(type(e))
+            logging.debug(e.error['message'])
+
+            if 'message' in e.error and e.error['message'].__contains__('You exceeded your current quota'):
+                # 尝试切换api-key
+                current_key_name = pkg.utils.context.get_openai_manager().key_mgr.get_key_name(
+                    pkg.utils.context.get_openai_manager().key_mgr.using_key
+                )
+                pkg.utils.context.get_openai_manager().key_mgr.set_current_exceeded()
+
+                # 触发插件事件
+                args = {
+                    'key_name': current_key_name,
+                    'usage': pkg.utils.context.get_openai_manager().audit_mgr
+                            .get_usage(pkg.utils.context.get_openai_manager().key_mgr.get_using_key_md5()),
+                    'exceeded_keys': pkg.utils.context.get_openai_manager().key_mgr.exceeded,
+                }
+                event = plugin_host.emit(plugin_models.KeyExceeded, **args)
+
+                if not event.is_prevented_default():
+                    switched, name = pkg.utils.context.get_openai_manager().key_mgr.auto_switch()
+
+                    if not switched:
+                        reply = handle_exception(
+                            "api-key调用额度超限({}),无可用api_key,请向OpenAI账户充值或在config.py中更换api_key；如果你认为这是误判，请尝试重启程序。".format(
+                                current_key_name), "[bot]err:API调用额度超额，请联系管理员，或等待修复")
+                    else:
+                        openai.api_key = pkg.utils.context.get_openai_manager().key_mgr.get_using_key()
+                        mgr.notify_admin("api-key调用额度超限({}),接口报错,已切换到{}".format(current_key_name, name))
+                        reply = ["[bot]err:API调用额度超额，已自动切换，请重新发送消息"]
+                        continue
+            elif 'message' in e.error and e.error['message'].__contains__('You can retry your request'):
+                # 重试
+                unexpected_exception_times += 1
+                continue
+            elif 'message' in e.error and e.error['message']\
+                    .__contains__('The server had an error while processing your request'):
+                # 重试
+                unexpected_exception_times += 1
+                continue
+            else:
+                reply = handle_exception("{}会话调用API失败:{}".format(session_name, e),
+                                         "[bot]err:RateLimitError,请重试或联系作者，或等待修复")
+        except openai.error.InvalidRequestError as e:
+            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调用服务不可用，请重试或联系管理员，或等待修复")
+        except Exception as e:
+            logging.exception(e)
+            reply = handle_exception("{}会话处理异常:{}".format(session_name, e), "[bot]err:{}".format(e))
+        break
+
+    return reply

pkg/qqbot/process.py

@@ -1,96 +1,45 @@
 # 此模块提供了消息处理的具体逻辑的接口
 import asyncio
-import datetime
-import json
-import threading
+import time
 
-from func_timeout import func_set_timeout
+import mirai
 import logging
-import openai
 
-from mirai import Image, MessageChain
+from mirai import MessageChain, Plain
 
 # 这里不使用动态引入config
 # 因为在这里动态引入会卡死程序
 # 而此模块静态引用config与动态引入的表现一致
-import config as config_init_import
+# 已弃用，由于超时时间现已动态使用
+# import config as config_init_import
 
 import pkg.openai.session
 import pkg.openai.manager
 import pkg.utils.reloader
 import pkg.utils.updater
 import pkg.utils.context
+import pkg.qqbot.message
+import pkg.qqbot.command
+import pkg.qqbot.ratelimit as ratelimit
+
+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 = []
 
 
-def config_operation(cmd, params):
-    reply = []
-    config = pkg.utils.context.get_config()
-    reply_str = ""
-    if len(params) == 0:
-        reply = ["[bot]err:请输入配置项"]
+def is_admin(qq: int) -> bool:
+    """兼容list和int类型的管理员判断"""
+    import config
+    if type(config.admin_qq) == list:
+        return qq in config.admin_qq
     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
+        return qq == config.admin_qq
 
 
-@func_set_timeout(config_init_import.process_message_timeout)
 def process_message(launcher_type: str, launcher_id: int, text_message: str, message_chain: MessageChain,
                     sender_id: int) -> MessageChain:
     global processing
@@ -100,231 +49,122 @@ def process_message(launcher_type: str, launcher_id: int, text_message: str, mes
     reply = []
     session_name = "{}_{}".format(launcher_type, launcher_id)
 
+    # 检查发送方是否被禁用
+    if banlist.is_banned(launcher_type, launcher_id, sender_id):
+        logging.info("根据禁用列表忽略{}_{}的消息".format(launcher_type, launcher_id))
+        return []
+
+    if ignore.ignore(text_message):
+        logging.info("根据忽略规则忽略消息: {}".format(text_message))
+        return []
+
     # 检查是否被禁言
     if launcher_type == 'group':
         result = mgr.bot.member_info(target=launcher_id, member_id=mgr.bot.qq).get()
         result = asyncio.run(result)
         if result.mute_time_remaining > 0:
             logging.info("机器人被禁言,跳过消息处理(group_{},剩余{}s)".format(launcher_id,
-                                                                                  result.mute_time_remaining))
+                                                                                result.mute_time_remaining))
             return reply
 
+    import config
+    if hasattr(config, 'income_msg_check') and config.income_msg_check:
+        if mgr.reply_filter.is_illegal(text_message):
+            return MessageChain(Plain("[bot] 你的提问中有不合适的内容, 请更换措辞~"))
+
     pkg.openai.session.get_session(session_name).acquire_response_lock()
 
+    text_message = text_message.strip()
+
+    # 处理消息
     try:
         if session_name in processing:
             pkg.openai.session.get_session(session_name).release_response_lock()
-            return ["[bot]err:正在处理中，请稍后再试"]
-
-        processing.append(session_name)
+            return MessageChain([Plain("[bot]err:正在处理中，请稍后再试")])
 
         config = pkg.utils.context.get_config()
 
+        processing.append(session_name)
         try:
-
             if text_message.startswith('!') or text_message.startswith("！"):  # 指令
-                try:
-                    logging.info(
-                        "[{}]发起指令:{}".format(session_name, text_message[:min(20, len(text_message))] + (
-                            "..." if len(text_message) > 20 else "")))
+                # 触发插件事件
+                args = {
+                    'launcher_type': launcher_type,
+                    'launcher_id': launcher_id,
+                    'sender_id': sender_id,
+                    'command': text_message[1:].strip().split(' ')[0],
+                    'params': text_message[1:].strip().split(' ')[1:],
+                    'text_message': text_message,
+                    'is_admin': is_admin(sender_id),
+                }
+                event = plugin_host.emit(plugin_models.PersonCommandSent
+                                         if launcher_type == 'person'
+                                         else plugin_models.GroupCommandSent, **args)
 
-                    cmd = text_message[1:].strip().split(' ')[0]
+                if event.get_return_value("alter") is not None:
+                    text_message = event.get_return_value("alter")
 
-                    params = text_message[1:].strip().split(' ')[1:]
-                    if cmd == 'help':
-                        reply = ["[bot]" + config.help_message]
-                    elif cmd == 'reset':
-                        pkg.openai.session.get_session(session_name).reset(explicit=True)
-                        reply = ["[bot]会话已重置"]
-                    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) + result.prompt[
-                                                :min(100,
-                                                     len(result.prompt))] + \
-                                     ("..." if len(result.prompt) > 100 else "#END#")]
-                    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) + result.prompt[
-                                                :min(100,
-                                                     len(result.prompt))] + \
-                                     ("..." if len(result.prompt) > 100 else "#END#")]
-                    elif cmd == 'prompt':
-                        reply = ["[bot]当前对话所有内容：\n" + pkg.openai.session.get_session(session_name).prompt]
-                    elif cmd == 'list':
-                        pkg.openai.session.get_session(session_name).persistence()
-                        page = 0
+                # 取出插件提交的返回值赋值给reply
+                if event.get_return_value("reply") is not None:
+                    reply = event.get_return_value("reply")
 
-                        if len(params) > 0:
-                            try:
-                                page = int(params[0])
-                            except ValueError:
-                                pass
+                if not event.is_prevented_default():
+                    reply = pkg.qqbot.command.process_command(session_name, text_message,
+                                                              mgr, config, launcher_type, launcher_id, sender_id, is_admin(sender_id))
 
-                        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'])
-                                reply_str += "#{} 创建:{} {}\n".format(i + page * 10,
-                                                                       datetime_obj.strftime("%Y-%m-%d %H:%M:%S"),
-                                                                       results[i]['prompt'][
-                                                                       :min(20, len(results[i]['prompt']))])
-                                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]
-                    elif cmd == 'fee':
-                        api_keys = pkg.utils.context.get_openai_manager().key_mgr.api_key
-                        reply_str = "[bot]api-key费用情况(估算):(阈值:{})\n\n".format(
-                            pkg.utils.context.get_openai_manager().key_mgr.api_key_fee_threshold)
-
-                        using_key_name = ""
-                        for api_key in api_keys:
-                            reply_str += "{}:\n - {}美元 {}%\n".format(api_key,
-                                                                       round(
-                                                                           pkg.utils.context.get_openai_manager().key_mgr.get_fee(
-                                                                               api_keys[api_key]), 6),
-                                                                       round(
-                                                                           pkg.utils.context.get_openai_manager().key_mgr.get_fee(
-                                                                               api_keys[
-                                                                                   api_key]) / pkg.utils.context.get_openai_manager().key_mgr.api_key_fee_threshold * 100,
-                                                                           3))
-                            if api_keys[api_key] == pkg.utils.context.get_openai_manager().key_mgr.using_key:
-                                using_key_name = api_key
-                        reply_str += "\n当前使用:{}".format(using_key_name)
-
-                        reply = [reply_str]
-                    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))
-
-                        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 == 'reload' and launcher_type == 'person' and launcher_id == config.admin_qq:
-                        def reload_task():
-                            pkg.utils.reloader.reload_all()
-
-                        threading.Thread(target=reload_task, daemon=True).start()
-                    elif cmd == 'update' and launcher_type == 'person' and launcher_id == config.admin_qq:
-                        def update_task():
-                            try:
-                                pkg.utils.updater.update_all()
-                            except Exception as e0:
-                                pkg.utils.context.get_qqbot_manager().notify_admin("更新失败:{}".format(e0))
-                                return
-                            pkg.utils.reloader.reload_all(notify=False)
-                            pkg.utils.context.get_qqbot_manager().notify_admin("更新完成")
-
-                        threading.Thread(target=update_task, daemon=True).start()
-                    elif cmd == 'cfg' and launcher_type == 'person' and launcher_id == config.admin_qq:
-                        reply = config_operation(cmd, params)
-                    else:
-                        if cmd.startswith("~") and launcher_type == 'person' and launcher_id == config.admin_qq:
-                            config_item = cmd[1:]
-                            params = [config_item] + params
-                            reply = config_operation("cfg", params)
-                        else:
-                            reply = ["[bot]err:未知的指令或权限不足: "+cmd]
-                except Exception as e:
-                    mgr.notify_admin("{}指令执行失败:{}".format(session_name, e))
-                    logging.exception(e)
-                    reply = ["[bot]err:{}".format(e)]
             else:  # 消息
-                logging.info("[{}]发送消息:{}".format(session_name, text_message[:min(20, len(text_message))] + (
-                    "..." if len(text_message) > 20 else "")))
+                # 限速丢弃检查
+                # print(ratelimit.__crt_minute_usage__[session_name])
+                if hasattr(config, "rate_limitation") and config.rate_limit_strategy == "drop":
+                    if ratelimit.is_reach_limit(session_name):
+                        logging.info("根据限速策略丢弃[{}]消息: {}".format(session_name, text_message))
+                        return MessageChain(["[bot]"+config.rate_limit_drop_tip]) if hasattr(config, "rate_limit_drop_tip") and config.rate_limit_drop_tip != "" else []
 
-                session = pkg.openai.session.get_session(session_name)
+                before = time.time()
+                # 触发插件事件
+                args = {
+                    "launcher_type": launcher_type,
+                    "launcher_id": launcher_id,
+                    "sender_id": sender_id,
+                    "text_message": text_message,
+                }
+                event = plugin_host.emit(plugin_models.PersonNormalMessageReceived
+                                         if launcher_type == 'person'
+                                         else plugin_models.GroupNormalMessageReceived, **args)
 
-                while True:
-                    try:
-                        prefix = "[GPT]" if hasattr(config, "show_prefix") and config.show_prefix else ""
-                        reply = [prefix + session.append(text_message)]
-                    except openai.error.APIConnectionError as e:
-                        mgr.notify_admin("{}会话调用API失败:{}".format(session_name, e))
-                        reply = ["[bot]err:调用API失败，请重试或联系作者，或等待修复"]
-                    except openai.error.RateLimitError as e:
-                        # 尝试切换api-key
-                        current_tokens_amt = pkg.utils.context.get_openai_manager().key_mgr.get_fee(
-                            pkg.utils.context.get_openai_manager().key_mgr.get_using_key())
-                        pkg.utils.context.get_openai_manager().key_mgr.set_current_exceeded()
-                        switched, name = pkg.utils.context.get_openai_manager().key_mgr.auto_switch()
+                if event.get_return_value("alter") is not None:
+                    text_message = event.get_return_value("alter")
 
-                        if not switched:
-                            mgr.notify_admin("API调用额度超限({}),无可用api_key,请向OpenAI账户充值或在config.py中更换api_key".format(
-                                current_tokens_amt))
-                            reply = ["[bot]err:API调用额度超额，请联系作者，或等待修复"]
-                        else:
-                            openai.api_key = pkg.utils.context.get_openai_manager().key_mgr.get_using_key()
-                            mgr.notify_admin("API调用额度超限({}),接口报错,已切换到{}".format(current_tokens_amt, name))
-                            reply = ["[bot]err:API调用额度超额，已自动切换，请重新发送消息"]
-                            continue
-                    except openai.error.InvalidRequestError as e:
-                        mgr.notify_admin("{}API调用参数错误:{}\n\n这可能是由于config.py中的prompt_submit_length参数或"
-                                         "completion_api_params中的max_tokens参数数值过大导致的，请尝试将其降低".format(
-                            session_name, e))
-                        reply = ["[bot]err:API调用参数错误，请联系作者，或等待修复"]
-                    except openai.error.ServiceUnavailableError as e:
-                        # mgr.notify_admin("{}API调用服务不可用:{}".format(session_name, e))
-                        reply = ["[bot]err:API调用服务暂不可用，请尝试重试"]
-                    except Exception as e:
-                        logging.exception(e)
-                        reply = ["[bot]err:{}".format(e)]
-                    break
+                # 取出插件提交的返回值赋值给reply
+                if event.get_return_value("reply") is not None:
+                    reply = event.get_return_value("reply")
 
-            if reply is not None and type(reply[0]) == str:
+                if not event.is_prevented_default():
+                    reply = pkg.qqbot.message.process_normal_message(text_message,
+                                                                     mgr, config, launcher_type, launcher_id, sender_id)
+
+                # 限速等待时间
+                if hasattr(config, "rate_limitation") and config.rate_limit_strategy == "wait":
+                    time.sleep(ratelimit.get_rest_wait_time(session_name, time.time() - before))
+                
+                if hasattr(config, "rate_limitation"):
+                    ratelimit.add_usage(session_name)
+
+            if reply is not None and len(reply) > 0 and (type(reply[0]) == str or type(reply[0]) == mirai.Plain):
+                if type(reply[0]) == mirai.Plain:
+                    reply[0] = reply[0].text
                 logging.info(
                     "回复[{}]文字消息:{}".format(session_name,
                                                  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, reply))
+                logging.info("回复[{}]消息".format(session_name))
 
         finally:
             processing.remove(session_name)
     finally:
         pkg.openai.session.get_session(session_name).release_response_lock()
 
-        return MessageChain(reply)
+    return MessageChain(reply)

pkg/qqbot/ratelimit.py

@@ -0,0 +1,86 @@
+# 限速相关模块
+import time
+import logging
+import threading
+
+__crt_minute_usage__ = {}
+"""当前分钟每个会话的对话次数"""
+
+
+__timer_thr__: threading.Thread = None
+
+
+def add_usage(session_name: str):
+    """增加会话的对话次数"""
+    global __crt_minute_usage__
+    if session_name in __crt_minute_usage__:
+        __crt_minute_usage__[session_name] += 1
+    else:
+        __crt_minute_usage__[session_name] = 1
+
+
+def start_timer():
+    """启动定时器"""
+    global __timer_thr__
+    __timer_thr__ = threading.Thread(target=run_timer, daemon=True)
+    __timer_thr__.start()
+
+
+def run_timer():
+    """启动定时器，每分钟清空一次对话次数"""
+    global __crt_minute_usage__
+    global __timer_thr__
+    
+    # 等待直到整分钟
+    time.sleep(60 - time.time() % 60)
+
+    while True:
+        if __timer_thr__ != threading.current_thread():
+            break
+        
+        logging.debug("清空当前分钟的对话次数")
+        __crt_minute_usage__ = {}
+        time.sleep(60)
+
+
+def get_usage(session_name: str) -> int:
+    """获取会话的对话次数"""
+    global __crt_minute_usage__
+    if session_name in __crt_minute_usage__:
+        return __crt_minute_usage__[session_name]
+    else:
+        return 0
+
+
+def get_rest_wait_time(session_name: str, spent: float) -> float:
+    """获取会话此回合的剩余等待时间"""
+    global __crt_minute_usage__
+
+    import config
+
+    if not hasattr(config, 'rate_limitation'):
+        return 0
+
+    min_seconds_per_round = 60.0 / config.rate_limitation
+
+    if session_name in __crt_minute_usage__:
+        return max(0, min_seconds_per_round - spent)
+    else:
+        return 0
+
+
+def is_reach_limit(session_name: str) -> bool:
+    """判断会话是否超过限制"""
+    global __crt_minute_usage__
+
+    import config
+
+    if not hasattr(config, 'rate_limitation'):
+        return False
+
+    if session_name in __crt_minute_usage__:
+        return __crt_minute_usage__[session_name] >= config.rate_limitation
+    else:
+        return False
+
+start_timer()

pkg/utils/__init__.py

@@ -0,0 +1 @@
+from .threadctl import ThreadCtl

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()

pkg/utils/context.py

@@ -1,6 +1,6 @@
-import pkg.database.manager
-import pkg.openai.manager
-import pkg.qqbot.manager
+import threading
+from pkg.utils import ThreadCtl
+
 
 context = {
     'inst': {
@@ -8,38 +8,87 @@ context = {
         '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():
+    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

pkg/utils/credit.py

@@ -0,0 +1,19 @@
+# OpenAI账号免费额度剩余查询
+import requests
+
+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()

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

pkg/utils/pkgmgr.py

@@ -0,0 +1,40 @@
+from pip._internal import main as pipmain
+
+import main
+
+
+def install(package):
+    pipmain(['install', package])
+    main.reset_logging()
+
+
+def run_pip(params: list):
+    pipmain(params)
+    main.reset_logging()
+
+
+def install_requirements(file):
+    pipmain(['install', '-r', file, "--upgrade"])
+    main.reset_logging()
+
+
+def ensure_dulwich():
+    # 尝试三次
+    for i in range(3):
+        try:
+            import dulwich
+            return
+        except ImportError:
+            install('dulwich')
+
+    raise ImportError("无法自动安装dulwich库")
+
+
+if __name__ == "__main__":
+    try:
+        install("openai11")
+    except Exception as e:
+        print(111)
+        print(e)
+
+    print(222)

pkg/utils/reloader.py

@@ -3,40 +3,62 @@ import threading
 
 import importlib
 import pkgutil
-import pkg.utils.context
+import pkg.utils.context as context
+import pkg.plugin.host
 
 
-def walk(module, prefix=''):
+def walk(module, prefix='', path_prefix=''):
     """遍历并重载所有模块"""
     for item in pkgutil.iter_modules(module.__path__):
         if item.ispkg:
-            walk(__import__(module.__name__ + '.' + item.name, fromlist=['']), prefix + item.name + '.')
+
+            walk(__import__(module.__name__ + '.' + item.name, fromlist=['']), prefix + item.name + '.', path_prefix + item.name + '/')
         else:
-            logging.info('reload module: {}'.format(prefix + item.name))
+            logging.info('reload module: {}, path: {}'.format(prefix + item.name, path_prefix + item.name + '.py'))
+            pkg.plugin.host.__current_module_path__ = "plugins/" + path_prefix + item.name + '.py'
             importlib.reload(__import__(module.__name__ + '.' + item.name, fromlist=['']))
 
 
 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'))
-    pkg.utils.context.context = context
+    importlib.reload(__import__('banlist'))
+    context.context = this_context
+
+    # 重载插件
+    import plugins
+    walk(plugins)
 
     # 执行启动流程
     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("重载完成")

pkg/utils/text2img.py

@@ -0,0 +1,193 @@
+import logging
+
+from PIL import Image, ImageDraw, ImageFont
+import re
+import os
+import config
+import traceback
+
+text_render_font: ImageFont = None
+
+if hasattr(config, "blob_message_strategy") and config.blob_message_strategy == "image":  # 仅在启用了image时才加载字体
+    use_font = config.font_path if hasattr(config, "font_path") else ""
+    try:
+
+        # 检查是否存在
+        if not os.path.exists(use_font):
+            # 若是windows系统，使用微软雅黑
+            if os.name == "nt":
+                use_font = "C:/Windows/Fonts/msyh.ttc"
+                if not os.path.exists(use_font):
+                    logging.warn("未找到字体文件，且无法使用Windows自带字体，更换为转发消息组件以发送长消息，您可以在config.py中调整相关设置。")
+                    config.blob_message_strategy = "forward"
+                else:
+                    logging.info("使用Windows自带字体：" + use_font)
+                    text_render_font = ImageFont.truetype(use_font, 32, encoding="utf-8")
+            else:
+                logging.warn("未找到字体文件，且无法使用Windows自带字体，更换为转发消息组件以发送长消息，您可以在config.py中调整相关设置。")
+                config.blob_message_strategy = "forward"
+        else:
+            text_render_font = ImageFont.truetype(use_font, 32, encoding="utf-8")
+    except:
+        traceback.print_exc()
+        logging.error("加载字体文件失败({})，更换为转发消息组件以发送长消息，您可以在config.py中调整相关设置。".format(use_font))
+        config.blob_message_strategy = "forward"
+
+
+def indexNumber(path=''):
+    """
+    查找字符串中数字所在串中的位置
+    :param path:目标字符串
+    :return:<class 'list'>: <class 'list'>: [['1', 16], ['2', 35], ['1', 51]]
+    """
+    kv = []
+    nums = []
+    beforeDatas = re.findall('[\d]+', path)
+    for num in beforeDatas:
+        indexV = []
+        times = path.count(num)
+        if times > 1:
+            if num not in nums:
+                indexs = re.finditer(num, path)
+                for index in indexs:
+                    iV = []
+                    i = index.span()[0]
+                    iV.append(num)
+                    iV.append(i)
+                    kv.append(iV)
+            nums.append(num)
+        else:
+            index = path.find(num)
+            indexV.append(num)
+            indexV.append(index)
+            kv.append(indexV)
+    # 根据数字位置排序
+    indexSort = []
+    resultIndex = []
+    for vi in kv:
+        indexSort.append(vi[1])
+    indexSort.sort()
+    for i in indexSort:
+        for v in kv:
+            if i == v[1]:
+                resultIndex.append(v)
+    return resultIndex
+
+
+def get_size(file):
+    # 获取文件大小:KB
+    size = os.path.getsize(file)
+    return size / 1024
+
+
+def get_outfile(infile, outfile):
+    if outfile:
+        return outfile
+    dir, suffix = os.path.splitext(infile)
+    outfile = '{}-out{}'.format(dir, suffix)
+    return outfile
+
+
+def compress_image(infile, outfile='', kb=100, step=20, quality=90):
+    """不改变图片尺寸压缩到指定大小
+    :param infile: 压缩源文件
+    :param outfile: 压缩文件保存地址
+    :param mb: 压缩目标,KB
+    :param step: 每次调整的压缩比率
+    :param quality: 初始压缩比率
+    :return: 压缩文件地址，压缩文件大小
+    """
+    o_size = get_size(infile)
+    if o_size <= kb:
+        return infile, o_size
+    outfile = get_outfile(infile, outfile)
+    while o_size > kb:
+        im = Image.open(infile)
+        im.save(outfile, quality=quality)
+        if quality - step < 0:
+            break
+        quality -= step
+        o_size = get_size(outfile)
+    return outfile, get_size(outfile)
+
+
+def text_to_image(text_str: str, save_as="temp.png", width=800):
+    global text_render_font
+
+    text_str = text_str.replace("\t", "    ")
+    
+    # 分行
+    lines = text_str.split('\n')
+
+    # 计算并分割
+    final_lines = []
+
+    text_width = width-80
+    for line in lines:
+        # 如果长了就分割
+        line_width = text_render_font.getlength(line)
+        if line_width < text_width:
+            final_lines.append(line)
+            continue
+        else:
+            rest_text = line
+            while True:
+                # 分割最前面的一行
+                point = int(len(rest_text) * (text_width / line_width))
+
+                # 检查断点是否在数字中间
+                numbers = indexNumber(rest_text)
+
+                for number in numbers:
+                    if number[1] < point < number[1] + len(number[0]) and number[1] != 0:
+                        point = number[1]
+                        break
+
+                final_lines.append(rest_text[:point])
+                rest_text = rest_text[point:]
+                line_width = text_render_font.getlength(rest_text)
+                if line_width < text_width:
+                    final_lines.append(rest_text)
+                    break
+                else:
+                    continue
+    # 准备画布
+    img = Image.new('RGBA', (width, max(280, len(final_lines) * 35 + 65)), (255, 255, 255, 255))
+    draw = ImageDraw.Draw(img, mode='RGBA')
+
+    
+    # 绘制正文
+    line_number = 0
+    offset_x = 20
+    offset_y = 30
+    for final_line in final_lines:
+        draw.text((offset_x, offset_y + 35 * line_number), final_line, fill=(0, 0, 0), font=text_render_font)
+        # 遍历此行,检查是否有emoji
+        idx_in_line = 0
+        for ch in final_line:
+            # if self.is_emoji(ch):
+            #     emoji_img_valid = ensure_emoji(hex(ord(ch))[2:])
+            #     if emoji_img_valid:  # emoji图像可用,绘制到指定位置
+            #         emoji_image = Image.open("emojis/{}.png".format(hex(ord(ch))[2:]), mode='r').convert('RGBA')
+            #         emoji_image = emoji_image.resize((32, 32))
+
+            #         x, y = emoji_image.size
+
+            #         final_emoji_img = Image.new('RGBA', emoji_image.size, (255, 255, 255))
+            #         final_emoji_img.paste(emoji_image, (0, 0, x, y), emoji_image)
+
+            #         img.paste(final_emoji_img, box=(int(offset_x + idx_in_line * 32), offset_y + 35 * line_number))
+
+            # 检查字符占位宽
+            char_code = ord(ch)
+            if char_code >= 127:
+                idx_in_line += 1
+            else:
+                idx_in_line += 0.5
+
+        line_number += 1
+
+    
+    img.save(save_as)
+
+    return save_as

pkg/utils/threadctl.py

@@ -0,0 +1,93 @@
+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__)

pkg/utils/updater.py

@@ -1,15 +1,259 @@
+import datetime
+import logging
+import os.path
+
+import requests
+import json
+
+import pkg.utils.constants
+import pkg.utils.network as network
+
+
+def check_dulwich_closure():
+    try:
+        import pkg.utils.pkgmgr
+        pkg.utils.pkgmgr.ensure_dulwich()
+    except:
+        pass
 
-def update_all():
-    """使用dulwich更新源码"""
     try:
         import dulwich
     except ModuleNotFoundError:
         raise Exception("dulwich模块未安装,请查看 https://github.com/RockChinQ/QChatGPT/issues/77")
+
+
+def pull_latest(repo_path: str) -> bool:
+    """拉取最新代码"""
+    check_dulwich_closure()
+
+    from dulwich import porcelain
+
+    repo = porcelain.open_repo(repo_path)
+    porcelain.pull(repo)
+
+    return True
+
+
+def get_release_list() -> list:
+    """获取发行列表"""
+    rls_list_resp = requests.get(
+        url="https://api.github.com/repos/RockChinQ/QChatGPT/releases",
+        proxies=network.wrapper_proxies()
+    )
+
+    rls_list = rls_list_resp.json()
+
+    return rls_list
+
+
+def get_current_tag() -> str:
+    """获取当前tag"""
+    current_tag = pkg.utils.constants.semantic_version
+    if os.path.exists("current_tag"):
+        with open("current_tag", "r") as f:
+            current_tag = f.read()
+
+    return current_tag
+
+
+def update_all(cli: bool = False) -> bool:
+    """检查更新并下载源码"""
+    current_tag = get_current_tag()
+
+    rls_list = get_release_list()
+
+    latest_rls = {}
+    rls_notes = []
+    for rls in rls_list:
+        rls_notes.append(rls['name'])  # 使用发行名称作为note
+        if rls['tag_name'] == current_tag:
+            break
+
+        if latest_rls == {}:
+            latest_rls = rls
+    if not cli:
+        logging.info("更新日志: {}".format(rls_notes))
+    else:
+        print("更新日志: {}".format(rls_notes))
+
+    if latest_rls == {}:  # 没有新版本
+        return False
+
+    # 下载最新版本的zip到temp目录
+    if not cli:
+        logging.info("开始下载最新版本: {}".format(latest_rls['zipball_url']))
+    else:
+        print("开始下载最新版本: {}".format(latest_rls['zipball_url']))
+    zip_url = latest_rls['zipball_url']
+    zip_resp = requests.get(
+        url=zip_url,
+        proxies=network.wrapper_proxies()
+    )
+    zip_data = zip_resp.content
+
+    # 检查temp/updater目录
+    if not os.path.exists("temp"):
+        os.mkdir("temp")
+    if not os.path.exists("temp/updater"):
+        os.mkdir("temp/updater")
+    with open("temp/updater/{}.zip".format(latest_rls['tag_name']), "wb") as f:
+        f.write(zip_data)
+
+    if not cli:
+        logging.info("下载最新版本完成: {}".format("temp/updater/{}.zip".format(latest_rls['tag_name'])))
+    else:
+        print("下载最新版本完成: {}".format("temp/updater/{}.zip".format(latest_rls['tag_name'])))
+
+    # 解压zip到temp/updater/<tag_name>/
+    import zipfile
+    # 检查目标文件夹
+    if os.path.exists("temp/updater/{}".format(latest_rls['tag_name'])):
+        import shutil
+        shutil.rmtree("temp/updater/{}".format(latest_rls['tag_name']))
+    os.mkdir("temp/updater/{}".format(latest_rls['tag_name']))
+    with zipfile.ZipFile("temp/updater/{}.zip".format(latest_rls['tag_name']), 'r') as zip_ref:
+        zip_ref.extractall("temp/updater/{}".format(latest_rls['tag_name']))
+
+    # 覆盖源码
+    source_root = ""
+    # 找到temp/updater/<tag_name>/中的第一个子目录路径
+    for root, dirs, files in os.walk("temp/updater/{}".format(latest_rls['tag_name'])):
+        if root != "temp/updater/{}".format(latest_rls['tag_name']):
+            source_root = root
+            break
+
+    # 覆盖源码
+    import shutil
+    for root, dirs, files in os.walk(source_root):
+        # 覆盖所有子文件子目录
+        for file in files:
+            src = os.path.join(root, file)
+            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写入文件
+    current_tag = latest_rls['tag_name']
+    with open("current_tag", "w") as f:
+        f.write(current_tag)
+
+    # 通知管理员
+    if not cli:
+        import pkg.utils.context
+        pkg.utils.context.get_qqbot_manager().notify_admin("已更新到最新版本: {}\n更新日志:\n{}\n新功能通常可以在config-template.py中看到，完整的更新日志请前往 https://github.com/RockChinQ/QChatGPT/releases 查看".format(current_tag, "\n".join(rls_notes)))
+    else:
+        print("已更新到最新版本: {}\n更新日志:\n{}\n新功能通常可以在config-template.py中看到，完整的更新日志请前往 https://github.com/RockChinQ/QChatGPT/releases 查看".format(current_tag, "\n".join(rls_notes)))
+    return True
+
+
+def is_repo(path: str) -> bool:
+    """检查是否是git仓库"""
+    check_dulwich_closure()
+
+    from dulwich import porcelain
     try:
-        from dulwich import porcelain
-        repo = porcelain.open_repo('.')
-        porcelain.pull(repo)
-    except ModuleNotFoundError:
-        raise Exception("dulwich模块未安装,请查看 https://github.com/RockChinQ/QChatGPT/issues/77")
-    except dulwich.porcelain.DivergedBranches:
-        raise Exception("分支不一致,自动更新仅支持master分支,请手动更新(https://github.com/RockChinQ/QChatGPT/issues/76)")
+        porcelain.open_repo(path)
+        return True
+    except:
+        return False
+
+
+def get_remote_url(repo_path: str) -> str:
+    """获取远程仓库地址"""
+    check_dulwich_closure()
+
+    from dulwich import porcelain
+    repo = porcelain.open_repo(repo_path)
+    return str(porcelain.get_remote_repo(repo, "origin")[1])
+
+
+def get_current_version_info() -> str:
+    """获取当前版本信息"""
+    rls_list = get_release_list()
+    current_tag = get_current_tag()
+    for rls in rls_list:
+        if rls['tag_name'] == current_tag:
+            return rls['name'] + "\n" + rls['body']
+    return "未知版本"
+
+
+def get_commit_id_and_time_and_msg() -> str:
+    """获取当前提交id和时间和提交信息"""
+    check_dulwich_closure()
+
+    from dulwich import porcelain
+
+    repo = porcelain.open_repo('.')
+
+    for entry in repo.get_walker():
+        tz = datetime.timezone(datetime.timedelta(hours=entry.commit.commit_timezone // 3600))
+        dt = datetime.datetime.fromtimestamp(entry.commit.commit_time, tz)
+        return str(entry.commit.id)[2:9] + " " + dt.strftime('%Y-%m-%d %H:%M:%S') + " [" + str(entry.commit.message, encoding="utf-8").strip()+"]"
+
+
+def get_current_commit_id() -> str:
+    """检查是否有新版本"""
+    check_dulwich_closure()
+
+    from dulwich import porcelain
+
+    repo = porcelain.open_repo('.')
+    current_commit_id = ""
+    for entry in repo.get_walker():
+        current_commit_id = str(entry.commit.id)[2:-1]
+        break
+
+    return current_commit_id
+
+
+def is_new_version_available() -> bool:
+    """检查是否有新版本"""
+    # 从github获取release列表
+    rls_list = get_release_list()
+    if rls_list is None:
+        return False
+
+    # 获取当前版本
+    current_tag = get_current_tag()
+
+    # 检查是否有新版本
+    for rls in rls_list:
+        if rls['tag_name'] == current_tag:
+            return False
+        else:
+            return True
+
+
+def get_rls_notes() -> list:
+    """获取更新日志"""
+    # 从github获取release列表
+    rls_list = get_release_list()
+    if rls_list is None:
+        return None
+
+    # 获取当前版本
+    current_tag = get_current_tag()
+
+    # 检查是否有新版本
+    rls_notes = []
+    for rls in rls_list:
+        if rls['tag_name'] == current_tag:
+            break
+
+        rls_notes.append(rls['name'])
+
+    return rls_notes
+
+
+if __name__ == "__main__":
+    update_all()

requirements.txt

@@ -0,0 +1,9 @@
+requests~=2.28.1
+openai~=0.27.2
+dulwich~=0.21.3
+colorlog~=6.6.0
+yiri-mirai~=0.2.6.1
+websockets~=10.4
+urllib3~=1.26.10
+func_timeout~=4.3.5
+Pillow

res/announcement

@@ -0,0 +1 @@
+2023/3/31 21:35 【插件兼容性问题】若您使用了revLibs插件，并将主程序升级到了v2.3.0，请立即使用管理员账号向机器人账号发送!plugin update命令更新逆向库插件，以解决由于情景预设重构引起的兼容性问题。

scenario/default-template.json

@@ -0,0 +1,12 @@
+{
+    "prompt": [
+        {
+            "role": "system",
+            "content": "You are a helpful assistant. 如果我需要帮助，你要说“输入!help获得帮助”"
+        },
+        {
+            "role": "assistant",
+            "content": "好的，我是一个能干的AI助手。 如果你需要帮助，我会说“输入!help获得帮助”"
+        }
+    ]
+}

sensitive-template.json

@@ -1,4 +1,7 @@
 {
+  "说明": "mask将替换敏感词中的每一个字，若mask_word值不为空，则将敏感词整个替换为mask_word的值",
+  "mask": "*",
+  "mask_word": "",
   "words": [
     "习近平",
     "胡锦涛",
@@ -9,6 +12,7 @@
     "毛泽东",
     "邓小平",
     "周恩来",
+    "马克思",
     "社会主义",
     "共产党",
     "共产主义",
@@ -21,6 +25,8 @@
     "天安门",
     "六四",
     "政治局常委",
+    "两会",
+    "共青团",
     "学潮",
     "八九",
     "二十大",
@@ -48,6 +54,7 @@
     "作爱",
     "做爱",
     "性交",
+    "性爱",
     "自慰",
     "阴茎",
     "淫妇",

tests/compatibility_tests/models_and_interfaces.py

@@ -0,0 +1,46 @@
+import openai
+import time
+
+# 测试completion api
+models = [
+    'gpt-3.5-turbo',
+    'gpt-3.5-turbo-0301',
+    'text-davinci-003',
+    'text-davinci-002',
+    'code-davinci-002',
+    'code-cushman-001',
+    'text-curie-001',
+    'text-babbage-001',
+    'text-ada-001',
+]
+
+openai.api_key = "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"
+
+for model in models:
+    print('Testing model: ', model)
+
+    # completion api
+    try:
+        response = openai.Completion.create(
+                        model=model,
+                        prompt="Say this is a test",
+                        max_tokens=7,
+                        temperature=0
+                    )
+        print('    completion api: ', response['choices'][0]['text'].strip())
+    except Exception as e:
+        print('    completion api err: ', e)
+
+    # chat completion api
+    try:
+        completion = openai.ChatCompletion.create(
+                        model="gpt-3.5-turbo",
+                        messages=[
+                            {"role": "user", "content": "Hello!"}
+                        ]
+                    )
+        print("    chat api: ",completion.choices[0].message['content'].strip())
+    except Exception as e:
+        print('    chat api err: ', e)
+
+    time.sleep(60)

tests/plugin_examples/__init__.py

@@ -0,0 +1,3 @@
+# 插件示例
+# 将此目录下的目录放入plugins目录即可使用
+# 每个示例插件的功能请查看其包内的__init__.py或README.md

tests/plugin_examples/auto_approval/main.py

@@ -0,0 +1,44 @@
+from mirai import Mirai
+
+import pkg.qqbot.manager
+from pkg.plugin.models import *
+from pkg.plugin.host import PluginHost
+
+from mirai.models import MemberJoinRequestEvent
+
+"""
+加群自动审批
+"""
+
+__group_id__ = 1025599757
+__application_contains__ = ['github', 'gitee', 'Github', 'Gitee', 'GitHub']
+
+
+# 注册插件
+@register(name="加群审批", description="自动审批加群申请", version="0.1", author="RockChinQ")
+class AutoApproval(Plugin):
+
+    bot: Mirai = None
+
+    # 插件加载时触发
+    def __init__(self, plugin_host: PluginHost):
+        qqmgr = plugin_host.get_runtime_context().get_qqbot_manager()
+        assert isinstance(qqmgr, pkg.qqbot.manager.QQBotManager)
+        self.bot = qqmgr.bot
+
+        # 向YiriMirai注册 加群申请 事件处理函数
+        @qqmgr.bot.on(MemberJoinRequestEvent)
+        async def process(event: MemberJoinRequestEvent):
+            assert isinstance(qqmgr, pkg.qqbot.manager.QQBotManager)
+            if event.group_id == __group_id__:
+                if any([x in event.message for x in __application_contains__]):
+                    logging.info("自动同意加群申请")
+                    await qqmgr.bot.allow(event)
+
+        self.process = process
+
+    # 插件卸载时触发
+    def __del__(self):
+        # 关闭时向YiriMirai注销 加群申请 事件处理函数
+        if self.bot is not None:
+            self.bot.bus.unsubscribe(MemberJoinRequestEvent, self.process)

tests/plugin_examples/cmdcn/cmdcn.py

@@ -0,0 +1,51 @@
+from pkg.plugin.models import *
+from pkg.plugin.host import EventContext, PluginHost
+
+"""
+基本命令的中文形式支持
+"""
+
+
+__mapping__ = {
+    "帮助": "help",
+    "重置": "reset",
+    "前一次": "last",
+    "后一次": "next",
+    "会话内容": "prompt",
+    "列出会话": "list",
+    "重新回答": "resend",
+    "使用量": "usage",
+    "绘画": "draw",
+    "版本": "version",
+    "热重载": "reload",
+    "热更新": "update",
+    "配置": "cfg",
+}
+
+
+@register(name="CmdCN", description="命令中文支持", version="0.1", author="RockChinQ")
+class CmdCnPlugin(Plugin):
+
+    def __init__(self, plugin_host: PluginHost):
+        pass
+
+    # 私聊发送指令
+    @on(PersonCommandSent)
+    def person_command_sent(self, event: EventContext, **kwargs):
+        cmd = kwargs['command']
+        if cmd in __mapping__:
+
+            # 返回替换后的指令
+            event.add_return("alter", "!"+__mapping__[cmd]+" "+" ".join(kwargs['params']))
+
+    # 群聊发送指令
+    @on(GroupCommandSent)
+    def group_command_sent(self, event: EventContext, **kwargs):
+        cmd = kwargs['command']
+        if cmd in __mapping__:
+
+            # 返回替换后的指令
+            event.add_return("alter", "!"+__mapping__[cmd]+" "+" ".join(kwargs['params']))
+
+    def __del__(self):
+        pass

tests/plugin_examples/hello_plugin/main.py

@@ -0,0 +1,50 @@
+from pkg.plugin.models import *
+from pkg.plugin.host import EventContext, PluginHost
+
+"""
+在收到私聊或群聊消息"hello"时，回复"hello, <发送者id>!"或"hello, everyone!"
+"""
+
+
+# 注册插件
+@register(name="Hello", description="hello world", version="0.1", author="RockChinQ")
+class HelloPlugin(Plugin):
+
+    # 插件加载时触发
+    # plugin_host (pkg.plugin.host.PluginHost) 提供了与主程序交互的一些方法，详细请查看其源码
+    def __init__(self, plugin_host: PluginHost):
+        pass
+
+    # 当收到个人消息时触发
+    @on(PersonNormalMessageReceived)
+    def person_normal_message_received(self, event: EventContext, **kwargs):
+        msg = kwargs['text_message']
+        if msg == "hello":  # 如果消息为hello
+
+            # 输出调试信息
+            logging.debug("hello, {}".format(kwargs['sender_id']))
+
+            # 回复消息 "hello, <发送者id>!"
+            event.add_return("reply", ["hello, {}!".format(kwargs['sender_id'])])
+
+            # 阻止该事件默认行为（向接口获取回复）
+            event.prevent_default()
+
+    # 当收到群消息时触发
+    @on(GroupNormalMessageReceived)
+    def group_normal_message_received(self, event: EventContext, **kwargs):
+        msg = kwargs['text_message']
+        if msg == "hello":  # 如果消息为hello
+
+            # 输出调试信息
+            logging.debug("hello, {}".format(kwargs['sender_id']))
+
+            # 回复消息 "hello, everyone!"
+            event.add_return("reply", ["hello, everyone!"])
+
+            # 阻止该事件默认行为（向接口获取回复）
+            event.prevent_default()
+
+    # 插件卸载时触发
+    def __del__(self):
+        pass