ci: fix

CI: 构建arm64镜像

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -0,0 +1,64 @@
+name: 漏洞反馈
+description: 报错或漏洞请使用这个模板创建，不使用此模板创建的异常、漏洞相关issue将被直接关闭
+title: "[Bug]: "
+labels: ["bug?"]
+body:
+  - type: dropdown
+    attributes:
+      label: 部署方式
+      description: "主程序使用的部署方式"
+      options:
+        - 手动部署
+        - 安装器部署
+        - 一键安装包部署
+        - Docker部署
+    validations:
+      required: true
+  - type: dropdown
+    attributes:
+      label: 登录框架
+      description: "连接QQ使用的框架"
+      options:
+        - Mirai
+        - go-cqhttp
+    validations:
+      required: false
+  - 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: input
+    attributes:
+      label: QChatGPT版本
+      description: QChatGPT版本号
+      placeholder: 例如： v2.6.0，可以使用`!version`命令查看
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 异常情况
+      description: 完整描述异常情况，什么时候发生的、发生了什么，尽可能详细
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 日志信息
+      description: 请提供完整的 **登录框架 和 QChatGPT控制台**的相关日志信息（若有），不提供日志信息**无法**为您排查问题，请尽可能详细
+    validations:
+      required: false
+  - type: textarea
+    attributes:
+      label: 启用的插件
+      description: 有些情况可能和插件功能有关，建议提供插件启用情况。可以使用`!plugin`命令查看已启用的插件
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/feature-request.yml

@@ -0,0 +1,21 @@
+name: 需求建议
+title: "[Feature]: "
+labels: ["改进"]
+description: "新功能或现有功能优化请使用这个模板；不符合类别的issue将被直接关闭"
+body:
+  - type: dropdown
+    attributes:
+      label: 这是一个？
+      description: 新功能建议还是现有功能优化
+      options:
+        - 新功能
+        - 现有功能优化
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 详细描述
+      description: 详细描述，越详细越好
+    validations:
+      required: true
+      

.github/ISSUE_TEMPLATE/submit-plugin.yml

@@ -0,0 +1,24 @@
+name: 提交新插件
+title: "[Plugin]: 请求登记新插件"
+labels: ["独立插件"]
+description: "本模板供且仅供提交新插件使用"
+body:
+  - type: input
+    attributes:
+      label: 插件名称
+      description: 填写插件的名称
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 插件代码库地址
+      description: 仅支持 Github
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 插件简介
+      description: 插件的简介
+    validations:
+      required: true
+      

.github/ISSUE_TEMPLATE/漏洞反馈.md

@@ -1,24 +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

@@ -10,6 +10,5 @@ updates:
     schedule:
       interval: "weekly"
     allow:
-      - dependency-name: "yiri-mirai"
+      - dependency-name: "yiri-mirai-rc"
-      - dependency-name: "dulwich"
       - dependency-name: "openai"

.github/pull_request_template.md

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

.github/workflows/build-docker-image.yml

@@ -0,0 +1,48 @@
+name: Build Docker Image
+on:
+  #防止fork乱用action设置只能手动触发构建
+  workflow_dispatch:
+  ## 发布release的时候会自动构建
+  release:
+    types: [published]
+jobs:
+  publish-docker-image:
+    runs-on: ubuntu-latest
+    name: Build image
+    
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: judge has env GITHUB_REF  # 如果没有GITHUB_REF环境变量，则把github.ref变量赋值给GITHUB_REF
+        run: |
+          if [ -z "$GITHUB_REF" ]; then
+            export GITHUB_REF=${{ github.ref }}
+            echo $GITHUB_REF
+          fi
+      # - name: Check GITHUB_REF env
+      #   run: echo $GITHUB_REF
+      # - name: Get version  # 在 GitHub Actions 运行环境
+      #   id: get_version
+      #   if: (startsWith(env.GITHUB_REF, 'refs/tags/')||startsWith(github.ref, 'refs/tags/')) && startsWith(github.repository, 'RockChinQ/QChatGPT')
+      #   run: export GITHUB_REF=${GITHUB_REF/refs\/tags\//}
+      - name: Check version
+        id: check_version
+        run: |
+          echo $GITHUB_REF
+          # 如果是tag，则去掉refs/tags/前缀
+          if [[ $GITHUB_REF == refs/tags/* ]]; then
+            echo "It's a tag"
+            echo $GITHUB_REF
+            echo $GITHUB_REF | awk -F '/' '{print $3}'
+            echo ::set-output name=version::$(echo $GITHUB_REF | awk -F '/' '{print $3}')
+          else
+            echo "It's not a tag"
+            echo $GITHUB_REF
+            echo ::set-output name=version::${GITHUB_REF}
+          fi
+      - name: Login to Registry
+        run: docker login --username=${{ secrets.DOCKER_USERNAME }} --password ${{ secrets.DOCKER_PASSWORD }}
+      - name: Create Buildx
+        run: docker buildx create --name mybuilder --use
+      - name: Build  # image name: rockchin/qchatgpt:<VERSION>
+        run: docker buildx build --platform linux/arm64,linux/amd64 -t rockchin/qchatgpt:${{ steps.check_version.outputs.version }} -t rockchin/qchatgpt:latest . --push

.github/workflows/sync-wiki.yml

@@ -0,0 +1,43 @@
+name: Update Wiki
+
+on:
+  push:
+    branches:
+      - master
+    paths:
+      - 'res/wiki/**'
+
+jobs:
+  update-wiki:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+    - name: Setup Git
+      run: |
+        git config --global user.name "GitHub Actions"
+        git config --global user.email "github-actions[bot]@users.noreply.github.com"
+    - name: Clone Wiki Repository
+      uses: actions/checkout@v2
+      with:
+        repository: RockChinQ/QChatGPT.wiki
+        path: wiki
+    - name: Delete old wiki content
+      run: |
+        rm -rf wiki/*
+    - name: Copy res/wiki content to wiki
+      run: |
+        cp -r res/wiki/* wiki/
+    - name: Check for changes
+      run: |
+        cd wiki
+        if git diff --quiet; then
+          echo "No changes to commit."
+          exit 0
+        fi
+    - name: Commit and Push Changes
+      run: |
+        cd wiki
+        git add .
+        git commit -m "Update wiki"
+        git push

.github/workflows/test-pr.yml

@@ -0,0 +1,80 @@
+name: Test Pull Request
+
+on:
+  pull_request:
+    types: [ready_for_review]
+    paths:
+      # 任何py文件改动都会触发
+      - '**.py'
+  pull_request_review:
+    types: [submitted]
+  issue_comment:
+    types: [created]
+  # 允许手动触发
+  workflow_dispatch:
+
+jobs:
+  perform-test:
+    runs-on: ubuntu-latest
+    # 如果事件为pull_request_review且review状态为approved，则执行
+    if: >
+      github.event_name == 'pull_request' ||
+      (github.event_name == 'pull_request_review' && github.event.review.state == 'APPROVED') ||
+      github.event_name == 'workflow_dispatch' ||
+      (github.event_name == 'issue_comment' && github.event.issue.pull_request != '' && contains(github.event.comment.body, '/test') && github.event.comment.user.login == 'RockChinQ')
+    steps:
+      # 签出测试工程仓库代码
+      - name: Checkout
+        uses: actions/checkout@v2
+        with:
+          # 仓库地址
+          repository: RockChinQ/qcg-tester
+          # 仓库路径
+          path: qcg-tester
+      - name: Setup Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: '3.10'
+
+      - name: Install dependencies
+        run: |
+          cd qcg-tester
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+
+      - name: Get PR details
+        id: get-pr
+        if: github.event_name == 'issue_comment'
+        uses: octokit/request-action@v2.x
+        with:
+          route: GET /repos/${{ github.repository }}/pulls/${{ github.event.issue.number }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Set PR source branch as env variable
+        if: github.event_name == 'issue_comment'
+        run: |
+          PR_SOURCE_BRANCH=$(echo '${{ steps.get-pr.outputs.data }}' | jq -r '.head.ref')
+          echo "BRANCH=$PR_SOURCE_BRANCH" >> $GITHUB_ENV
+
+      - name: Set PR Branch as bash env
+        if: github.event_name != 'issue_comment'
+        run: |
+          echo "BRANCH=${{ github.head_ref }}" >> $GITHUB_ENV
+      - name: Set OpenAI API Key from Secrets
+        run: |
+          echo "OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY }}" >> $GITHUB_ENV
+      - name: Set OpenAI Reverse Proxy URL from Secrets
+        run: |
+          echo "OPENAI_REVERSE_PROXY=${{ secrets.OPENAI_REVERSE_PROXY }}" >> $GITHUB_ENV
+      - name: Run test
+        run: |
+          cd qcg-tester
+          python main.py
+
+      - name: Upload coverage reports to Codecov
+        run: |
+          cd qcg-tester/resource/QChatGPT
+          curl -Os https://uploader.codecov.io/latest/linux/codecov
+          chmod +x codecov
+          ./codecov -t ${{ secrets.CODECOV_TOKEN }}

.gitignore

@@ -1,4 +1,4 @@
-config.py
+/config.py
 .idea/
 __pycache__/
 database.db
@@ -12,3 +12,26 @@ logs/
 sensitive.json
 temp/
 current_tag
+scenario/
+!scenario/default-template.json
+override.json
+cookies.json
+res/announcement_saved
+res/announcement_saved.json
+cmdpriv.json
+tips.py
+.venv
+bin/
+.vscode
+test_*
+venv/
+hugchat.json
+qcapi
+claude.json
+bard.json
+/*yaml
+!/docker-compose.yaml
+res/instance_id.json
+.DS_Store
+/data
+botpy.log

CONTRIBUTING.md

@@ -17,3 +17,10 @@
 - 解决本项目或衍生项目的issues中亟待解决的问题
 - 阅读并完善本项目文档
 - 在各个社交媒体撰写本项目教程等
+
+### 代码规范
+
+- 代码中的注解`务必`符合Google风格的规范
+- 模块顶部的引入代码请遵循`系统模块`、`第三方库模块`、`自定义模块`的顺序进行引入
+- `不要`直接引入模块的特定属性，而是引入这个模块，再通过`xxx.yyy`的形式使用属性
+- 任何作用域的字段`必须`先声明后使用，并在声明处注明类型提示

Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.10.13-slim
+WORKDIR /app
+
+COPY . .
+
+RUN apt update \
+    && apt install gcc -y \
+    && python -m pip install -r requirements.txt  
+                        
+CMD [ "python", "main.py" ]

README.md

@@ -1,235 +1,49 @@
-# QChatGPT🤖
-> 2023/3/3  官方接口疑似被墙，可考虑使用网络代理 [#198](https://github.com/RockChinQ/QChatGPT/issues/198)  
-> 2023/3/3  现已在主线支持官方ChatGPT接口，使用方法查看[#195](https://github.com/RockChinQ/QChatGPT/issues/195)  
-> 2023/3/2  OpenAI已发布ChatGPT官方接口，我们正在全力接入，预计明日前完成，请查看[此PR](https://github.com/RockChinQ/QChatGPT/pull/194)  
-> 2023/2/16 现已支持接入ChatGPT网页版，详情请完成部署并查看底部**插件**小节或[此仓库](https://github.com/RockChinQ/revLibs)
 
-- 到[项目Wiki](https://github.com/RockChinQ/QChatGPT/wiki)可了解项目详细信息
+<p align="center">
-- 由bilibili TheLazy制作的[视频教程](https://www.bilibili.com/video/BV15v4y1X7aP)
+<img src="https://qchatgpt.rockchin.top/logo.png" alt="QChatGPT" width="180" />
-- 交流、答疑群: ~~204785790~~（已满）、691226829、656285629  
+</p>
-  - **进群提问前请您`确保`已经找遍文档和issue均无法解决**  
+
-- QQ频道机器人见[QQChannelChatGPT](https://github.com/Soulter/QQChannelChatGPT)
+<div align="center">
-
+
-通过调用OpenAI的ChatGPT等语言模型来实现一个更加智能的QQ机器人  
+# QChatGPT
-
+
-## 🍺模型适配一览
+[![GitHub release (latest by date)](https://img.shields.io/github/v/release/RockChinQ/QChatGPT)](https://github.com/RockChinQ/QChatGPT/releases/latest)
-
+<a href="https://hub.docker.com/repository/docker/rockchin/qchatgpt">
-### 文字对话
+    <img src="https://img.shields.io/docker/pulls/rockchin/qchatgpt?color=blue" alt="docker pull">
-
+  </a>
-- OpenAI GPT-3.5模型(ChatGPT API), 本项目原生支持, 默认使用
+![Wakapi Count](https://wakapi.dev/api/badge/RockChinQ/interval:any/project:QChatGPT)
-- OpenAI GPT-3模型, 本项目原生支持, 部署完成后前往config.py切换
+<a href="https://codecov.io/gh/RockChinQ/QChatGPT" > 
-- ChatGPT网页版逆向API, 由[插件](https://github.com/RockChinQ/revLibs)接入
+ <img src="https://codecov.io/gh/RockChinQ/QChatGPT/graph/badge.svg?token=pjxYIL2kbC"/> 
-
+ </a>
-### 故事续写
+<br/>
-
+<img src="https://img.shields.io/badge/python-3.9 | 3.10 | 3.11-blue.svg" alt="python">
-- NovelAI API, 由[插件](https://github.com/dominoar/QCPNovelAi)接入
+<a href="http://qm.qq.com/cgi-bin/qm/qr?_wv=1027&k=66-aWvn8cbP4c1ut_1YYkvvGVeEtyTH8&authKey=pTaKBK5C%2B8dFzQ4XlENf6MHTCLaHnlKcCRx7c14EeVVlpX2nRSaS8lJm8YeM4mCU&noverify=0&group_code=195992197">
-
+<img alt="Static Badge" src="https://img.shields.io/badge/%E5%AE%98%E6%96%B9%E7%BE%A4-195992197-purple">
-### 图片绘制
+</a>
-
+<a href="http://qm.qq.com/cgi-bin/qm/qr?_wv=1027&k=nC80H57wmKPwRDLFeQrDDjVl81XuC21P&authKey=2wTUTfoQ5v%2BD4C5zfpuR%2BSPMDqdXgDXA%2FS2wHI1NxTfWIG%2B%2FqK08dgyjMMOzhXa9&noverify=0&group_code=248432104">
-- 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)
+<img alt="Static Badge" src="https://img.shields.io/badge/%E7%A4%BE%E5%8C%BA%E7%BE%A4-248432104-purple">
-- NovelAI API, 由[插件](https://github.com/dominoar/QCPNovelAi)接入
+</a>
-
+<a href="https://www.bilibili.com/video/BV14h4y1w7TC">
-### 语音生成
+<img alt="Static Badge" src="https://img.shields.io/badge/%E8%A7%86%E9%A2%91%E6%95%99%E7%A8%8B-208647">
-
+</a>
-- TTS+VITS, 由[插件](https://github.com/dominoar/QChatPlugins)接入
+<a href="https://www.bilibili.com/video/BV11h4y1y74H">
-
+<img alt="Static Badge" src="https://img.shields.io/badge/Linux%E9%83%A8%E7%BD%B2%E8%A7%86%E9%A2%91-208647">
-## ✅功能
+</a>
-
+
-<details>
+## 使用文档
-<summary>✅支持敏感词过滤，避免账号风险</summary>
+
-
+<a href="https://qchatgpt.rockchin.top">项目主页</a> ｜
-  - 难以监测机器人与用户对话时的内容，故引入此功能以减少机器人风险
+<a href="https://qchatgpt.rockchin.top/posts/feature.html">功能介绍</a> ｜
-  - 加入了百度云内容审核，在`config.py`中修改`baidu_check`的值，并填写`baidu_api_key`和`baidu_secret_key`以开启此功能
+<a href="https://qchatgpt.rockchin.top/posts/deploy/">部署文档</a> ｜
-  - 编辑`sensitive.json`，并在`config.py`中修改`sensitive_word_filter`的值以开启此功能
+<a href="https://qchatgpt.rockchin.top/posts/error/">常见问题</a> ｜
-</details>
+<a href="https://qchatgpt.rockchin.top/posts/plugin/intro.html">插件介绍</a> ｜
-
+<a href="https://github.com/RockChinQ/QChatGPT/issues/new?assignees=&labels=%E7%8B%AC%E7%AB%8B%E6%8F%92%E4%BB%B6&projects=&template=submit-plugin.yml&title=%5BPlugin%5D%3A+%E8%AF%B7%E6%B1%82%E7%99%BB%E8%AE%B0%E6%96%B0%E6%8F%92%E4%BB%B6">提交插件</a>
-<details>
+
-<summary>✅群内多种响应规则，不必at</summary>
+## 相关链接
-
+
-  - 默认回复`ai`作为前缀或`@`机器人的消息
+<a href="https://github.com/RockChinQ/qcg-installer">安装器源码</a> ｜
-  - 详细见`config.py`中的`response_rules`字段
+<a href="https://github.com/RockChinQ/qcg-tester">测试工程源码</a> ｜
-</details>
+<a href="https://github.com/the-lazy-me/QChatGPT-Wiki">官方文档储存库</a>
-
+
-<details>
+<img alt="回复效果（带有联网插件）" src="https://qchatgpt.rockchin.top/assets/image/QChatGPT-1211.png" width="500px"/>
-<summary>✅完善的多api-key管理，超额自动切换</summary>
+</div>
-
-  - 支持配置多个`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>
-
-详情请查看[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里进行搜索**
-
-### - 注册OpenAI账号
-
-**可以直接进群找群主购买**  
-或参考以下文章自行注册
-
-> ~~[只需 1 元搞定 ChatGPT 注册](https://zhuanlan.zhihu.com/p/589470082)~~（已失效）  
-> [手把手教你如何注册ChatGPT，超级详细](https://guxiaobei.com/51461)
-
-注册成功后请前往[个人中心查看](https://beta.openai.com/account/api-keys)api_key  
-完成注册后，使用以下自动化或手动部署步骤
-
-### - 自动化部署
-
-<details>
-<summary>展开查看，以下方式二选一，Linux首选Docker，Windows首选安装器</summary>
-
-#### Docker方式
-
-请查看此仓库[mikumifa/QChatGPT-Docker-Installer](https://github.com/mikumifa/QChatGPT-Docker-Installer)
-
-#### 安装器方式
-使用[此安装器](https://github.com/RockChinQ/qcg-installer)（若无法访问请到[Gitee](https://gitee.com/RockChin/qcg-installer)）进行部署
-
-- 安装器目前仅支持部分平台，请到仓库文档查看，其他平台请手动部署
-
-</details>
-
-### - 手动部署
-<details>
-<summary>手动部署适用于所有平台</summary>
-
-- 请使用Python 3.9.x以上版本   
-
-#### 配置Mirai
-
-按照[此教程](https://yiri-mirai.wybxc.cc/tutorials/01/configuration)配置Mirai及YiriMirai  
-启动mirai-console后，使用`login`命令登录QQ账号，保持mirai-console运行状态
-
-#### 配置主程序
-
-1. 克隆此项目
-
-```bash
-git clone https://github.com/RockChinQ/QChatGPT
-cd QChatGPT
-```
-
-2. 安装依赖
-
-```bash
-pip3 install yiri-mirai openai colorlog func_timeout
-pip3 install dulwich
-```
-
-3. 运行一次主程序，生成配置文件
-
-```bash
-python3 main.py
-```
-
-4. 编辑配置文件`config.py`
-
-按照文件内注释填写配置信息
-
-5. 运行主程序
-
-```bash
-python3 main.py
-```
-
-无报错信息即为运行成功
-
-**常见问题**
-
-- 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)
-
-## 🧩插件生态
-
-现已支持自行开发插件对功能进行扩展或自定义程序行为  
-详见[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)
-
-### 示例插件
-
-在`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 故事叙述与绘画
-
-## 😘致谢
-
-- [@the-lazy-me](https://github.com/the-lazy-me) 为本项目制作[视频教程](https://www.bilibili.com/video/BV15v4y1X7aP)
-- [@mikumifa](https://github.com/mikumifa) 本项目Docker部署仓库开发者
-- [@dominoar](https://github.com/dominoar) 为本项目开发多种插件
-- [@hissincn](https://github.com/hissincn) 本项目贡献者
-- [@LINSTCL](https://github.com/LINSTCL)   GPT-3.5官方模型适配贡献者
-
-以及其他所有为本项目提供支持的朋友们。
-
-## 👍赞赏
-
-<img alt="赞赏码" src="res/mm_reward_qrcode_1672840549070.png" width="400" height="400"/>

banlist-template.py

@@ -1,20 +0,0 @@
-# 是否启用禁用列表
-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]  # 本项目交流群的群号，默认屏蔽，避免在交流群测试机器人

config-template.py

@@ -1,245 +0,0 @@
-# 配置文件: 注释里标[必需]的参数必须修改, 其他参数根据需要修改, 但请勿删除
-import logging
-
-# [必需] Mirai的配置
-# 请到配置mirai的步骤中的教程查看每个字段的信息
-# adapter: 选择适配器，目前支持HTTPAdapter和WebSocketAdapter
-# host: 运行mirai的主机地址
-# port: 运行mirai的主机端口
-# verifyKey: mirai-api-http的verifyKey
-# qq: 机器人的QQ号
-#
-# 注意: QQ机器人配置不支持热重载及热更新
-mirai_http_api_config = {
-    "adapter": "WebSocketAdapter",
-    "host": "localhost",
-    "port": 8080,
-    "verifyKey": "yirimirai",
-    "qq": 1234567890
-}
-
-# [必需] OpenAI的配置
-# api_key: OpenAI的API Key
-# http_proxy: 请求OpenAI时使用的代理，None为不使用，https和socks5暂不能使用
-# 若只有一个api-key，请直接修改以下内容中的"openai_api_key"为你的api-key
-#
-# 如准备了多个api-key，可以以字典的形式填写，程序会自动选择可用的api-key
-# 例如
-# openai_config = {
-#     "api_key": {
-#         "default": "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
-#         "key1": "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
-#         "key2": "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
-#     },
-#     "http_proxy": "http://127.0.0.1:12345"
-# }
-openai_config = {
-    "api_key": {
-        "default": "openai_api_key"
-    },
-    "http_proxy": None
-}
-
-# [必需] 管理员QQ号，用于接收报错等通知及执行管理员级别指令
-# 支持多个管理员，可以使用list形式设置，例如：
-# admin_qq = [12345678, 87654321]
-admin_qq = 0
-
-# 情景预设（机器人人格）
-# 每个会话的预设信息，影响所有会话，无视指令重置
-# 可以通过这个字段指定某些情况的回复，可直接用自然语言描述指令
-# 例如: 
-# default_prompt = "如果我之后想获取帮助，请你说“输入!help获取帮助”"
-#   这样用户在不知所措的时候机器人就会提示其输入!help获取帮助
-# 可参考 https://github.com/PlexPt/awesome-chatgpt-prompts-zh
-#
-# 如果需要多个情景预设，并在运行期间方便切换，请使用字典的形式填写，例如
-# 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获取帮助”",
-}
-
-# 群内响应规则
-# 符合此消息的群内消息即使不包含at机器人也会响应
-# 支持消息前缀匹配及正则表达式匹配
-# 注意：由消息前缀(prefix)匹配的消息中将会删除此前缀，正则表达式(regexp)匹配的消息不会删除匹配的部分
-#      前缀匹配优先级高于正则表达式匹配
-# 正则表达式简明教程：https://www.runoob.com/regexp/regexp-tutorial.html
-response_rules = {
-    "prefix": ["/ai", "!ai", "！ai", "ai"],
-    "regexp": []  # "为什么.*", "怎么?样.*", "怎么.*", "如何.*", "[Hh]ow to.*", "[Ww]hy not.*", "[Ww]hat is.*", ".*怎么办", ".*咋办"
-}
-
-# 消息忽略规则
-# 适用于私聊及群聊
-# 符合此规则的消息将不会被响应
-# 支持消息前缀匹配及正则表达式匹配
-# 此设置优先级高于response_rules
-# 用以过滤mirai等其他层级的指令
-# @see https://github.com/RockChinQ/QChatGPT/issues/165
-ignore_rules = {
-    "prefix": ["/"],
-    "regexp": []
-}
-
-# 是否检查收到的消息中是否包含敏感词
-# 若收到的消息无法通过下方指定的敏感词检查策略，则发送提示信息
-income_msg_check = False
-
-# 敏感词过滤开关，以同样数量的*代替敏感词回复
-# 请在sensitive.json中添加敏感词
-sensitive_word_filter = True
-
-# 是否启用百度云内容安全审核
-# 注册方式查看 https://cloud.baidu.com/doc/ANTIPORN/s/Wkhu9d5iy
-baidu_check = False
-
-# 百度云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 = 1024
-
-# OpenAI补全API的参数
-# 请在下方填写模型，程序自动选择接口
-# 现已支持的模型有：
-# 
-#    '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
-completion_api_params = {
-    "model": "gpt-3.5-turbo",
-    "temperature": 0.9,  # 数值越低得到的回答越理性，取值范围[0, 1]
-    "max_tokens": 1024,  # 每次获取OpenAI接口响应的文字量上限, 不高于4096
-    "top_p": 1,  # 生成的文本的文本与要求的符合度, 取值范围[0, 1]
-    "frequency_penalty": 0.2,
-    "presence_penalty": 1.0,
-}
-
-# OpenAI的Image API的参数
-# 具体请查看OpenAI的文档: https://beta.openai.com/docs/api-reference/images/create
-image_api_params = {
-    "size": "256x256",  # 图片尺寸，支持256x256, 512x512, 1024x1024
-}
-
-# 群内回复消息时是否引用原消息
-quote_origin = True
-
-# 回复绘图时是否包含图片描述
-include_image_description = True
-
-# 消息处理的超时时间，单位为秒
-process_message_timeout = 30
-
-# 回复消息时是否显示[GPT]前缀
-show_prefix = False
-
-# 应用长消息处理策略的阈值
-# 当回复消息长度超过此值时，将使用长消息处理策略
-blob_message_threshold = 256
-
-# 长消息处理策略
-# - "image": 将长消息转换为图片发送
-# - "forward": 将长消息转换为转发消息组件发送
-blob_message_strategy = "forward"
-
-# 消息处理超时重试次数
-retry_times = 3
-
-# 消息处理出错时是否向用户隐藏错误详细信息
-# 设置为True时，仅向管理员发送错误详细信息
-# 设置为False时，向用户及管理员发送错误详细信息
-hide_exce_info_to_user = False
-
-# 消息处理出错时向用户发送的提示信息
-# 仅当hide_exce_info_to_user为True时生效
-# 设置为空字符串时，不发送提示信息
-alter_tip_message = '出错了，请稍后再试'
-
-# 每个会话的过期时间，单位为秒
-# 默认值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
-
-# 是否上报统计信息
-# 用于统计机器人的使用情况，不会收集任何用户信息
-# 仅上报时间、字数使用量、绘图使用量，其他信息不会上报
-report_usage = True
-
-# 日志级别
-logging_level = logging.INFO
-
-# 定制帮助消息
-help_message = """此机器人通过调用OpenAI的GPT-3大型语言模型生成回复，不具有情感。
-你可以用自然语言与其交流，回复的消息中[GPT]开头的为模型生成的语言，[bot]开头的为程序提示。
-了解此项目请找QQ 1010553892 联系作者
-请不要用其生成整篇文章或大段代码，因为每次只会向模型提交少部分文字，生成大部分文字会产生偏题、前后矛盾等问题
-每次会话最后一次交互后{}分钟后会自动结束，结束后将开启新会话，如需继续前一次会话请发送 !last 重新开启
-欢迎到github.com/RockChinQ/QChatGPT 给个star
-
-帮助信息：
-!help - 显示帮助
-!reset - 重置会话
-!last - 切换到前一次的对话
-!next - 切换到后一次的对话
-!prompt - 显示当前对话所有内容
-!list - 列出所有历史会话
-!usage - 列出各个api-key的使用量""".format(session_expire_time // 60)

docker-compose.yaml

@@ -0,0 +1,10 @@
+version: "3"
+
+services:
+  qchatgpt:
+    image: rockchin/qchatgpt:latest
+    volumes:
+      - ./data:/app/data
+      - ./plugins:/app/plugins
+    restart: on-failure
+    # 根据具体环境配置网络

main.py

@@ -1,363 +1,18 @@
-import importlib
+import asyncio
-import os
-import shutil
-import threading
-import time
-
-import logging
-import sys
-
-try:
-    import colorlog
-except ImportError:
-    # 尝试安装
-    import pkg.utils.pkgmgr as pkgmgr
-    pkgmgr.install_requirements("requirements.txt")
-    try:
-        import colorlog
-    except ImportError:
-        print("依赖不满足,请查看 https://github.com/RockChinQ/qcg-installer/issues/15")
-        sys.exit(1)
-import colorlog
-
-import requests
-import websockets.exceptions
-from urllib3.exceptions import InsecureRequestWarning
 
 
-sys.path.append(".")
+asciiart = r"""
-
+  ___   ___ _         _    ___ ___ _____ 
-log_colors_config = {
+ / _ \ / __| |_  __ _| |_ / __| _ \_   _|
-    'DEBUG': 'green',  # cyan white
+| (_) | (__| ' \/ _` |  _| (_ |  _/ | |  
-    'INFO': 'white',
+ \__\_\\___|_||_\__,_|\__|\___|_|   |_|  
-    'WARNING': 'yellow',
-    'ERROR': 'red',
-    'CRITICAL': 'bold_red',
-}
-
-
-def init_db():
-    import pkg.database.manager
-    database = pkg.database.manager.DatabaseManager()
-
-    database.initialize_database()
-
-
-def ensure_dependencies():
-    import pkg.utils.pkgmgr as pkgmgr
-    pkgmgr.run_pip(["install", "openai", "Pillow", "--upgrade"])
-
-
-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
-    assert os.path.exists('config.py')
-
-    config = importlib.import_module('config')
-
-    import pkg.utils.context
-
-    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
-
-
-def main(first_time_init=False):
-    global known_exception_caught
-
-    import 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)
-
-        init_runtime_log_file()
-
-        sh = reset_logging()
-
-        # 检查是否设置了管理员
-        if not (hasattr(config, 'admin_qq') and config.admin_qq != 0):
-            # 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
-
-        pkg.openai.dprompt.read_prompt_from_file()
-
-        pkg.utils.context.context['logger_handler'] = sh
-        # 主启动流程
-        database = pkg.database.manager.DatabaseManager()
-
-        database.initialize_database()
-
-        openai_interact = pkg.openai.manager.OpenAIInteract(config.openai_config['api_key'])
-
-        # 加载所有未超时的session
-        pkg.openai.session.load_sessions()
-
-        # 初始化qq机器人
-        qqbot = pkg.qqbot.manager.QQBotManager(mirai_http_api_config=config.mirai_http_api_config,
-                                               timeout=config.process_message_timeout, retry=config.retry_times,
-                                               first_time_init=first_time_init)
-
-        # 加载插件
-        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
-                try:
-                    qqbot.bot.run()
-                except TypeError as e:
-                    if str(e).__contains__("argument 'debug'"):
-                        logging.error(
-                            "连接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))
-                        known_exception_caught = True
-
-                except websockets.exceptions.InvalidStatus as e:
-                    logging.error(
-                        "mirai-api-http端口无法使用:{}, 解决方案: https://github.com/RockChinQ/QChatGPT/issues/22".format(
-                            e))
-                    known_exception_caught = True
-                except mirai.exceptions.NetworkError as e:
-                    logging.error("连接mirai-api-http失败:{}, 请检查是否已按照文档启动mirai".format(e))
-                    known_exception_caught = True
-                except Exception as e:
-                    if str(e).__contains__("404"):
-                        logging.error(
-                            "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/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)
-        if first_time_init:
-            if not known_exception_caught:
-                logging.info('程序启动完成,如长时间未显示 ”成功登录到账号xxxxx“ ,并且不回复消息,请查看 '
-                             'https://github.com/RockChinQ/QChatGPT/issues/37')
-            else:
-                sys.exit(1)
-        else:
-            logging.info('热重载完成')
-
-    # 发送赞赏码
-    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:
-
-        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():
-            pkg.utils.context.get_qqbot_manager().notify_admin("新版本可用，请发送 !update 进行自动更新\n更新日志:\n{}".format("\n".join(pkg.utils.updater.get_rls_notes())))
-        else:
-            logging.info("当前已是最新版本")
-
-    except Exception as e:
-        logging.warning("检查更新失败:{}".format(e))
-
-    while True:
-        try:
-            time.sleep(10)
-            if qqbot != pkg.utils.context.get_qqbot_manager():  # 已经reload了
-                logging.info("以前的main流程由于reload退出")
-                break
-        except KeyboardInterrupt:
-            stop()
-
-            print("程序退出")
-            sys.exit(0)
-
-
-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)
-
-        for session in pkg.openai.session.sessions:
-            logging.info('持久化session: %s', session)
-            pkg.openai.session.sessions[session].persistence()
-        pkg.utils.context.get_database_manager().close()
-    except Exception as e:
-        if not isinstance(e, KeyboardInterrupt):
-            raise e
 
+⭐️开源地址: https://github.com/RockChinQ/QChatGPT
+📖文档地址: https://q.rkcn.top
+"""
 
 if __name__ == '__main__':
-    # 检查是否有config.py,如果没有就把config-template.py复制一份,并退出程序
+    print(asciiart)
-    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复制一份
+    from pkg.core import boot
-    if not os.path.exists('banlist.py'):
+    asyncio.run(boot.main())
-        shutil.copy('banlist-template.py', 'banlist.py')
-
-    # 检查是否有sensitive.json
-    if not os.path.exists("sensitive.json"):
-        shutil.copy("sensitive-template.json", "sensitive.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)
-
-    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:
-            try:
-                import pkg.utils.pkgmgr
-                pkg.utils.pkgmgr.ensure_dulwich()
-            except:
-                pass
-
-            from dulwich import porcelain
-
-            repo = porcelain.open_repo('.')
-            porcelain.pull(repo)
-        except ModuleNotFoundError:
-            print("dulwich模块未安装,请查看 https://github.com/RockChinQ/QChatGPT/issues/77")
-        sys.exit(0)
-
-    # import pkg.utils.configmgr
-    #
-    # pkg.utils.configmgr.set_config_and_reload("quote_origin", False)
-    requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
-
-    main(True)

pkg/audit/__init__.py

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

pkg/audit/center/apigroup.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import abc
+import uuid
+import json
+import logging
+import asyncio
+
+import aiohttp
+import requests
+
+from ...core import app
+
+
+class APIGroup(metaclass=abc.ABCMeta):
+    """API 组抽象类"""
+    _basic_info: dict = None
+    _runtime_info: dict = None
+
+    prefix = None
+
+    ap: app.Application
+
+    def __init__(self, prefix: str, ap: app.Application):
+        self.prefix = prefix
+        self.ap = ap
+
+    async def _do(
+        self,
+        method: str,
+        path: str,
+        data: dict = None,
+        params: dict = None,
+        headers: dict = {},
+        **kwargs
+    ):
+        self._runtime_info['account_id'] = "-1"
+        
+        url = self.prefix + path
+        data = json.dumps(data)
+        headers['Content-Type'] = 'application/json'
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.request(
+                    method,
+                    url,
+                    data=data,
+                    params=params,
+                    headers=headers,
+                    **kwargs
+                ) as resp:
+                    self.ap.logger.debug("data: %s", data)
+                    self.ap.logger.debug("ret: %s", await resp.text())
+
+        except Exception as e:
+            self.ap.logger.debug(f'上报失败: {e}')
+    
+    async def do(
+        self,
+        method: str,
+        path: str,
+        data: dict = None,
+        params: dict = None,
+        headers: dict = {},
+        **kwargs
+    ) -> asyncio.Task:
+        """执行请求"""
+        asyncio.create_task(self._do(method, path, data, params, headers, **kwargs))
+
+    def gen_rid(
+        self
+    ):
+        """生成一个请求 ID"""
+        return str(uuid.uuid4())
+
+    def basic_info(
+        self
+    ):
+        """获取基本信息"""
+        basic_info = APIGroup._basic_info.copy()
+        basic_info['rid'] = self.gen_rid()
+        return basic_info
+    
+    def runtime_info(
+        self
+    ):
+        """获取运行时信息"""
+        return APIGroup._runtime_info

pkg/audit/center/groups/main.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from .. import apigroup
+from ....core import app
+
+
+class V2MainDataAPI(apigroup.APIGroup):
+    """主程序相关 数据API"""
+
+    def __init__(self, prefix: str, ap: app.Application):
+        self.ap = ap
+        super().__init__(prefix+"/main", ap)
+
+    async def do(self, *args, **kwargs):
+        if not self.ap.system_cfg.data['report-usage']:
+            return None
+        return await super().do(*args, **kwargs)
+
+    async def post_update_record(
+        self,
+        spent_seconds: int,
+        infer_reason: str,
+        old_version: str,
+        new_version: str,
+    ):
+        """提交更新记录"""
+        return await self.do(
+            "POST",
+            "/update",
+            data={
+                "basic": self.basic_info(),
+                "update_info": {
+                    "spent_seconds": spent_seconds,
+                    "infer_reason": infer_reason,
+                    "old_version": old_version,
+                    "new_version": new_version,
+                }
+            }
+        )
+    
+    async def post_announcement_showed(
+        self,
+        ids: list[int],
+    ):
+        """提交公告已阅"""
+        return await self.do(
+            "POST",
+            "/announcement",
+            data={
+                "basic": self.basic_info(),
+                "announcement_info": {
+                    "ids": ids,
+                }
+            }
+        )

pkg/audit/center/groups/plugin.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from ....core import app
+from .. import apigroup
+
+
+class V2PluginDataAPI(apigroup.APIGroup):
+    """插件数据相关 API"""
+
+    def __init__(self, prefix: str, ap: app.Application):
+        self.ap = ap
+        super().__init__(prefix+"/plugin", ap)
+
+    async def do(self, *args, **kwargs):
+        if not self.ap.system_cfg.data['report-usage']:
+            return None
+        return await super().do(*args, **kwargs)
+
+    async def post_install_record(
+        self,
+        plugin: dict
+    ):
+        """提交插件安装记录"""
+        return await self.do(
+            "POST",
+            "/install",
+            data={
+                "basic": self.basic_info(),
+                "plugin": plugin,
+            }
+        )
+
+    async def post_remove_record(
+        self,
+        plugin: dict
+    ):
+        """提交插件卸载记录"""
+        return await self.do(
+            "POST",
+            "/remove",
+            data={
+                "basic": self.basic_info(),
+                "plugin": plugin,
+            }
+        )
+
+    async def post_update_record(
+        self,
+        plugin: dict,
+        old_version: str,
+        new_version: str,
+    ):
+        """提交插件更新记录"""
+        return await self.do(
+            "POST",
+            "/update",
+            data={
+                "basic": self.basic_info(),
+                "plugin": plugin,
+                "update_info": {
+                    "old_version": old_version,
+                    "new_version": new_version,
+                }
+            }
+        )

pkg/audit/center/groups/usage.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from .. import apigroup
+from ....core import app
+
+
+class V2UsageDataAPI(apigroup.APIGroup):
+    """使用量数据相关 API"""
+
+    def __init__(self, prefix: str, ap: app.Application):
+        self.ap = ap
+        super().__init__(prefix+"/usage", ap)
+
+    async def do(self, *args, **kwargs):
+        if not self.ap.system_cfg.data['report-usage']:
+            return None
+        return await super().do(*args, **kwargs)
+
+    async def post_query_record(
+        self,
+        session_type: str,
+        session_id: str,
+        query_ability_provider: str,
+        usage: int,
+        model_name: str,
+        response_seconds: int,
+        retry_times: int,
+    ):
+        """提交请求记录"""
+        return await self.do(
+            "POST",
+            "/query",
+            data={
+                "basic": self.basic_info(),
+                "runtime": self.runtime_info(),
+                "session_info": {
+                    "type": session_type,
+                    "id": session_id,
+                },
+                "query_info": {
+                    "ability_provider": query_ability_provider,
+                    "usage": usage,
+                    "model_name": model_name,
+                    "response_seconds": response_seconds,
+                    "retry_times": retry_times,
+                }
+            }
+        )
+    
+    async def post_event_record(
+        self,
+        plugins: list[dict],
+        event_name: str,
+    ):
+        """提交事件触发记录"""
+        return await self.do(
+            "POST",
+            "/event",
+            data={
+                "basic": self.basic_info(),
+                "runtime": self.runtime_info(),
+                "plugins": plugins,
+                "event_info": {
+                    "name": event_name,
+                }
+            }
+        )
+    
+    async def post_function_record(
+        self,
+        plugin: dict,
+        function_name: str,
+        function_description: str,
+    ):
+        """提交内容函数使用记录"""
+        return await self.do(
+            "POST",
+            "/function",
+            data={
+                "basic": self.basic_info(),
+                "plugin": plugin,
+                "function_info": {
+                    "name": function_name,
+                    "description": function_description,
+                }
+            }
+        )
+    

pkg/audit/center/v2.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import logging
+
+from . import apigroup
+from .groups import main
+from .groups import usage
+from .groups import plugin
+from ...core import app
+
+
+BACKEND_URL = "https://api.qchatgpt.rockchin.top/api/v2"
+
+class V2CenterAPI:
+    """中央服务器 v2 API 交互类"""
+    
+    main: main.V2MainDataAPI = None
+    """主 API 组"""
+
+    usage: usage.V2UsageDataAPI = None
+    """使用量 API 组"""
+
+    plugin: plugin.V2PluginDataAPI = None
+    """插件 API 组"""
+
+    def __init__(self, ap: app.Application, basic_info: dict = None, runtime_info: dict = None):
+        """初始化"""
+
+        logging.debug("basic_info: %s, runtime_info: %s", basic_info, runtime_info)
+        
+        apigroup.APIGroup._basic_info = basic_info
+        apigroup.APIGroup._runtime_info = runtime_info
+
+        self.main = main.V2MainDataAPI(BACKEND_URL, ap)
+        self.usage = usage.V2UsageDataAPI(BACKEND_URL, ap)
+        self.plugin = plugin.V2PluginDataAPI(BACKEND_URL, ap)
+

pkg/audit/gatherer.py

@@ -1,113 +0,0 @@
-import hashlib
-import json
-import logging
-
-import requests
-
-import pkg.utils.context
-import pkg.utils.updater
-
-
-class DataGatherer:
-    """数据收集器"""
-    usage = {}
-    """以key值md5为key,{
-        "text": {
-            "text-davinci-003": 文字量:int,
-        },
-        "image": {
-            "256x256": 图片数量:int,
-        }
-    }为值的字典"""
-
-    version_str = "undetermined"
-
-    def __init__(self):
-        self.load_from_db()
-        try:
-            self.version_str = pkg.utils.updater.get_commit_id_and_time_and_msg()[:40 if len(pkg.utils.updater.get_commit_id_and_time_and_msg()) > 40 else len(pkg.utils.updater.get_commit_id_and_time_and_msg())]
-        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, 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 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()
-
-        if key_md5 not in self.usage:
-            self.usage[key_md5] = {}
-
-        if "text" not in self.usage[key_md5]:
-            self.usage[key_md5]["text"] = {}
-
-        if model not in self.usage[key_md5]["text"]:
-            self.usage[key_md5]["text"][model] = 0
-
-        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:
-            self.usage[key_md5] = {}
-
-        if "image" not in self.usage[key_md5]:
-            self.usage[key_md5]["image"] = {}
-
-        if size not in self.usage[key_md5]["image"]:
-            self.usage[key_md5]["image"][size] = 0
-
-        self.usage[key_md5]["image"][size] += 1
-        self.dump_to_db()
-
-        self.report_to_server("image", 1)
-
-    def get_text_length_of_key(self, key):
-        key_md5 = hashlib.md5(key.encode('utf-8')).hexdigest()
-        if key_md5 not in self.usage:
-            return 0
-        if "text" not in self.usage[key_md5]:
-            return 0
-        # 遍历其中所有模型，求和
-        return sum(self.usage[key_md5]["text"].values())
-
-    def get_image_count_of_key(self, key):
-        key_md5 = hashlib.md5(key.encode('utf-8')).hexdigest()
-        if key_md5 not in self.usage:
-            return 0
-        if "image" not in self.usage[key_md5]:
-            return 0
-        # 遍历其中所有模型，求和
-        return sum(self.usage[key_md5]["image"].values())
-
-    def get_total_text_length(self):
-        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)
-
-    def load_from_db(self):
-        json_str = pkg.utils.context.get_database_manager().load_usage_json()
-        if json_str is not None:
-            self.usage = json.loads(json_str)

pkg/audit/identifier.py

@@ -0,0 +1,83 @@
+import os
+import uuid
+import json
+import time
+
+
+identifier = {
+    'host_id': '',
+    'instance_id': '',
+    'host_create_ts': 0,
+    'instance_create_ts': 0,
+}
+
+HOST_ID_FILE = os.path.expanduser('~/.qchatgpt/host_id.json')
+INSTANCE_ID_FILE = 'res/instance_id.json'
+
+def init():
+    global identifier
+
+    if not os.path.exists(os.path.expanduser('~/.qchatgpt')):
+        os.mkdir(os.path.expanduser('~/.qchatgpt'))
+
+    if not os.path.exists(HOST_ID_FILE):
+        new_host_id = 'host_'+str(uuid.uuid4())
+        new_host_create_ts = int(time.time())
+
+        with open(HOST_ID_FILE, 'w') as f:
+            json.dump({
+                'host_id': new_host_id,
+                'host_create_ts': new_host_create_ts
+            }, f)
+
+        identifier['host_id'] = new_host_id
+        identifier['host_create_ts'] = new_host_create_ts
+    else:
+        loaded_host_id = ''
+        loaded_host_create_ts = 0
+
+        with open(HOST_ID_FILE, 'r') as f:
+            file_content = json.load(f)
+            loaded_host_id = file_content['host_id']
+            loaded_host_create_ts = file_content['host_create_ts']
+
+        identifier['host_id'] = loaded_host_id
+        identifier['host_create_ts'] = loaded_host_create_ts
+
+    # 检查实例 id
+    if os.path.exists(INSTANCE_ID_FILE):
+        instance_id = {}
+        with open(INSTANCE_ID_FILE, 'r') as f:
+            instance_id = json.load(f)
+        
+        if instance_id['host_id'] != identifier['host_id']: # 如果实例 id 不是当前主机的，删除
+            os.remove(INSTANCE_ID_FILE)
+
+    if not os.path.exists(INSTANCE_ID_FILE):
+        new_instance_id = 'instance_'+str(uuid.uuid4())
+        new_instance_create_ts = int(time.time())
+
+        with open(INSTANCE_ID_FILE, 'w') as f:
+            json.dump({
+                'host_id': identifier['host_id'],
+                'instance_id': new_instance_id,
+                'instance_create_ts': new_instance_create_ts
+            }, f)
+
+        identifier['instance_id'] = new_instance_id
+        identifier['instance_create_ts'] = new_instance_create_ts
+    else:
+        loaded_instance_id = ''
+        loaded_instance_create_ts = 0
+
+        with open(INSTANCE_ID_FILE, 'r') as f:
+            file_content = json.load(f)
+            loaded_instance_id = file_content['instance_id']
+            loaded_instance_create_ts = file_content['instance_create_ts']
+
+        identifier['instance_id'] = loaded_instance_id
+        identifier['instance_create_ts'] = loaded_instance_create_ts
+
+def print_out():
+    global identifier
+    print(identifier)

pkg/command/cmdmgr.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import typing
+
+from ..core import app, entities as core_entities
+from ..provider import entities as llm_entities
+from . import entities, operator, errors
+from ..config import manager as cfg_mgr
+
+from .operators import func, plugin, default, reset, list as list_cmd, last, next, delc, resend, prompt, cmd, help, version, update
+
+
+class CommandManager:
+    """命令管理器
+    """
+
+    ap: app.Application
+
+    cmd_list: list[operator.CommandOperator]
+
+    def __init__(self, ap: app.Application):
+        self.ap = ap
+
+    async def initialize(self):
+
+        # 设置各个类的路径
+        def set_path(cls: operator.CommandOperator, ancestors: list[str]):
+            cls.path = '.'.join(ancestors + [cls.name])
+            for op in operator.preregistered_operators:
+                if op.parent_class == cls:
+                    set_path(op, ancestors + [cls.name])
+        
+        for cls in operator.preregistered_operators:
+            if cls.parent_class is None:
+                set_path(cls, [])
+
+        # 应用命令权限配置
+        for cls in operator.preregistered_operators:
+            if cls.path in self.ap.command_cfg.data['privilege']:
+                cls.lowest_privilege = self.ap.command_cfg.data['privilege'][cls.path]
+
+        # 实例化所有类
+        self.cmd_list = [cls(self.ap) for cls in operator.preregistered_operators]
+
+        # 设置所有类的子节点
+        for cmd in self.cmd_list:
+            cmd.children = [child for child in self.cmd_list if child.parent_class == cmd.__class__]
+
+        # 初始化所有类
+        for cmd in self.cmd_list:
+            await cmd.initialize()
+
+    async def _execute(
+        self,
+        context: entities.ExecuteContext,
+        operator_list: list[operator.CommandOperator],
+        operator: operator.CommandOperator = None
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        """执行命令
+        """
+
+        found = False
+        if len(context.crt_params) > 0:
+            for oper in operator_list:
+                if (context.crt_params[0] == oper.name \
+                    or context.crt_params[0] in oper.alias) \
+                    and (oper.parent_class is None or oper.parent_class == operator.__class__):
+                    found = True
+
+                    context.crt_command = context.crt_params[0]
+                    context.crt_params = context.crt_params[1:]
+
+                    async for ret in self._execute(
+                        context,
+                        oper.children,
+                        oper
+                    ):
+                        yield ret
+                    break
+
+        if not found:
+            if operator is None:
+                yield entities.CommandReturn(
+                    error=errors.CommandNotFoundError(context.crt_params[0])
+                )
+            else:
+                if operator.lowest_privilege > context.privilege:
+                    yield entities.CommandReturn(
+                        error=errors.CommandPrivilegeError(operator.name)
+                    )
+                else:
+                    async for ret in operator.execute(context):
+                        yield ret
+
+
+    async def execute(
+        self,
+        command_text: str,
+        query: core_entities.Query,
+        session: core_entities.Session
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        """执行命令
+        """
+
+        privilege = 1
+
+        if f'{query.launcher_type.value}_{query.launcher_id}' in self.ap.system_cfg.data['admin-sessions']:
+            privilege = 2
+
+        ctx = entities.ExecuteContext(
+            query=query,
+            session=session,
+            command_text=command_text,
+            command='',
+            crt_command='',
+            params=command_text.split(' '),
+            crt_params=command_text.split(' '),
+            privilege=privilege
+        )
+
+        async for ret in self._execute(
+            ctx,
+            self.cmd_list
+        ):
+            yield ret

pkg/command/entities.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import typing
+
+import pydantic
+import mirai
+
+from ..core import app, entities as core_entities
+from . import errors, operator
+
+
+class CommandReturn(pydantic.BaseModel):
+
+    text: typing.Optional[str]
+    """文本
+    """
+
+    image: typing.Optional[mirai.Image]
+
+    error: typing.Optional[errors.CommandError]= None
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+class ExecuteContext(pydantic.BaseModel):
+
+    query: core_entities.Query
+
+    session: core_entities.Session
+
+    command_text: str
+
+    command: str
+
+    crt_command: str
+
+    params: list[str]
+
+    crt_params: list[str]
+
+    privilege: int

pkg/command/errors.py

@@ -0,0 +1,33 @@
+
+
+class CommandError(Exception):
+    
+    def __init__(self, message: str = None):
+        self.message = message
+    
+    def __str__(self):
+        return self.message
+
+
+class CommandNotFoundError(CommandError):
+    
+    def __init__(self, message: str = None):
+        super().__init__("未知命令: "+message)
+
+
+class CommandPrivilegeError(CommandError):
+    
+    def __init__(self, message: str = None):
+        super().__init__("权限不足: "+message)
+
+
+class ParamNotEnoughError(CommandError):
+    
+    def __init__(self, message: str = None):
+        super().__init__("参数不足: "+message)
+
+
+class CommandOperationError(CommandError):
+    
+    def __init__(self, message: str = None):
+        super().__init__("操作失败: "+message)

pkg/command/operator.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import typing
+import abc
+
+from ..core import app, entities as core_entities
+from . import entities
+
+
+preregistered_operators: list[typing.Type[CommandOperator]] = []
+
+
+def operator_class(
+    name: str,
+    help: str,
+    usage: str = None,
+    alias: list[str] = [],
+    privilege: int=1,  # 1为普通用户，2为管理员
+    parent_class: typing.Type[CommandOperator] = None
+) -> typing.Callable[[typing.Type[CommandOperator]], typing.Type[CommandOperator]]:
+    def decorator(cls: typing.Type[CommandOperator]) -> typing.Type[CommandOperator]:
+        cls.name = name
+        cls.alias = alias
+        cls.help = help
+        cls.usage = usage
+        cls.parent_class = parent_class
+        cls.lowest_privilege = privilege
+
+        preregistered_operators.append(cls)
+
+        return cls
+
+    return decorator
+
+
+class CommandOperator(metaclass=abc.ABCMeta):
+    """命令算子
+    """
+
+    ap: app.Application
+
+    name: str
+    """名称，搜索到时若符合则使用"""
+
+    path: str
+    """路径，所有父节点的name的连接，用于定义命令权限"""
+
+    alias: list[str]
+    """同name"""
+
+    help: str
+    """此节点的帮助信息"""
+
+    usage: str = None
+
+    parent_class: typing.Union[typing.Type[CommandOperator], None] = None
+    """父节点类。标记以供管理器在初始化时编织父子关系。"""
+
+    lowest_privilege: int = 0
+    """最低权限。若权限低于此值，则不予执行。"""
+
+    children: list[CommandOperator]
+    """子节点。解析命令时，若节点有子节点，则以下一个参数去匹配子节点，
+    若有匹配中的，转移到子节点中执行，若没有匹配中的或没有子节点，执行此节点。"""
+
+    def __init__(self, ap: app.Application):
+        self.ap = ap
+        self.children = []
+
+    async def initialize(self):
+        pass
+
+    @abc.abstractmethod
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        pass

pkg/command/operators/cmd.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import typing
+
+from .. import operator, entities, cmdmgr, errors
+
+
+@operator.operator_class(
+    name="cmd",
+    help='显示命令列表',
+    usage='!cmd\n!cmd <命令名称>'
+)
+class CmdOperator(operator.CommandOperator):
+    """命令列表
+    """
+
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        """执行
+        """
+        if len(context.crt_params) == 0:
+            reply_str = "当前所有命令: \n\n"
+
+            for cmd in self.ap.cmd_mgr.cmd_list:
+                if cmd.parent_class is None:
+                    reply_str += f"{cmd.name}: {cmd.help}\n"
+        
+            reply_str += "\n使用 !cmd <命令名称> 查看命令的详细帮助"
+
+            yield entities.CommandReturn(text=reply_str.strip())
+        
+        else:
+            cmd_name = context.crt_params[0]
+
+            cmd = None
+
+            for _cmd in self.ap.cmd_mgr.cmd_list:
+                if (cmd_name == _cmd.name or cmd_name in _cmd.alias) and (_cmd.parent_class is None):
+                    cmd = _cmd
+                    break
+
+            if cmd is None:
+                yield entities.CommandReturn(error=errors.CommandNotFoundError(cmd_name))
+            else:
+                reply_str = f"{cmd.name}: {cmd.help}\n\n"
+                reply_str += f"使用方法: \n{cmd.usage}"
+
+                yield entities.CommandReturn(text=reply_str.strip())

pkg/command/operators/default.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import typing
+import traceback
+
+from .. import operator, entities, cmdmgr, errors
+
+
+@operator.operator_class(
+    name="default",
+    help="操作情景预设",
+    usage='!default\n!default set <指定情景预设为默认>'
+)
+class DefaultOperator(operator.CommandOperator):
+
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        
+        reply_str = "当前所有情景预设: \n\n"
+
+        for prompt in self.ap.prompt_mgr.get_all_prompts():
+
+            content = ""
+            for msg in prompt.messages:
+                content += f"  {msg.role}: {msg.content}"
+
+            reply_str += f"名称: {prompt.name}\n内容: \n{content}\n\n"
+
+        reply_str += f"当前会话使用的是: {context.session.use_prompt_name}"
+
+        yield entities.CommandReturn(text=reply_str.strip())
+
+
+@operator.operator_class(
+    name="set",
+    help="设置当前会话默认情景预设",
+    parent_class=DefaultOperator
+)
+class DefaultSetOperator(operator.CommandOperator):
+
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+            
+            if len(context.crt_params) == 0:
+                yield entities.CommandReturn(error=errors.ParamNotEnoughError('请提供情景预设名称'))
+            else:
+                prompt_name = context.crt_params[0]
+        
+                try:
+                    prompt = await self.ap.prompt_mgr.get_prompt_by_prefix(prompt_name)
+                    if prompt is None:
+                        yield entities.CommandReturn(error=errors.CommandError("设置当前会话默认情景预设失败: 未找到情景预设 {}".format(prompt_name)))
+                    else:
+                        context.session.use_prompt_name = prompt.name
+                        yield entities.CommandReturn(text=f"已设置当前会话默认情景预设为 {prompt_name}, !reset 后生效")
+                except Exception as e:
+                    traceback.print_exc()
+                    yield entities.CommandReturn(error=errors.CommandError("设置当前会话默认情景预设失败: "+str(e)))

pkg/command/operators/delc.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import typing
+import datetime
+
+from .. import operator, entities, cmdmgr, errors
+
+
+@operator.operator_class(
+    name="del",
+    help="删除当前会话的历史记录",
+    usage='!del <序号>\n!del all'
+)
+class DelOperator(operator.CommandOperator):
+
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        
+        if context.session.conversations:
+            delete_index = 0
+            if len(context.crt_params) > 0:
+                try:
+                    delete_index = int(context.crt_params[0])
+                except:
+                    yield entities.CommandReturn(error=errors.CommandOperationError('索引必须是整数'))
+                    return
+                
+            if delete_index < 0 or delete_index >= len(context.session.conversations):
+                yield entities.CommandReturn(error=errors.CommandOperationError('索引超出范围'))
+                return
+            
+            # 倒序
+            to_delete_index = len(context.session.conversations)-1-delete_index
+
+            if context.session.conversations[to_delete_index] == context.session.using_conversation:
+                context.session.using_conversation = None
+
+            del context.session.conversations[to_delete_index]
+
+            yield entities.CommandReturn(text=f"已删除对话: {delete_index}")
+        else:
+            yield entities.CommandReturn(error=errors.CommandOperationError('当前没有对话'))
+
+
+@operator.operator_class(
+    name="all",
+    help="删除此会话的所有历史记录",
+    parent_class=DelOperator
+)
+class DelAllOperator(operator.CommandOperator):
+
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+
+        context.session.conversations = []
+        context.session.using_conversation = None
+
+        yield entities.CommandReturn(text="已删除所有对话")

pkg/command/operators/func.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+from typing import AsyncGenerator
+
+from .. import operator, entities, cmdmgr
+
+
+@operator.operator_class(name="func", help="查看所有已注册的内容函数", usage='!func')
+class FuncOperator(operator.CommandOperator):
+    async def execute(
+        self, context: entities.ExecuteContext
+    ) -> AsyncGenerator[entities.CommandReturn, None]:
+        reply_str = "当前已加载的内容函数: \n\n"
+
+        index = 1
+
+        all_functions = await self.ap.tool_mgr.get_all_functions()
+
+        for func in all_functions:
+            reply_str += "{}. {}{}:\n{}\n\n".format(
+                index,
+                ("(已禁用) " if not func.enable else ""),
+                func.name,
+                func.description,
+            )
+            index += 1
+
+        yield entities.CommandReturn(text=reply_str)

pkg/command/operators/help.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import typing
+
+from .. import operator, entities, cmdmgr, errors
+
+
+@operator.operator_class(
+    name='help',
+    help='显示帮助',
+    usage='!help\n!help <命令名称>'
+)
+class HelpOperator(operator.CommandOperator):
+    
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        help = self.ap.system_cfg.data['help-message']
+
+        help += '\n发送命令 !cmd 可查看命令列表'
+
+        yield entities.CommandReturn(text=help)

pkg/command/operators/last.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import typing
+import datetime
+
+
+from .. import operator, entities, cmdmgr, errors
+
+
+@operator.operator_class(
+    name="last",
+    help="切换到前一个对话",
+    usage='!last'
+)
+class LastOperator(operator.CommandOperator):
+
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        
+        if context.session.conversations:
+            # 找到当前会话的上一个会话
+            for index in range(len(context.session.conversations)-1, -1, -1):
+                if context.session.conversations[index] == context.session.using_conversation:
+                    if index == 0:
+                        yield entities.CommandReturn(error=errors.CommandOperationError('已经是第一个对话了'))
+                        return
+                    else:
+                        context.session.using_conversation = context.session.conversations[index-1]
+                        time_str = context.session.using_conversation.create_time.strftime("%Y-%m-%d %H:%M:%S")
+
+                        yield entities.CommandReturn(text=f"已切换到上一个对话: {index} {time_str}: {context.session.using_conversation.messages[0].content}")
+                        return
+        else:
+            yield entities.CommandReturn(error=errors.CommandOperationError('当前没有对话'))

pkg/command/operators/list.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import typing
+import datetime
+
+from .. import operator, entities, cmdmgr, errors
+
+
+@operator.operator_class(
+    name="list",
+    help="列出此会话中的所有历史对话",
+    usage='!list\n!list <页码>'
+)
+class ListOperator(operator.CommandOperator):
+
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        
+        page = 0
+
+        if len(context.crt_params) > 0:
+            try:
+                page = int(context.crt_params[0]-1)
+            except:
+                yield entities.CommandReturn(error=errors.CommandOperationError('页码应为整数'))
+                return
+
+        record_per_page = 10
+
+        content = ''
+
+        index = 0
+
+        using_conv_index = 0
+
+        for conv in context.session.conversations[::-1]:
+            time_str =  conv.create_time.strftime("%Y-%m-%d %H:%M:%S")
+
+            if conv == context.session.using_conversation:
+                using_conv_index = index
+
+            if index >= page * record_per_page and index < (page + 1) * record_per_page:
+                content += f"{index} {time_str}: {conv.messages[0].content if len(conv.messages) > 0 else '无内容'}\n"
+            index += 1
+
+        if content == '':
+            content = '无'
+        else:
+            if context.session.using_conversation is None:
+                content += "\n当前处于新会话"
+            else:
+                content += f"\n当前会话: {using_conv_index} {context.session.using_conversation.create_time.strftime('%Y-%m-%d %H:%M:%S')}: {context.session.using_conversation.messages[0].content if len(context.session.using_conversation.messages) > 0 else '无内容'}"
+        
+        yield entities.CommandReturn(text=f"第 {page + 1} 页 (时间倒序):\n{content}")

pkg/command/operators/next.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import typing
+import datetime
+
+from .. import operator, entities, cmdmgr, errors
+
+
+@operator.operator_class(
+    name="next",
+    help="切换到后一个对话",
+    usage='!next'
+)
+class NextOperator(operator.CommandOperator):
+
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        
+        if context.session.conversations:
+            # 找到当前会话的下一个会话
+            for index in range(len(context.session.conversations)):
+                if context.session.conversations[index] == context.session.using_conversation:
+                    if index == len(context.session.conversations)-1:
+                        yield entities.CommandReturn(error=errors.CommandOperationError('已经是最后一个对话了'))
+                        return
+                    else:
+                        context.session.using_conversation = context.session.conversations[index+1]
+                        time_str = context.session.using_conversation.create_time.strftime("%Y-%m-%d %H:%M:%S")
+
+                        yield entities.CommandReturn(text=f"已切换到后一个对话: {index} {time_str}: {context.session.using_conversation.messages[0].content}")
+                        return
+        else:
+            yield entities.CommandReturn(error=errors.CommandOperationError('当前没有对话'))

pkg/command/operators/plugin.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+import typing
+import traceback
+
+from .. import operator, entities, cmdmgr, errors
+from ...core import app
+
+
+@operator.operator_class(
+    name="plugin",
+    help="插件操作",
+    usage="!plugin\n!plugin get <插件仓库地址>\n!plugin update\n!plugin del <插件名>\n!plugin on <插件名>\n!plugin off <插件名>"
+)
+class PluginOperator(operator.CommandOperator):
+
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        
+        plugin_list = self.ap.plugin_mgr.plugins
+        reply_str = "所有插件({}):\n".format(len(plugin_list))
+        idx = 0
+        for plugin in plugin_list:
+            reply_str += "\n#{} {} {}\n{}\nv{}\n作者: {}\n"\
+                .format((idx+1), plugin.plugin_name,
+                        "[已禁用]" if not plugin.enabled else "",
+                        plugin.plugin_description,
+                        plugin.plugin_version, plugin.plugin_author)
+
+            # TODO 从元数据调远程地址
+
+            idx += 1
+
+        yield entities.CommandReturn(text=reply_str)
+
+
+@operator.operator_class(
+    name="get",
+    help="安装插件",
+    privilege=2,
+    parent_class=PluginOperator
+)
+class PluginGetOperator(operator.CommandOperator):
+
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        
+        if len(context.crt_params) == 0:
+            yield entities.CommandReturn(error=errors.ParamNotEnoughError('请提供插件仓库地址'))
+        else:
+            repo = context.crt_params[0]
+
+            yield entities.CommandReturn(text="正在安装插件...")
+
+            try:
+                await self.ap.plugin_mgr.install_plugin(repo)
+                yield entities.CommandReturn(text="插件安装成功，请重启程序以加载插件")
+            except Exception as e:
+                traceback.print_exc()
+                yield entities.CommandReturn(error=errors.CommandError("插件安装失败: "+str(e)))
+
+
+@operator.operator_class(
+    name="update",
+    help="更新插件",
+    privilege=2,
+    parent_class=PluginOperator
+)
+class PluginUpdateOperator(operator.CommandOperator):
+
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        
+        if len(context.crt_params) == 0:
+            yield entities.CommandReturn(error=errors.ParamNotEnoughError('请提供插件名称'))
+        else:
+            plugin_name = context.crt_params[0]
+
+            try:
+                plugin_container = self.ap.plugin_mgr.get_plugin_by_name(plugin_name)
+
+                if plugin_container is not None:
+                    yield entities.CommandReturn(text="正在更新插件...")
+                    await self.ap.plugin_mgr.update_plugin(plugin_name)
+                    yield entities.CommandReturn(text="插件更新成功，请重启程序以加载插件")
+                else:
+                    yield entities.CommandReturn(error=errors.CommandError("插件更新失败: 未找到插件"))
+            except Exception as e:
+                traceback.print_exc()
+                yield entities.CommandReturn(error=errors.CommandError("插件更新失败: "+str(e)))
+
+@operator.operator_class(
+    name="all",
+    help="更新所有插件",
+    privilege=2,
+    parent_class=PluginUpdateOperator
+)
+class PluginUpdateAllOperator(operator.CommandOperator):
+
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+
+        try:
+            plugins = [
+                p.plugin_name
+                for p in self.ap.plugin_mgr.plugins
+            ]
+
+            if plugins:
+                yield entities.CommandReturn(text="正在更新插件...")
+                updated = []
+                try:
+                    for plugin_name in plugins:
+                        await self.ap.plugin_mgr.update_plugin(plugin_name)
+                        updated.append(plugin_name)
+                except Exception as e:
+                    traceback.print_exc()
+                    yield entities.CommandReturn(error=errors.CommandError("插件更新失败: "+str(e)))
+                yield entities.CommandReturn(text="已更新插件: {}".format(", ".join(updated)))
+            else:
+                yield entities.CommandReturn(text="没有可更新的插件")
+        except Exception as e:
+            traceback.print_exc()
+            yield entities.CommandReturn(error=errors.CommandError("插件更新失败: "+str(e)))
+
+
+@operator.operator_class(
+    name="del",
+    help="删除插件",
+    privilege=2,
+    parent_class=PluginOperator
+)
+class PluginDelOperator(operator.CommandOperator):
+
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        
+        if len(context.crt_params) == 0:
+            yield entities.CommandReturn(error=errors.ParamNotEnoughError('请提供插件名称'))
+        else:
+            plugin_name = context.crt_params[0]
+
+            try:
+                plugin_container = self.ap.plugin_mgr.get_plugin_by_name(plugin_name)
+
+                if plugin_container is not None:
+                    yield entities.CommandReturn(text="正在删除插件...")
+                    await self.ap.plugin_mgr.uninstall_plugin(plugin_name)
+                    yield entities.CommandReturn(text="插件删除成功，请重启程序以加载插件")
+                else:
+                    yield entities.CommandReturn(error=errors.CommandError("插件删除失败: 未找到插件"))
+            except Exception as e:
+                traceback.print_exc()
+                yield entities.CommandReturn(error=errors.CommandError("插件删除失败: "+str(e)))
+
+
+async def update_plugin_status(plugin_name: str, new_status: bool, ap: app.Application):
+    if ap.plugin_mgr.get_plugin_by_name(plugin_name) is not None:
+        for plugin in ap.plugin_mgr.plugins:
+            if plugin.plugin_name == plugin_name:
+                plugin.enabled = new_status
+
+                for func in plugin.content_functions:
+                    func.enable = new_status
+                
+                await ap.plugin_mgr.setting.dump_container_setting(ap.plugin_mgr.plugins)
+
+                break
+
+        return True
+    else:
+        return False
+
+
+@operator.operator_class(
+    name="on",
+    help="启用插件",
+    privilege=2,
+    parent_class=PluginOperator
+)
+class PluginEnableOperator(operator.CommandOperator):
+
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        
+        if len(context.crt_params) == 0:
+            yield entities.CommandReturn(error=errors.ParamNotEnoughError('请提供插件名称'))
+        else:
+            plugin_name = context.crt_params[0]
+
+            try:
+                if await update_plugin_status(plugin_name, True, self.ap):
+                    yield entities.CommandReturn(text="已启用插件: {}".format(plugin_name))
+                else:
+                    yield entities.CommandReturn(error=errors.CommandError("插件状态修改失败: 未找到插件 {}".format(plugin_name)))
+            except Exception as e:
+                traceback.print_exc()
+                yield entities.CommandReturn(error=errors.CommandError("插件状态修改失败: "+str(e)))
+
+
+@operator.operator_class(
+    name="off",
+    help="禁用插件",
+    privilege=2,
+    parent_class=PluginOperator
+)
+class PluginDisableOperator(operator.CommandOperator):
+
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        
+        if len(context.crt_params) == 0:
+            yield entities.CommandReturn(error=errors.ParamNotEnoughError('请提供插件名称'))
+        else:
+            plugin_name = context.crt_params[0]
+
+            try:
+                if await update_plugin_status(plugin_name, False, self.ap):
+                    yield entities.CommandReturn(text="已禁用插件: {}".format(plugin_name))
+                else:
+                    yield entities.CommandReturn(error=errors.CommandError("插件状态修改失败: 未找到插件 {}".format(plugin_name)))
+            except Exception as e:
+                traceback.print_exc()
+                yield entities.CommandReturn(error=errors.CommandError("插件状态修改失败: "+str(e)))

pkg/command/operators/prompt.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import typing
+
+from .. import operator, entities, cmdmgr, errors
+
+
+@operator.operator_class(
+    name="prompt",
+    help="查看当前对话的前文",
+    usage='!prompt'
+)
+class PromptOperator(operator.CommandOperator):
+    
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        """执行
+        """
+        if context.session.using_conversation is None:
+            yield entities.CommandReturn(error=errors.CommandOperationError('当前没有对话'))
+        else:
+            reply_str = '当前对话所有内容:\n\n'
+
+            for msg in context.session.using_conversation.messages:
+                reply_str += f"{msg.role}: {msg.content}\n"
+
+            yield entities.CommandReturn(text=reply_str)

pkg/command/operators/resend.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import typing
+
+from .. import operator, entities, cmdmgr, errors
+
+
+@operator.operator_class(
+    name="resend",
+    help="重发当前会话的最后一条消息",
+    usage='!resend'
+)
+class ResendOperator(operator.CommandOperator):
+
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        # 回滚到最后一条用户message前
+        if context.session.using_conversation is None:
+            yield entities.CommandReturn(error=errors.CommandError("当前没有对话"))
+        else:
+            conv_msg = context.session.using_conversation.messages
+            
+            # 倒序一直删到最后一条用户message
+            while len(conv_msg) > 0 and conv_msg[-1].role != 'user':
+                conv_msg.pop()
+
+            if len(conv_msg) > 0:
+                # 删除最后一条用户message
+                conv_msg.pop()
+
+            # 不重发了，提示用户已删除就行了
+            yield entities.CommandReturn(text="已删除最后一次请求记录")

pkg/command/operators/reset.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import typing
+
+from .. import operator, entities, cmdmgr, errors
+
+
+@operator.operator_class(
+    name="reset",
+    help="重置当前会话",
+    usage='!reset'
+)
+class ResetOperator(operator.CommandOperator):
+    
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        """执行
+        """
+        context.session.using_conversation = None
+
+        yield entities.CommandReturn(text="已重置当前会话")

pkg/command/operators/update.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import typing
+import traceback
+
+from .. import operator, entities, cmdmgr, errors
+
+
+@operator.operator_class(
+    name="update",
+    help="更新程序",
+    usage='!update',
+    privilege=2
+)
+class UpdateCommand(operator.CommandOperator):
+
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+       
+        try:
+            yield entities.CommandReturn(text="正在进行更新...")
+            if await self.ap.ver_mgr.update_all():
+                yield entities.CommandReturn(text="更新完成，请重启程序以应用更新")
+            else:
+                yield entities.CommandReturn(text="当前已是最新版本")
+        except Exception as e:
+            traceback.print_exc()
+            yield entities.CommandReturn(error=errors.CommandError("更新失败: "+str(e)))

pkg/command/operators/version.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import typing
+
+from .. import operator, cmdmgr, entities, errors
+
+
+@operator.operator_class(
+    name="version",
+    help="显示版本信息",
+    usage='!version'
+)
+class VersionCommand(operator.CommandOperator):
+
+    async def execute(
+        self,
+        context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        reply_str = f"当前版本: \n{self.ap.ver_mgr.get_current_version()}"
+
+        try:
+            if await self.ap.ver_mgr.is_new_version_available():
+                reply_str += "\n\n有新版本可用, 使用 !update 更新"
+        except:
+            pass
+
+        yield entities.CommandReturn(text=reply_str.strip())

pkg/config/impls/json.py

@@ -0,0 +1,47 @@
+import os
+import shutil
+import json
+
+from .. import model as file_model
+
+
+class JSONConfigFile(file_model.ConfigFile):
+    """JSON配置文件"""
+
+    config_file_name: str = None
+    """配置文件名"""
+
+    template_file_name: str = None
+    """模板文件名"""
+
+    def __init__(self, config_file_name: str, template_file_name: str) -> None:
+        self.config_file_name = config_file_name
+        self.template_file_name = template_file_name
+
+    def exists(self) -> bool:
+        return os.path.exists(self.config_file_name)
+
+    async def create(self):
+        shutil.copyfile(self.template_file_name, self.config_file_name)
+
+    async def load(self) -> dict:
+
+        if not self.exists():
+            await self.create()
+
+        with open(self.config_file_name, 'r', encoding='utf-8') as f:
+            cfg = json.load(f)
+
+        # 从模板文件中进行补全
+        with open(self.template_file_name, 'r', encoding='utf-8') as f:
+            template_cfg = json.load(f)
+
+        for key in template_cfg:
+            if key not in cfg:
+                cfg[key] = template_cfg[key]
+
+        return cfg
+    
+    async def save(self, cfg: dict):
+        with open(self.config_file_name, 'w', encoding='utf-8') as f:
+            json.dump(cfg, f, indent=4, ensure_ascii=False)

pkg/config/impls/pymodule.py

@@ -0,0 +1,62 @@
+import os
+import shutil
+import importlib
+import logging
+
+from .. import model as file_model
+
+
+class PythonModuleConfigFile(file_model.ConfigFile):
+    """Python模块配置文件"""
+
+    config_file_name: str = None
+    """配置文件名"""
+
+    template_file_name: str = None
+    """模板文件名"""
+
+    def __init__(self, config_file_name: str, template_file_name: str) -> None:
+        self.config_file_name = config_file_name
+        self.template_file_name = template_file_name
+
+    def exists(self) -> bool:
+        return os.path.exists(self.config_file_name)
+
+    async def create(self):
+        shutil.copyfile(self.template_file_name, self.config_file_name)
+
+    async def load(self) -> dict:
+        module_name = os.path.splitext(os.path.basename(self.config_file_name))[0]
+        module = importlib.import_module(module_name)
+        
+        cfg = {}
+
+        allowed_types = (int, float, str, bool, list, dict)
+
+        for key in dir(module):
+            if key.startswith('__'):
+                continue
+
+            if not isinstance(getattr(module, key), allowed_types):
+                continue
+
+            cfg[key] = getattr(module, key)
+
+        # 从模板模块文件中进行补全
+        module_name = os.path.splitext(os.path.basename(self.template_file_name))[0]
+        module = importlib.import_module(module_name)
+
+        for key in dir(module):
+            if key.startswith('__'):
+                continue
+
+            if not isinstance(getattr(module, key), allowed_types):
+                continue
+
+            if key not in cfg:
+                cfg[key] = getattr(module, key)
+
+        return cfg
+
+    async def save(self, data: dict):
+        logging.warning('Python模块配置文件不支持保存')

pkg/config/manager.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from . import model as file_model
+from .impls import pymodule, json as json_file
+
+
+managers: ConfigManager = []
+
+
+class ConfigManager:
+    """配置文件管理器"""
+
+    file: file_model.ConfigFile = None
+    """配置文件实例"""
+
+    data: dict = None
+    """配置数据"""
+
+    def __init__(self, cfg_file: file_model.ConfigFile) -> None:
+        self.file = cfg_file
+        self.data = {}
+
+    async def load_config(self):
+        self.data = await self.file.load()
+
+    async def dump_config(self):
+        await self.file.save(self.data)
+
+
+async def load_python_module_config(config_name: str, template_name: str) -> ConfigManager:
+    """加载Python模块配置文件"""
+    cfg_inst = pymodule.PythonModuleConfigFile(
+        config_name,
+        template_name
+    )
+
+    cfg_mgr = ConfigManager(cfg_inst)
+    await cfg_mgr.load_config()
+
+    return cfg_mgr
+
+
+async def load_json_config(config_name: str, template_name: str) -> ConfigManager:
+    """加载JSON配置文件"""
+    cfg_inst = json_file.JSONConfigFile(
+        config_name,
+        template_name
+    )
+
+    cfg_mgr = ConfigManager(cfg_inst)
+    await cfg_mgr.load_config()
+
+    return cfg_mgr

pkg/config/model.py

@@ -0,0 +1,27 @@
+import abc
+
+
+class ConfigFile(metaclass=abc.ABCMeta):
+    """配置文件抽象类"""
+
+    config_file_name: str = None
+    """配置文件名"""
+
+    template_file_name: str = None
+    """模板文件名"""
+
+    @abc.abstractmethod
+    def exists(self) -> bool:
+        pass
+
+    @abc.abstractmethod
+    async def create(self):
+        pass
+
+    @abc.abstractmethod
+    async def load(self) -> dict:
+        pass
+
+    @abc.abstractmethod
+    async def save(self, data: dict):
+        pass

pkg/core/app.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import logging
+import asyncio
+import traceback
+
+import aioconsole
+
+from ..platform import manager as im_mgr
+from ..provider.session import sessionmgr as llm_session_mgr
+from ..provider.requester import modelmgr as llm_model_mgr
+from ..provider.sysprompt import sysprompt as llm_prompt_mgr
+from ..provider.tools import toolmgr as llm_tool_mgr
+from ..config import manager as config_mgr
+from ..audit.center import v2 as center_mgr
+from ..command import cmdmgr
+from ..plugin import manager as plugin_mgr
+from . import pool, controller
+from ..pipeline import stagemgr
+from ..utils import version as version_mgr, proxy as proxy_mgr
+
+
+class Application:
+    im_mgr: im_mgr.PlatformManager = None
+
+    cmd_mgr: cmdmgr.CommandManager = None
+
+    sess_mgr: llm_session_mgr.SessionManager = None
+
+    model_mgr: llm_model_mgr.ModelManager = None
+
+    prompt_mgr: llm_prompt_mgr.PromptManager = None
+
+    tool_mgr: llm_tool_mgr.ToolManager = None
+
+    command_cfg: config_mgr.ConfigManager = None
+
+    pipeline_cfg: config_mgr.ConfigManager = None
+
+    platform_cfg: config_mgr.ConfigManager = None
+
+    provider_cfg: config_mgr.ConfigManager = None
+
+    system_cfg: config_mgr.ConfigManager = None
+
+    ctr_mgr: center_mgr.V2CenterAPI = None
+
+    plugin_mgr: plugin_mgr.PluginManager = None
+
+    query_pool: pool.QueryPool = None
+
+    ctrl: controller.Controller = None
+
+    stage_mgr: stagemgr.StageManager = None
+
+    ver_mgr: version_mgr.VersionManager = None
+
+    proxy_mgr: proxy_mgr.ProxyManager = None
+
+    logger: logging.Logger = None
+
+    def __init__(self):
+        pass
+
+    async def initialize(self):
+        pass
+
+    async def run(self):
+        await self.plugin_mgr.load_plugins()
+        await self.plugin_mgr.initialize_plugins()
+
+        tasks = []
+
+        try:
+
+                    
+            tasks = [
+                asyncio.create_task(self.im_mgr.run()),
+                asyncio.create_task(self.ctrl.run())
+            ]
+
+            # async def interrupt(tasks):
+            #     await asyncio.sleep(1.5)
+            #     while await aioconsole.ainput("使用 ctrl+c 或 'exit' 退出程序 > ") != 'exit':
+            #         pass
+            #     for task in tasks:
+            #         task.cancel()
+            
+            # await interrupt(tasks)
+
+            import signal
+
+            def signal_handler(sig, frame):
+                for task in tasks:
+                    task.cancel()
+                self.logger.info("程序退出.")
+                exit(0)
+
+            signal.signal(signal.SIGINT, signal_handler)
+
+            await asyncio.gather(*tasks, return_exceptions=True)
+
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            self.logger.error(f"应用运行致命异常: {e}")
+            self.logger.debug(f"Traceback: {traceback.format_exc()}")
+

pkg/core/boot.py

@@ -0,0 +1,149 @@
+from __future__ import print_function
+
+import os
+import sys
+
+from .bootutils import files
+from .bootutils import deps
+from .bootutils import log
+from .bootutils import config
+
+from . import app
+from . import pool
+from . import controller
+from ..pipeline import stagemgr
+from ..audit import identifier
+from ..provider.session import sessionmgr as llm_session_mgr
+from ..provider.requester import modelmgr as llm_model_mgr
+from ..provider.sysprompt import sysprompt as llm_prompt_mgr
+from ..provider.tools import toolmgr as llm_tool_mgr
+from ..platform import manager as im_mgr
+from ..command import cmdmgr
+from ..plugin import manager as plugin_mgr
+from ..audit.center import v2 as center_v2
+from ..utils import version, proxy, announce
+
+use_override = False
+
+
+async def make_app() -> app.Application:
+    global use_override
+
+    generated_files = await files.generate_files()
+
+    if generated_files:
+        print("以下文件不存在，已自动生成，请按需修改配置文件后重启：")
+        for file in generated_files:
+            print("-", file)
+
+        sys.exit(0)
+
+    missing_deps = await deps.check_deps()
+
+    if missing_deps:
+        print("以下依赖包未安装，将自动安装，请完成后重启程序：")
+        for dep in missing_deps:
+            print("-", dep)
+        await deps.install_deps(missing_deps)
+        sys.exit(0)
+
+    qcg_logger = await log.init_logging()
+
+    # 生成标识符
+    identifier.init()
+
+    # ========== 加载配置文件 ==========
+
+    command_cfg = await config.load_json_config("data/config/command.json", "templates/command.json")
+    pipeline_cfg = await config.load_json_config("data/config/pipeline.json", "templates/pipeline.json")
+    platform_cfg = await config.load_json_config("data/config/platform.json", "templates/platform.json")
+    provider_cfg = await config.load_json_config("data/config/provider.json", "templates/provider.json")
+    system_cfg = await config.load_json_config("data/config/system.json", "templates/system.json")
+
+    # ========== 构建应用实例 ==========
+    ap = app.Application()
+    ap.logger = qcg_logger
+
+    ap.command_cfg = command_cfg
+    ap.pipeline_cfg = pipeline_cfg
+    ap.platform_cfg = platform_cfg
+    ap.provider_cfg = provider_cfg
+    ap.system_cfg = system_cfg
+
+    proxy_mgr = proxy.ProxyManager(ap)
+    await proxy_mgr.initialize()
+    ap.proxy_mgr = proxy_mgr
+    
+    ver_mgr = version.VersionManager(ap)
+    await ver_mgr.initialize()
+    ap.ver_mgr = ver_mgr
+
+    center_v2_api = center_v2.V2CenterAPI(
+        ap,
+        basic_info={
+            "host_id": identifier.identifier["host_id"],
+            "instance_id": identifier.identifier["instance_id"],
+            "semantic_version": ver_mgr.get_current_version(),
+            "platform": sys.platform,
+        },
+        runtime_info={
+            "admin_id": "{}".format(system_cfg.data["admin-sessions"]),
+            "msg_source": str([
+                adapter_cfg['adapter'] if 'adapter' in adapter_cfg else 'unknown'
+                for adapter_cfg in platform_cfg.data['platform-adapters'] if adapter_cfg['enable']
+            ]),
+        },
+    )
+    ap.ctr_mgr = center_v2_api
+
+    # 发送公告
+    ann_mgr = announce.AnnouncementManager(ap)
+    await ann_mgr.show_announcements()
+
+    ap.query_pool = pool.QueryPool()
+
+    await ap.ver_mgr.show_version_update()
+
+    plugin_mgr_inst = plugin_mgr.PluginManager(ap)
+    await plugin_mgr_inst.initialize()
+    ap.plugin_mgr = plugin_mgr_inst
+
+    cmd_mgr_inst = cmdmgr.CommandManager(ap)
+    await cmd_mgr_inst.initialize()
+    ap.cmd_mgr = cmd_mgr_inst
+
+    llm_model_mgr_inst = llm_model_mgr.ModelManager(ap)
+    await llm_model_mgr_inst.initialize()
+    ap.model_mgr = llm_model_mgr_inst
+
+    llm_session_mgr_inst = llm_session_mgr.SessionManager(ap)
+    await llm_session_mgr_inst.initialize()
+    ap.sess_mgr = llm_session_mgr_inst
+
+    llm_prompt_mgr_inst = llm_prompt_mgr.PromptManager(ap)
+    await llm_prompt_mgr_inst.initialize()
+    ap.prompt_mgr = llm_prompt_mgr_inst
+
+    llm_tool_mgr_inst = llm_tool_mgr.ToolManager(ap)
+    await llm_tool_mgr_inst.initialize()
+    ap.tool_mgr = llm_tool_mgr_inst
+
+    im_mgr_inst = im_mgr.PlatformManager(ap=ap)
+    await im_mgr_inst.initialize()
+    ap.im_mgr = im_mgr_inst
+
+    stage_mgr = stagemgr.StageManager(ap)
+    await stage_mgr.initialize()
+    ap.stage_mgr = stage_mgr
+
+    ctrl = controller.Controller(ap)
+    ap.ctrl = ctrl
+
+    await ap.initialize()
+
+    return ap
+
+
+async def main():
+    app_inst = await make_app()
+    await app_inst.run()

pkg/core/bootutils/config.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import json
+
+from ...config import manager as config_mgr
+from ...config.impls import pymodule
+
+
+load_python_module_config = config_mgr.load_python_module_config
+load_json_config = config_mgr.load_json_config
+
+
+async def override_config_manager(cfg_mgr: config_mgr.ConfigManager) -> list[str]:
+    override_json = json.load(open("override.json", "r", encoding="utf-8"))
+    overrided = []
+
+    config = cfg_mgr.data
+    for key in override_json:
+        if key in config:
+            config[key] = override_json[key]
+            overrided.append(key)
+
+    return overrided

pkg/core/bootutils/deps.py

@@ -0,0 +1,32 @@
+import pip
+
+required_deps = {
+    "requests": "requests",
+    "openai": "openai",
+    "colorlog": "colorlog",
+    "mirai": "yiri-mirai-rc",
+    "PIL": "pillow",
+    "nakuru": "nakuru-project-idk",
+    "CallingGPT": "CallingGPT",
+    "tiktoken": "tiktoken",
+    "yaml": "pyyaml",
+    "aiohttp": "aiohttp",
+}
+
+
+async def check_deps() -> list[str]:
+    global required_deps
+
+    missing_deps = []
+    for dep in required_deps:
+        try:
+            __import__(dep)
+        except ImportError:
+            missing_deps.append(dep)
+    return missing_deps
+
+async def install_deps(deps: list[str]):
+    global required_deps
+    
+    for dep in deps:
+        pip.main(["install", required_deps[dep]])

pkg/core/bootutils/files.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+
+
+required_files = {
+    "plugins/__init__.py": "templates/__init__.py",
+    "plugins/plugins.json": "templates/plugin-settings.json",
+    "data/config/command.json": "templates/command.json",
+    "data/config/pipeline.json": "templates/pipeline.json",
+    "data/config/platform.json": "templates/platform.json",
+    "data/config/provider.json": "templates/provider.json",
+    "data/config/system.json": "templates/system.json",
+    "data/config/sensitive-words.json": "templates/sensitive-words.json",
+    "data/scenario/default.json": "templates/scenario-template.json",
+}
+
+required_paths = [
+    "temp",
+    "data",
+    "data/prompts",
+    "data/scenario",
+    "data/logs",
+    "data/config",
+    "plugins"
+]
+
+async def generate_files() -> list[str]:
+    global required_files, required_paths
+
+    for required_paths in required_paths:
+        if not os.path.exists(required_paths):
+            os.mkdir(required_paths)
+
+    generated_files = []
+    for file in required_files:
+        if not os.path.exists(file):
+            shutil.copyfile(required_files[file], file)
+            generated_files.append(file)
+
+    return generated_files

pkg/core/bootutils/log.py

@@ -0,0 +1,57 @@
+import logging
+import os
+import sys
+import time
+
+import colorlog
+
+
+log_colors_config = {
+    "DEBUG": "green",  # cyan white
+    "INFO": "white",
+    "WARNING": "yellow",
+    "ERROR": "red",
+    "CRITICAL": "cyan",
+}
+
+
+async def init_logging() -> logging.Logger:
+    level = logging.INFO
+
+    if "DEBUG" in os.environ and os.environ["DEBUG"] in ["true", "1"]:
+        level = logging.DEBUG
+
+    log_file_name = "data/logs/qcg-%s.log" % time.strftime(
+        "%Y-%m-%d-%H-%M-%S", time.localtime()
+    )
+
+    qcg_logger = logging.getLogger("qcg")
+
+    qcg_logger.setLevel(level)
+
+    color_formatter = colorlog.ColoredFormatter(
+        fmt="%(log_color)s[%(asctime)s.%(msecs)03d] %(pathname)s (%(lineno)d) - [%(levelname)s] :\n    %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+        log_colors=log_colors_config,
+    )
+
+    stream_handler = logging.StreamHandler(sys.stdout)
+
+    log_handlers: logging.Handler = [stream_handler, logging.FileHandler(log_file_name)]
+
+    for handler in log_handlers:
+        handler.setLevel(level)
+        handler.setFormatter(color_formatter)
+        qcg_logger.addHandler(handler)
+
+    qcg_logger.debug("日志初始化完成，日志级别：%s" % level)
+    logging.basicConfig(
+        level=logging.INFO,  # 设置日志输出格式
+        format="[DEPR][%(asctime)s.%(msecs)03d] %(pathname)s (%(lineno)d) - [%(levelname)s] :\n%(message)s",
+        # 日志输出的格式
+        # -8表示占位符，让输出左对齐，输出长度都为8位
+        datefmt="%Y-%m-%d %H:%M:%S",  # 时间输出的格式
+        handlers=[logging.NullHandler()],
+    )
+
+    return qcg_logger

pkg/core/controller.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import asyncio
+import typing
+import traceback
+
+from . import app, entities
+from ..pipeline import entities as pipeline_entities
+from ..plugin import events
+
+
+class Controller:
+    """总控制器
+    """
+    ap: app.Application
+
+    semaphore: asyncio.Semaphore = None
+    """请求并发控制信号量"""
+
+    def __init__(self, ap: app.Application):
+        self.ap = ap
+        self.semaphore = asyncio.Semaphore(self.ap.system_cfg.data['pipeline-concurrency'])
+
+    async def consumer(self):
+        """事件处理循环
+        """
+        try:
+            while True:
+                selected_query: entities.Query = None
+
+                # 取请求
+                async with self.ap.query_pool:
+                    queries: list[entities.Query] = self.ap.query_pool.queries
+
+                    for query in queries:
+                        session = await self.ap.sess_mgr.get_session(query)
+                        self.ap.logger.debug(f"Checking query {query} session {session}")
+
+                        if not session.semaphore.locked():
+                            selected_query = query
+                            await session.semaphore.acquire()
+
+                            break
+
+                    if selected_query:  # 找到了
+                        queries.remove(selected_query)
+                    else:  # 没找到 说明：没有请求 或者 所有query对应的session都已达到并发上限
+                        await self.ap.query_pool.condition.wait()
+                        continue
+
+                if selected_query:
+                    async def _process_query(selected_query):
+                        async with self.semaphore:  # 总并发上限
+                            await self.process_query(selected_query)
+                        
+                        async with self.ap.query_pool:
+                            (await self.ap.sess_mgr.get_session(selected_query)).semaphore.release()
+                            # 通知其他协程，有新的请求可以处理了
+                            self.ap.query_pool.condition.notify_all()
+                    
+                    asyncio.create_task(_process_query(selected_query))
+        except Exception as e:
+            # traceback.print_exc()
+            self.ap.logger.error(f"控制器循环出错: {e}")
+            self.ap.logger.debug(f"Traceback: {traceback.format_exc()}")
+
+    async def _check_output(self, query: entities.Query, result: pipeline_entities.StageProcessResult):
+        """检查输出
+        """
+        if result.user_notice:
+            await self.ap.im_mgr.send(
+                query.message_event,
+                result.user_notice,
+                query.adapter
+            )
+        if result.debug_notice:
+            self.ap.logger.debug(result.debug_notice)
+        if result.console_notice:
+            self.ap.logger.info(result.console_notice)
+        if result.error_notice:
+            self.ap.logger.error(result.error_notice)
+
+    async def _execute_from_stage(
+        self,
+        stage_index: int,
+        query: entities.Query,
+    ):
+        """从指定阶段开始执行
+
+        如何看懂这里为什么这么写？
+        去问 GPT-4:
+            Q1: 现在有一个责任链，其中有多个stage，query对象在其中传递，stage.process可能返回Result也有可能返回typing.AsyncGenerator[Result, None]，
+                如果返回的是生成器，需要挨个生成result，检查是否result中是否要求继续，如果要求继续就进行下一个stage。如果此次生成器产生的result处理完了，就继续生成下一个result，
+                调用后续的stage，直到该生成器全部生成完。责任链中可能有多个stage会返回生成器
+            Q2: 不是这样的，你可能理解有误。如果我们责任链上有这些Stage：
+
+                A B C D E F G
+
+                如果所有的stage都返回Result，且所有Result都要求继续，那么执行顺序是：
+
+                A B C D E F G
+
+                现在假设C返回的是AsyncGenerator，那么执行顺序是：
+
+                A B C D E F G C D E F G C D E F G ...
+            Q3: 但是如果不止一个stage会返回生成器呢？
+        """
+        i = stage_index
+
+        while i < len(self.ap.stage_mgr.stage_containers):
+            stage_container = self.ap.stage_mgr.stage_containers[i]
+            
+            result = stage_container.inst.process(query, stage_container.inst_name)
+
+            if isinstance(result, typing.Coroutine):
+                result = await result
+
+            if isinstance(result, pipeline_entities.StageProcessResult):  # 直接返回结果
+                self.ap.logger.debug(f"Stage {stage_container.inst_name} processed query {query} res {result}")
+                await self._check_output(query, result)
+
+                if result.result_type == pipeline_entities.ResultType.INTERRUPT:
+                    self.ap.logger.debug(f"Stage {stage_container.inst_name} interrupted query {query}")
+                    break
+                elif result.result_type == pipeline_entities.ResultType.CONTINUE:
+                    query = result.new_query
+            elif isinstance(result, typing.AsyncGenerator):  # 生成器
+                self.ap.logger.debug(f"Stage {stage_container.inst_name} processed query {query} gen")
+
+                async for sub_result in result:
+                    self.ap.logger.debug(f"Stage {stage_container.inst_name} processed query {query} res {sub_result}")
+                    await self._check_output(query, sub_result)
+
+                    if sub_result.result_type == pipeline_entities.ResultType.INTERRUPT:
+                        self.ap.logger.debug(f"Stage {stage_container.inst_name} interrupted query {query}")
+                        break
+                    elif sub_result.result_type == pipeline_entities.ResultType.CONTINUE:
+                        query = sub_result.new_query
+                        await self._execute_from_stage(i + 1, query)
+                break
+
+            i += 1
+
+    async def process_query(self, query: entities.Query):
+        """处理请求
+        """
+        self.ap.logger.debug(f"Processing query {query}")
+
+        try:
+            await self._execute_from_stage(0, query)
+        except Exception as e:
+            self.ap.logger.error(f"处理请求时出错 query_id={query.query_id}: {e}")
+            self.ap.logger.debug(f"Traceback: {traceback.format_exc()}")
+            # traceback.print_exc()
+        finally:
+            self.ap.logger.debug(f"Query {query} processed")
+
+    async def run(self):
+        """运行控制器
+        """
+        await self.consumer()

pkg/core/entities.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import enum
+import typing
+import datetime
+import asyncio
+
+import pydantic
+import mirai
+
+from ..provider import entities as llm_entities
+from ..provider.requester import entities
+from ..provider.sysprompt import entities as sysprompt_entities
+from ..provider.tools import entities as tools_entities
+from ..platform import adapter as msadapter
+
+
+class LauncherTypes(enum.Enum):
+
+    PERSON = 'person'
+    """私聊"""
+
+    GROUP = 'group'
+    """群聊"""
+
+
+class Query(pydantic.BaseModel):
+    """一次请求的信息封装"""
+
+    query_id: int
+    """请求ID，添加进请求池时生成"""
+
+    launcher_type: LauncherTypes
+    """会话类型，platform设置"""
+
+    launcher_id: int
+    """会话ID，platform设置"""
+
+    sender_id: int
+    """发送者ID，platform设置"""
+
+    message_event: mirai.MessageEvent
+    """事件，platform收到的事件"""
+
+    message_chain: mirai.MessageChain
+    """消息链，platform收到的消息链"""
+
+    adapter: msadapter.MessageSourceAdapter
+    """适配器对象"""
+
+    session: typing.Optional[Session] = None
+    """会话对象，由前置处理器设置"""
+
+    messages: typing.Optional[list[llm_entities.Message]] = []
+    """历史消息列表，由前置处理器设置"""
+
+    prompt: typing.Optional[sysprompt_entities.Prompt] = None
+    """情景预设内容，由前置处理器设置"""
+
+    user_message: typing.Optional[llm_entities.Message] = None
+    """此次请求的用户消息对象，由前置处理器设置"""
+
+    use_model: typing.Optional[entities.LLMModelInfo] = None
+    """使用的模型，由前置处理器设置"""
+
+    use_funcs: typing.Optional[list[tools_entities.LLMFunction]] = None
+    """使用的函数，由前置处理器设置"""
+
+    resp_messages: typing.Optional[list[llm_entities.Message]] = []
+    """由provider生成的回复消息对象列表"""
+
+    resp_message_chain: typing.Optional[mirai.MessageChain] = None
+    """回复消息链，从resp_messages包装而得"""
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+class Conversation(pydantic.BaseModel):
+    """对话"""
+
+    prompt: sysprompt_entities.Prompt
+
+    messages: list[llm_entities.Message]
+
+    create_time: typing.Optional[datetime.datetime] = pydantic.Field(default_factory=datetime.datetime.now)
+
+    update_time: typing.Optional[datetime.datetime] = pydantic.Field(default_factory=datetime.datetime.now)
+
+    use_model: entities.LLMModelInfo
+
+    use_funcs: typing.Optional[list[tools_entities.LLMFunction]]
+
+
+class Session(pydantic.BaseModel):
+    """会话"""
+    launcher_type: LauncherTypes
+
+    launcher_id: int
+
+    sender_id: typing.Optional[int] = 0
+
+    use_prompt_name: typing.Optional[str] = 'default'
+
+    using_conversation: typing.Optional[Conversation] = None
+
+    conversations: typing.Optional[list[Conversation]] = []
+
+    create_time: typing.Optional[datetime.datetime] = pydantic.Field(default_factory=datetime.datetime.now)
+
+    update_time: typing.Optional[datetime.datetime] = pydantic.Field(default_factory=datetime.datetime.now)
+
+    semaphore: typing.Optional[asyncio.Semaphore] = None
+
+    class Config:
+        arbitrary_types_allowed = True

pkg/core/pool.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import asyncio
+
+import mirai
+
+from . import entities
+from ..platform import adapter as msadapter
+
+
+class QueryPool:
+
+    query_id_counter: int = 0
+
+    pool_lock: asyncio.Lock
+
+    queries: list[entities.Query]
+
+    condition: asyncio.Condition
+
+    def __init__(self):
+        self.query_id_counter = 0
+        self.pool_lock = asyncio.Lock()
+        self.queries = []
+        self.condition = asyncio.Condition(self.pool_lock)
+
+    async def add_query(
+        self,
+        launcher_type: entities.LauncherTypes,
+        launcher_id: int,
+        sender_id: int,
+        message_event: mirai.MessageEvent,
+        message_chain: mirai.MessageChain,
+        adapter: msadapter.MessageSourceAdapter
+    ) -> entities.Query:
+        async with self.condition:
+            query = entities.Query(
+                query_id=self.query_id_counter,
+                launcher_type=launcher_type,
+                launcher_id=launcher_id,
+                sender_id=sender_id,
+                message_event=message_event,
+                message_chain=message_chain,
+                resp_messages=[],
+                resp_message_chain=None,
+                adapter=adapter
+            )
+            self.queries.append(query)
+            self.query_id_counter += 1
+            self.condition.notify_all()
+
+    async def __aenter__(self):
+        await self.pool_lock.acquire()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        self.pool_lock.release()

pkg/database/manager.py

@@ -1,299 +0,0 @@
-import hashlib
-import json
-import logging
-import time
-from sqlite3 import Cursor
-
-import sqlite3
-
-import pkg.utils.context
-
-
-# 数据库管理
-# 为其他模块提供数据库操作接口
-class DatabaseManager:
-    conn = None
-    cursor = None
-
-    def __init__(self):
-
-        self.reconnect()
-
-        pkg.utils.context.set_database_manager(self)
-
-    # 连接到数据库文件
-    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:
-        # logging.debug('SQL: {}'.format(sql))
-        c = self.cursor.execute(*args, **kwargs)
-        self.conn.commit()
-        return c
-
-    # 初始化数据库的函数
-    def initialize_database(self):
-        self.execute("""
-        create table if not exists `sessions` (
-            `id` INTEGER PRIMARY KEY AUTOINCREMENT,
-            `name` varchar(255) not null,
-            `type` varchar(255) not null,
-            `number` bigint not null,
-            `create_timestamp` bigint not null,
-            `last_interact_timestamp` bigint not null,
-            `status` varchar(255) not null default 'on_going',
-            `prompt` text not null
-        )
-        """)
-
-        self.execute("""
-        create table if not exists `account_fee`(
-            `id` INTEGER PRIMARY KEY AUTOINCREMENT,
-            `key_md5` varchar(255) not null,
-            `timestamp` bigint not null,
-            `fee` DECIMAL(12,6) not null
-        )
-        """)
-
-        self.execute("""
-        create table if not exists `account_usage`(
-            `id` INTEGER PRIMARY KEY AUTOINCREMENT,
-            `json` text not null
-        )
-        """)
-        print('Database initialized.')
-
-    # session持久化
-    def persistence_session(self, subject_type: str, subject_number: int, create_timestamp: int,
-                            last_interact_timestamp: int, prompt: str):
-        # 检查是否已经有了此name和create_timestamp的session
-        # 如果有，就更新prompt和last_interact_timestamp
-        # 如果没有，就插入一条新的记录
-        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 (?, ?, ?, ?, ?, ?)
-            """
-
-            self.execute(sql,
-                         ("{}_{}".format(subject_type, subject_number), subject_type, subject_number, create_timestamp,
-                          last_interact_timestamp, prompt))
-        else:
-            sql = """
-            update `sessions` set `last_interact_timestamp` = ?, `prompt` = ? 
-            where `type` = ? and `number` = ? and `create_timestamp` = ?
-            """
-
-            self.execute(sql, (last_interact_timestamp, prompt, subject_type,
-                               subject_number, create_timestamp))
-
-    # 显式关闭一个session
-    def explicit_close_session(self, session_name: str, create_timestamp: int):
-        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("""
-        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("""
-        update `sessions` set `status` = 'expired' where `name` = '{}' and `create_timestamp` = {}
-        """.format(session_name, create_timestamp))
-
-    # 从数据库加载还没过期的session数据
-    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`
-        from `sessions` where `last_interact_timestamp` > {}
-        """.format(int(time.time()) - config.session_expire_time))
-        results = self.cursor.fetchall()
-        sessions = {}
-        for result in results:
-            session_name = result[0]
-            subject_type = result[1]
-            subject_number = result[2]
-            create_timestamp = result[3]
-            last_interact_timestamp = result[4]
-            prompt = result[5]
-            status = result[6]
-
-            # 当且仅当最后一个该对象的会话是on_going状态时，才会被加载
-            if status == 'on_going':
-                sessions[session_name] = {
-                    'subject_type': subject_type,
-                    'subject_number': subject_number,
-                    'create_timestamp': create_timestamp,
-                    'last_interact_timestamp': last_interact_timestamp,
-                    'prompt': prompt
-                }
-            else:
-                if session_name in sessions:
-                    del sessions[session_name]
-
-        return sessions
-
-    # 获取此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`
-        from `sessions` where `name` = '{}' and `last_interact_timestamp` < {} order by `last_interact_timestamp` desc
-        limit 1
-        """.format(session_name, cursor_timestamp))
-        results = self.cursor.fetchall()
-        if len(results) == 0:
-            return None
-        result = results[0]
-
-        session_name = result[0]
-        subject_type = result[1]
-        subject_number = result[2]
-        create_timestamp = result[3]
-        last_interact_timestamp = result[4]
-        prompt = result[5]
-        status = result[6]
-
-        return {
-            'subject_type': subject_type,
-            'subject_number': subject_number,
-            'create_timestamp': create_timestamp,
-            'last_interact_timestamp': last_interact_timestamp,
-            'prompt': prompt
-        }
-
-    # 获取此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`
-            from `sessions` where `name` = '{}' and `last_interact_timestamp` > {} order by `last_interact_timestamp` asc
-            limit 1
-            """.format(session_name, cursor_timestamp))
-        results = self.cursor.fetchall()
-        if len(results) == 0:
-            return None
-        result = results[0]
-
-        session_name = result[0]
-        subject_type = result[1]
-        subject_number = result[2]
-        create_timestamp = result[3]
-        last_interact_timestamp = result[4]
-        prompt = result[5]
-        status = result[6]
-
-        return {
-            'subject_type': subject_type,
-            'subject_number': subject_number,
-            'create_timestamp': create_timestamp,
-            'last_interact_timestamp': last_interact_timestamp,
-            'prompt': prompt
-        }
-
-    # 列出与某个对象的所有对话session
-    def list_history(self, session_name: str, capacity: int, page: int):
-        self.execute("""
-        select `name`, `type`, `number`, `create_timestamp`, `last_interact_timestamp`, `prompt`, `status`
-        from `sessions` where `name` = '{}' order by `last_interact_timestamp` desc limit {} offset {}
-        """.format(session_name, capacity, capacity * page))
-        results = self.cursor.fetchall()
-        sessions = []
-        for result in results:
-            session_name = result[0]
-            subject_type = result[1]
-            subject_number = result[2]
-            create_timestamp = result[3]
-            last_interact_timestamp = result[4]
-            prompt = result[5]
-            status = result[6]
-
-            sessions.append({
-                'subject_type': subject_type,
-                'subject_number': subject_number,
-                'create_timestamp': create_timestamp,
-                'last_interact_timestamp': last_interact_timestamp,
-                'prompt': prompt
-            })
-
-        return sessions
-
-    # 将apikey的使用量存进数据库
-    def dump_api_key_usage(self, api_keys: dict, usage: dict):
-        logging.debug('dumping api key usage...')
-        logging.debug(api_keys)
-        logging.debug(usage)
-        for api_key in api_keys:
-            # 计算key的md5值
-            key_md5 = hashlib.md5(api_keys[api_key].encode('utf-8')).hexdigest()
-            # 获取使用量
-            usage_count = 0
-            if key_md5 in usage:
-                usage_count = usage[key_md5]
-            # 将使用量存进数据库
-            # 先检查是否已存在
-            self.execute("""
-            select count(*) from `api_key_usage` where `key_md5` = '{}'""".format(key_md5))
-            result = self.cursor.fetchone()
-            if result[0] == 0:
-                # 不存在则插入
-                self.execute("""
-                insert into `api_key_usage` (`key_md5`, `usage`,`timestamp`) values ('{}', {}, {})
-                """.format(key_md5, usage_count, int(time.time())))
-            else:
-                # 存在则更新，timestamp设置为当前
-                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("""
-        select `key_md5`, `usage` from `api_key_usage`
-        """)
-        results = self.cursor.fetchall()
-        usage = {}
-        for result in results:
-            key_md5 = result[0]
-            usage_count = result[1]
-            usage[key_md5] = usage_count
-        return usage
-
-    def dump_usage_json(self, usage: dict):
-        json_str = json.dumps(usage)
-        self.execute("""
-        select count(*) from `account_usage`""")
-        result = self.cursor.fetchone()
-        if result[0] == 0:
-            # 不存在则插入
-            self.execute("""
-            insert into `account_usage` (`json`) values ('{}')
-            """.format(json_str))
-        else:
-            # 存在则更新
-            self.execute("""
-            update `account_usage` set `json` = '{}' where `id` = 1
-            """.format(json_str))
-
-    def load_usage_json(self):
-        self.execute("""
-        select `json` from `account_usage` order by id desc limit 1
-        """)
-        result = self.cursor.fetchone()
-        if result is None:
-            return None
-        else:
-            return result[0]

pkg/openai/dprompt.py

@@ -1,74 +0,0 @@
-# 多情景预设值管理
-
-__current__ = "default"
-
-__prompts_from_files__ = {}
-
-
-def read_prompt_from_file() -> str:
-    """从文件读取预设值"""
-    # 读取prompts/目录下的所有文件，以文件名为键，文件内容为值
-    # 保存在__prompts_from_files__中
-    global __prompts_from_files__
-    import os
-
-    __prompts_from_files__ = {}
-    for file in os.listdir("prompts"):
-        with open(os.path.join("prompts", file), encoding="utf-8") as f:
-            __prompts_from_files__[file] = f.read()
-
-
-def get_prompt_dict() -> dict:
-    """获取预设值字典"""
-    import config
-    default_prompt = config.default_prompt
-    if type(default_prompt) == str:
-        default_prompt = {"default": default_prompt}
-    elif type(default_prompt) == dict:
-        pass
-    else:
-        raise TypeError("default_prompt must be str or dict")
-
-    # 将文件中的预设值合并到default_prompt中
-    for key in __prompts_from_files__:
-        default_prompt[key] = __prompts_from_files__[key]
-
-    return default_prompt
-
-
-def set_current(name):
-    global __current__
-    for key in get_prompt_dict():
-        if key.lower().startswith(name.lower()):
-            __current__ = key
-            return
-    raise KeyError("未找到情景预设: " + name)
-
-
-def get_current():
-    global __current__
-    return __current__
-
-
-def set_to_default():
-    global __current__
-    default_dict = get_prompt_dict()
-
-    if "default" in default_dict:
-        __current__ = "default"
-    else:
-        __current__ = list(default_dict.keys())[0]
-
-
-def get_prompt(name: str = None) -> str:
-    """获取预设值"""
-    if name is None:
-        name = get_current()
-
-    default_dict = get_prompt_dict()
-
-    for key in default_dict:
-        if key.lower().startswith(name.lower()):
-            return default_dict[key]
-
-    raise KeyError("未找到情景预设: " + name)

pkg/openai/keymgr.py

@@ -1,84 +0,0 @@
-# 此模块提供了维护api-key的各种功能
-import hashlib
-import logging
-
-import pkg.plugin.host as plugin_host
-import pkg.plugin.models as plugin_models
-
-class KeysManager:
-    api_key = {}
-
-    # api-key的使用量
-    # 其中键为api-key的md5值，值为使用量
-    using_key = ""
-
-    alerted = []
-
-    # 在此list中的都是经超额报错标记过的api-key
-    # 记录的是key值，仅在运行时有效
-    exceeded = []
-
-    def get_using_key(self):
-        return self.using_key
-
-    def get_using_key_md5(self):
-        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
-
-        if type(api_key) is dict:
-            self.api_key = api_key
-        elif type(api_key) is str:
-            self.api_key = {
-                "default": api_key
-            }
-        elif type(api_key) is list:
-            for i in range(len(api_key)):
-                self.api_key[str(i)] = api_key[i]
-        # 从usage中删除未加载的api-key的记录
-        # 不删了，也许会运行时添加曾经有记录的api-key
-
-        self.auto_switch()
-
-    # 根据tested自动切换到可用的api-key
-    # 返回是否切换成功, 切换后的api-key的别名
-    def auto_switch(self) -> (bool, str):
-        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
-
-        self.using_key = list(self.api_key.values())[0]
-        logging.info("使用api-key:" + list(self.api_key.keys())[0])
-
-        return False, ""
-
-    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
-        self.exceeded.append(self.using_key)
-
-    def get_key_name(self, api_key):
-        """根据api-key获取其别名"""
-        for key_name in self.api_key:
-            if self.api_key[key_name] == api_key:
-                return key_name
-        return ""

pkg/openai/manager.py

@@ -1,75 +0,0 @@
-import logging
-
-import openai
-
-import pkg.openai.keymgr
-import pkg.utils.context
-import pkg.audit.gatherer
-from pkg.openai.modelmgr import ModelRequest, create_openai_model_request
-
-# 为其他模块提供与OpenAI交互的接口
-class OpenAIInteract:
-    api_params = {}
-
-    key_mgr: pkg.openai.keymgr.KeysManager = None
-
-    audit_mgr: pkg.audit.gatherer.DataGatherer = None
-
-    default_image_api_params = {
-        "size": "256x256",
-    }
-
-    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, prompts):
-        config = pkg.utils.context.get_config()
-
-        # 根据模型选择使用的接口
-        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()
-
-        logging.debug("OpenAI response: %s", response)
-
-        if 'model' in config.completion_api_params:
-            self.audit_mgr.report_text_model_usage(config.completion_api_params['model'],
-                                                   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'])
-
-        return ai.get_message()
-
-    def request_image(self, prompt):
-
-        config = pkg.utils.context.get_config()
-        params = config.image_api_params if hasattr(config, "image_api_params") else self.default_image_api_params
-
-        response = openai.Image.create(
-            prompt=prompt,
-            n=1,
-            **params
-        )
-
-        self.audit_mgr.report_image_model_usage(params['size'])
-
-        return response
-

pkg/openai/modelmgr.py

@@ -1,152 +0,0 @@
-# 提供与模型交互的抽象接口
-import openai, logging, threading, asyncio
-
-COMPLETION_MODELS = {
-    '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',
-}
-
-EDIT_MODELS = {
-
-}
-
-IMAGE_MODELS = {
-
-}
-
-
-class ModelRequest():
-    """GPT父类"""
-    can_chat = False
-    runtime:threading.Thread = None
-    ret = ""
-    proxy:str = None
-
-    def __init__(self, model_name, user_name, request_fun, http_proxy:str = None):
-        self.model_name = model_name
-        self.user_name = user_name
-        self.request_fun = request_fun
-        if http_proxy != None:
-            self.proxy = http_proxy
-            openai.proxy = self.proxy
-
-    async def __a_request__(self, **kwargs):
-        self.ret = await self.request_fun(**kwargs)
-
-    def request(self, **kwargs):
-        if self.proxy != None: #异步请求
-            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()
-        return
-
-    def get_total_tokens(self):
-        try:
-            return self.ret['usage']['total_tokens']
-        except Exception:
-            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,28 +0,0 @@
-# 计费模块
-# 已弃用 https://github.com/RockChinQ/QChatGPT/issues/81
-
-import logging
-
-pricing = {
-    "base": {  # 文字模型单位是1000字符
-        "text-davinci-003": 0.02,
-    },
-    "image": {
-        "256x256": 0.016,
-        "512x512": 0.018,
-        "1024x1024": 0.02,
-    }
-}
-
-
-def language_base_price(model, text):
-    salt_rate = 0.93
-    length = ((len(text.encode('utf-8')) - len(text)) / 2 + len(text)) * salt_rate
-    logging.debug("text length: %d" % length)
-
-    return pricing["base"][model] * length / 1000
-
-
-def image_price(size):
-    logging.debug("image size: %s" % size)
-    return pricing["image"][size]

pkg/openai/session.py

@@ -1,356 +0,0 @@
-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 = {}
-
-
-class SessionOfflineStatus:
-    ON_GOING = 'on_going'
-    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']
-        }
-    ]
-    # 警告
-    logging.warning(
-        """
-用户[{}]的数据已被重置，有可能是因为数据版本过旧或存储错误
-原始数据将备份在：
-{}""".format(session_name, bak_path)
-    )
-    return prompt
-
-# 从数据加载session
-def load_sessions():
-    global sessions
-
-    db_inst = pkg.utils.context.get_database_manager()
-
-    session_data = db_inst.load_valid_sessions()
-
-    for session_name in session_data:
-        logging.info('加载session: {}'.format(session_name))
-
-        temp_session = Session(session_name)
-        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']
-        try:
-            temp_session.prompt = json.loads(session_data[session_name]['prompt'])
-        except Exception:
-            temp_session.prompt = reset_session_prompt(session_name, session_data[session_name]['prompt'])
-            temp_session.persistence()
-
-        sessions[session_name] = temp_session
-
-
-# 获取指定名称的session，如果不存在则创建一个新的
-def get_session(session_name: str):
-    global sessions
-    if session_name not in sessions:
-        sessions[session_name] = Session(session_name)
-    return sessions[session_name]
-
-
-def dump_session(session_name: str):
-    global sessions
-    if session_name in sessions:
-        assert isinstance(sessions[session_name], Session)
-        sessions[session_name].persistence()
-        del sessions[session_name]
-
-
-# 通用的OpenAI API交互session
-# session内部保留了对话的上下文，
-# 收到用户消息后，将上下文提交给OpenAI API生成回复
-class Session:
-    name = ''
-
-    prompt = []
-
-    create_timestamp = 0
-
-    last_interact_timestamp = 0
-
-    just_switched_to_exist_session = False
-
-    response_lock = None
-
-    # 加锁
-    def acquire_response_lock(self):
-        logging.debug('{},lock acquire,{}'.format(self.name, self.response_lock))
-        self.response_lock.acquire()
-        logging.debug('{},lock acquire successfully,{}'.format(self.name, self.response_lock))
-
-    # 释放锁
-    def release_response_lock(self):
-        if self.response_lock.locked():
-            logging.debug('{},lock release,{}'.format(self.name, self.response_lock))
-            self.response_lock.release()
-            logging.debug('{},lock release successfully,{}'.format(self.name, self.response_lock))
-
-    # 从配置文件获取会话预设信息
-    def get_default_prompt(self, use_default: str=None):
-        config = pkg.utils.context.get_config()
-
-        import pkg.openai.dprompt as dprompt
-
-        if use_default is None:
-            current_default_prompt = dprompt.get_prompt(dprompt.get_current())
-        else:
-            current_default_prompt = dprompt.get_prompt(use_default)
-
-        return [
-            {
-                'role': 'user',
-                'content': current_default_prompt
-            },{
-                'role': 'assistant',
-                'content': 'ok'
-            }
-        ]
-
-    def __init__(self, name: str):
-        self.name = name
-        self.create_timestamp = int(time.time())
-        self.last_interact_timestamp = int(time.time())
-        self.schedule()
-
-        self.response_lock = threading.Lock()
-        self.prompt = self.get_default_prompt()
-
-    # 设定检查session最后一次对话是否超过过期时间的计时器
-    def schedule(self):
-        threading.Thread(target=self.expire_check_timer_loop, args=(self.create_timestamp,)).start()
-
-    # 检查session是否已经过期
-    def expire_check_timer_loop(self, create_timestamp: int):
-        global sessions
-        while True:
-            time.sleep(60)
-
-            # 不是此session已更换，退出
-            if self.create_timestamp != create_timestamp or self not in sessions.values():
-                return
-
-            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
-                del sessions[self.name]
-                return
-
-    # 请求回复
-    # 这个函数是阻塞的
-    def append(self, text: str) -> str:
-        self.last_interact_timestamp = int(time.time())
-
-        # 触发插件事件
-        if self.prompt == self.get_default_prompt():
-            args = {
-                'session_name': self.name,
-                'session': self,
-                'default_prompt': self.prompt,
-            }
-
-            event = pkg.plugin.host.emit(plugin_models.SessionFirstMessageReceived, **args)
-            if event.is_prevented_default():
-                return None
-
-        config = pkg.utils.context.get_config()
-        max_length = config.prompt_submit_length if hasattr(config, "prompt_submit_length") else 1024
-
-        # 向API请求补全
-        message = pkg.utils.context.get_openai_manager().request_completion(
-            self.cut_out(text, max_length),
-        )
-
-        # 成功获取，处理回复
-        res_test = message
-        res_ans = res_test
-
-        # 去除开头可能的提示
-        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})
-
-        if self.just_switched_to_exist_session:
-            self.just_switched_to_exist_session = False
-            self.set_ongoing()
-
-        return res_ans if res_ans[0]!='\n' else res_ans[1:]
-
-    # 删除上一回合并返回上一回合的问题
-    def undo(self) -> str:
-        self.last_interact_timestamp = int(time.time())
-
-        # 删除最后两个消息
-        if len(self.prompt) < 2:
-            raise Exception('之前无对话，无法撤销')
-    
-        question = self.prompt[-2]['content']
-        self.prompt = self.prompt[:-2]
-        
-        # 返回上一回合的问题
-        return question
-
-    # 构建对话体
-    def cut_out(self, msg: str, max_tokens: int) -> list:
-        """将现有prompt进行切割处理，使得新的prompt长度不超过max_tokens"""
-        # 如果用户消息长度超过max_tokens，直接返回
-        
-        temp_prompt = [
-                {
-                    'role': 'user',
-                    'content': msg
-                }
-            ]
-
-        token_count = len(msg)
-        # 倒序遍历prompt
-        for i in range(len(self.prompt) - 1, -1, -1):
-            if token_count >= max_tokens:
-                break
-
-            # 将prompt加到temp_prompt头部
-            temp_prompt.insert(0, self.prompt[i])
-            token_count += len(self.prompt[i]['content'])
-
-        logging.debug('cut_out: {}'.format(str(temp_prompt)))
-
-        return temp_prompt
-
-    # 持久化session
-    def persistence(self):
-        if self.prompt == self.get_default_prompt():
-            return
-
-        db_inst = pkg.utils.context.get_database_manager()
-
-        name_spt = self.name.split('_')
-
-        subject_type = name_spt[0]
-        subject_number = int(name_spt[1])
-
-        db_inst.persistence_session(subject_type, subject_number, self.create_timestamp, self.last_interact_timestamp,
-                                    json.dumps(self.prompt))
-
-    # 重置session
-    def reset(self, explicit: bool = False, expired: bool = False, schedule_new: bool = True, use_prompt: str = None):
-        if self.prompt[-1]['role'] != "system":
-            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(use_prompt)
-        self.create_timestamp = int(time.time())
-        self.last_interact_timestamp = int(time.time())
-        self.just_switched_to_exist_session = False
-
-        # self.response_lock = threading.Lock()
-
-        if schedule_new:
-            self.schedule()
-
-    # 将本session的数据库状态设置为on_going
-    def set_ongoing(self):
-        pkg.utils.context.get_database_manager().set_session_ongoing(self.name, self.create_timestamp)
-
-    # 切换到上一个session
-    def last_session(self):
-        last_one = pkg.utils.context.get_database_manager().last_session(self.name, self.last_interact_timestamp)
-        if last_one is None:
-            return None
-        else:
-            self.persistence()
-
-            self.create_timestamp = last_one['create_timestamp']
-            self.last_interact_timestamp = last_one['last_interact_timestamp']
-            try:
-                self.prompt = json.loads(last_one['prompt'])
-            except json.decoder.JSONDecodeError:
-                self.prompt = reset_session_prompt(self.name, last_one['prompt'])
-                self.persistence()
-
-            self.just_switched_to_exist_session = True
-            return self
-
-    # 切换到下一个session
-    def next_session(self):
-        next_one = pkg.utils.context.get_database_manager().next_session(self.name, self.last_interact_timestamp)
-        if next_one is None:
-            return None
-        else:
-            self.persistence()
-
-            self.create_timestamp = next_one['create_timestamp']
-            self.last_interact_timestamp = next_one['last_interact_timestamp']
-            try:
-                self.prompt = json.loads(next_one['prompt'])
-            except json.decoder.JSONDecodeError:
-                self.prompt = reset_session_prompt(self.name, next_one['prompt'])
-                self.persistence()
-
-            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)
-
-    def draw_image(self, prompt: str):
-        return pkg.utils.context.get_openai_manager().request_image(prompt)

pkg/pipeline/bansess/bansess.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+import re
+
+from .. import stage, entities, stagemgr
+from ...core import entities as core_entities
+from ...config import manager as cfg_mgr
+
+
+@stage.stage_class('BanSessionCheckStage')
+class BanSessionCheckStage(stage.PipelineStage):
+
+    async def initialize(self):
+        pass
+
+    async def process(
+        self,
+        query: core_entities.Query,
+        stage_inst_name: str
+    ) -> entities.StageProcessResult:
+        
+        found = False
+
+        mode = self.ap.pipeline_cfg.data['access-control']['mode']
+
+        sess_list = self.ap.pipeline_cfg.data['access-control'][mode]
+
+        if (query.launcher_type == 'group' and 'group_*' in sess_list) \
+            or (query.launcher_type == 'person' and 'person_*' in sess_list):
+            found = True
+        else:
+            for sess in sess_list:
+                if sess == f"{query.launcher_type}_{query.launcher_id}":
+                    found = True
+                    break
+
+        result = False
+
+        if mode == 'blacklist':
+            result = found
+
+        return entities.StageProcessResult(
+            result_type=entities.ResultType.CONTINUE if not result else entities.ResultType.INTERRUPT,
+            new_query=query,
+            debug_notice=f'根据访问控制忽略消息: {query.launcher_type}_{query.launcher_id}' if result else ''
+        )

pkg/pipeline/cntfilter/cntfilter.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import mirai
+
+from ...core import app
+
+from .. import stage, entities, stagemgr
+from ...core import entities as core_entities
+from ...config import manager as cfg_mgr
+from . import filter, entities as filter_entities
+from .filters import cntignore, banwords, baiduexamine
+
+
+@stage.stage_class('PostContentFilterStage')
+@stage.stage_class('PreContentFilterStage')
+class ContentFilterStage(stage.PipelineStage):
+
+    filter_chain: list[filter.ContentFilter]
+
+    def __init__(self, ap: app.Application):
+        self.filter_chain = []
+        super().__init__(ap)
+
+    async def initialize(self):
+        self.filter_chain.append(cntignore.ContentIgnore(self.ap))
+
+        if self.ap.pipeline_cfg.data['check-sensitive-words']:
+            self.filter_chain.append(banwords.BanWordFilter(self.ap))
+        
+        if self.ap.pipeline_cfg.data['baidu-cloud-examine']['enable']:
+            self.filter_chain.append(baiduexamine.BaiduCloudExamine(self.ap))
+
+        for filter in self.filter_chain:
+            await filter.initialize()
+
+    async def _pre_process(
+        self,
+        message: str,
+        query: core_entities.Query,
+    ) -> entities.StageProcessResult:
+        """请求llm前处理消息
+        只要有一个不通过就不放行，只放行 PASS 的消息
+        """
+        if not self.ap.pipeline_cfg.data['income-msg-check']:
+            return entities.StageProcessResult(
+                result_type=entities.ResultType.CONTINUE,
+                new_query=query
+            )
+        else:
+            for filter in self.filter_chain:
+                if filter_entities.EnableStage.PRE in filter.enable_stages:
+                    result = await filter.process(message)
+
+                    if result.level in [
+                        filter_entities.ResultLevel.BLOCK,
+                        filter_entities.ResultLevel.MASKED
+                    ]:
+                        return entities.StageProcessResult(
+                            result_type=entities.ResultType.INTERRUPT,
+                            new_query=query,
+                            user_notice=result.user_notice,
+                            console_notice=result.console_notice
+                        )
+                    elif result.level == filter_entities.ResultLevel.PASS:  # 传到下一个
+                        message = result.replacement
+            
+            query.message_chain = mirai.MessageChain(
+                mirai.Plain(message)
+            )
+
+            return entities.StageProcessResult(
+                result_type=entities.ResultType.CONTINUE,
+                new_query=query
+            )
+        
+    async def _post_process(
+        self,
+        message: str,
+        query: core_entities.Query,
+    ) -> entities.StageProcessResult:
+        """请求llm后处理响应
+        只要是 PASS 或者 MASKED 的就通过此 filter，将其 replacement 设置为message，进入下一个 filter
+        """
+        if message is None:
+            return entities.StageProcessResult(
+                result_type=entities.ResultType.CONTINUE,
+                new_query=query
+            )
+        else:
+            message = message.strip()
+            for filter in self.filter_chain:
+                if filter_entities.EnableStage.POST in filter.enable_stages:
+                    result = await filter.process(message)
+
+                    if result.level == filter_entities.ResultLevel.BLOCK:
+                        return entities.StageProcessResult(
+                            result_type=entities.ResultType.INTERRUPT,
+                            new_query=query,
+                            user_notice=result.user_notice,
+                            console_notice=result.console_notice
+                        )
+                    elif result.level in [
+                        filter_entities.ResultLevel.PASS,
+                        filter_entities.ResultLevel.MASKED
+                    ]:
+                        message = result.replacement
+
+            query.resp_messages[-1].content = message
+
+            return entities.StageProcessResult(
+                result_type=entities.ResultType.CONTINUE,
+                new_query=query
+            )
+
+    async def process(
+        self,
+        query: core_entities.Query,
+        stage_inst_name: str
+    ) -> entities.StageProcessResult:
+        """处理
+        """
+        if stage_inst_name == 'PreContentFilterStage':
+            return await self._pre_process(
+                str(query.message_chain).strip(),
+                query
+            )
+        elif stage_inst_name == 'PostContentFilterStage':
+            return await self._post_process(
+                query.resp_messages[-1].content,
+                query
+            )
+        else:
+            raise ValueError(f'未知的 stage_inst_name: {stage_inst_name}')

pkg/pipeline/cntfilter/entities.py

@@ -0,0 +1,64 @@
+
+import typing
+import enum
+
+import pydantic
+
+
+class ResultLevel(enum.Enum):
+    """结果等级"""
+    PASS = enum.auto()
+    """通过"""
+
+    WARN = enum.auto()
+    """警告"""
+
+    MASKED = enum.auto()
+    """已掩去"""
+
+    BLOCK = enum.auto()
+    """阻止"""
+
+
+class EnableStage(enum.Enum):
+    """启用阶段"""
+    PRE = enum.auto()
+    """预处理"""
+
+    POST = enum.auto()
+    """后处理"""
+
+
+class FilterResult(pydantic.BaseModel):
+    level: ResultLevel
+
+    replacement: str
+    """替换后的消息"""
+
+    user_notice: str
+    """不通过时，用户提示消息"""
+
+    console_notice: str
+    """不通过时，控制台提示消息"""
+
+
+class ManagerResultLevel(enum.Enum):
+    """处理器结果等级"""
+    CONTINUE = enum.auto()
+    """继续"""
+
+    INTERRUPT = enum.auto()
+    """中断"""
+
+class FilterManagerResult(pydantic.BaseModel):
+
+    level: ManagerResultLevel
+
+    replacement: str
+    """替换后的消息"""
+
+    user_notice: str
+    """用户提示消息"""
+
+    console_notice: str
+    """控制台提示消息"""

pkg/pipeline/cntfilter/filter.py

@@ -0,0 +1,34 @@
+# 内容过滤器的抽象类
+from __future__ import annotations
+import abc
+
+from ...core import app
+from . import entities
+
+
+class ContentFilter(metaclass=abc.ABCMeta):
+
+    ap: app.Application
+
+    def __init__(self, ap: app.Application):
+        self.ap = ap
+
+    @property
+    def enable_stages(self):
+        """启用的阶段
+        """
+        return [
+            entities.EnableStage.PRE,
+            entities.EnableStage.POST
+        ]
+
+    async def initialize(self):
+        """初始化过滤器
+        """
+        pass
+
+    @abc.abstractmethod
+    async def process(self, message: str) -> entities.FilterResult:
+        """处理消息
+        """
+        raise NotImplementedError

pkg/pipeline/cntfilter/filters/baiduexamine.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import aiohttp
+
+from .. import entities
+from .. import filter as filter_model
+
+
+BAIDU_EXAMINE_URL = "https://aip.baidubce.com/rest/2.0/solution/v1/text_censor/v2/user_defined?access_token={}"
+BAIDU_EXAMINE_TOKEN_URL = "https://aip.baidubce.com/oauth/2.0/token"
+
+
+class BaiduCloudExamine(filter_model.ContentFilter):
+    """百度云内容审核"""
+
+    async def _get_token(self) -> str:
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                BAIDU_EXAMINE_TOKEN_URL,
+                params={
+                    "grant_type": "client_credentials",
+                    "client_id": self.ap.pipeline_cfg.data['baidu-cloud-examine']['api-key'],
+                    "client_secret": self.ap.pipeline_cfg.data['baidu-cloud-examine']['api-secret']
+                }
+            ) as resp:
+                return (await resp.json())['access_token']
+
+    async def process(self, message: str) -> entities.FilterResult:
+
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                BAIDU_EXAMINE_URL.format(await self._get_token()),
+                headers={'Content-Type': 'application/x-www-form-urlencoded', 'Accept': 'application/json'},
+                data=f"text={message}".encode('utf-8')
+            ) as resp:
+                result = await resp.json()
+
+                if "error_code" in result:
+                    return entities.FilterResult(
+                        level=entities.ResultLevel.BLOCK,
+                        replacement=message,
+                        user_notice='',
+                        console_notice=f"百度云判定出错，错误信息：{result['error_msg']}"
+                    )
+                else:
+                    conclusion = result["conclusion"]
+
+                    if conclusion in ("合规"):
+                        return entities.FilterResult(
+                            level=entities.ResultLevel.PASS,
+                            replacement=message,
+                            user_notice='',
+                            console_notice=f"百度云判定结果：{conclusion}"
+                        )
+                    else:
+                        return entities.FilterResult(
+                            level=entities.ResultLevel.BLOCK,
+                            replacement=message,
+                            user_notice="消息中存在不合适的内容, 请修改",
+                            console_notice=f"百度云判定结果：{conclusion}"
+                        )

pkg/pipeline/cntfilter/filters/banwords.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+import re
+
+from .. import filter as filter_model
+from .. import entities
+from ....config import manager as cfg_mgr
+
+
+class BanWordFilter(filter_model.ContentFilter):
+    """根据内容禁言"""
+
+    sensitive: cfg_mgr.ConfigManager
+
+    async def initialize(self):
+        self.sensitive = await cfg_mgr.load_json_config(
+            "data/config/sensitive-words.json",
+            "templates/sensitive-words.json"
+        )
+
+    async def process(self, message: str) -> entities.FilterResult:
+        found = False
+
+        for word in self.sensitive.data['words']:
+            match = re.findall(word, message)
+
+            if len(match) > 0:
+                found = True
+
+                for i in range(len(match)):
+                    if self.sensitive.data['mask_word'] == "":
+                        message = message.replace(
+                            match[i], self.sensitive.data['mask'] * len(match[i])
+                        )
+                    else:
+                        message = message.replace(
+                            match[i], self.sensitive.data['mask_word']
+                        )
+
+        return entities.FilterResult(
+            level=entities.ResultLevel.MASKED if found else entities.ResultLevel.PASS,
+            replacement=message,
+            user_notice='消息中存在不合适的内容, 请修改' if found else '',
+            console_notice=''
+        )

pkg/pipeline/cntfilter/filters/cntignore.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+import re
+
+from .. import entities
+from .. import filter as filter_model
+
+
+class ContentIgnore(filter_model.ContentFilter):
+    """根据内容忽略消息"""
+
+    @property
+    def enable_stages(self):
+        return [
+            entities.EnableStage.PRE,
+        ]
+
+    async def process(self, message: str) -> entities.FilterResult:
+        if 'prefix' in self.ap.pipeline_cfg.data['ignore-rules']:
+            for rule in self.ap.pipeline_cfg.data['ignore-rules']['prefix']:
+                if message.startswith(rule):
+                    return entities.FilterResult(
+                        level=entities.ResultLevel.BLOCK,
+                        replacement='',
+                        user_notice='',
+                        console_notice='根据 ignore_rules 中的 prefix 规则，忽略消息'
+                    )
+        
+        if 'regexp' in self.ap.pipeline_cfg.data['ignore-rules']:
+            for rule in self.ap.pipeline_cfg.data['ignore-rules']['regexp']:
+                if re.search(rule, message):
+                    return entities.FilterResult(
+                        level=entities.ResultLevel.BLOCK,
+                        replacement='',
+                        user_notice='',
+                        console_notice='根据 ignore_rules 中的 regexp 规则，忽略消息'
+                    )
+
+        return entities.FilterResult(
+            level=entities.ResultLevel.PASS,
+            replacement=message,
+            user_notice='',
+            console_notice=''
+        )

pkg/pipeline/entities.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import enum
+import typing
+
+import pydantic
+import mirai
+import mirai.models.message as mirai_message
+
+from ..core import entities
+
+
+class ResultType(enum.Enum):
+
+    CONTINUE = enum.auto()
+    """继续流水线"""
+
+    INTERRUPT = enum.auto()
+    """中断流水线"""
+
+
+class StageProcessResult(pydantic.BaseModel):
+    
+    result_type: ResultType
+
+    new_query: entities.Query
+
+    user_notice: typing.Optional[typing.Union[str, list[mirai_message.MessageComponent], mirai.MessageChain, None]] = []
+    """只要设置了就会发送给用户"""
+
+    # TODO delete
+    # admin_notice: typing.Optional[typing.Union[str, list[mirai_message.MessageComponent], mirai.MessageChain, None]] = []
+    """只要设置了就会发送给管理员"""
+
+    console_notice: typing.Optional[str] = ''
+    """只要设置了就会输出到控制台"""
+
+    debug_notice: typing.Optional[str] = ''
+
+    error_notice: typing.Optional[str] = ''

pkg/pipeline/longtext/longtext.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+import os
+import traceback
+
+from PIL import Image, ImageDraw, ImageFont
+from mirai.models.message import MessageComponent, Plain, MessageChain
+
+from ...core import app
+from . import strategy
+from .strategies import image, forward
+from .. import stage, entities, stagemgr
+from ...core import entities as core_entities
+from ...config import manager as cfg_mgr
+
+
+@stage.stage_class("LongTextProcessStage")
+class LongTextProcessStage(stage.PipelineStage):
+
+    strategy_impl: strategy.LongTextStrategy
+
+    async def initialize(self):
+        config = self.ap.platform_cfg.data['long-text-process']
+        if config['strategy'] == 'image':
+            use_font = config['font-path']
+            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):
+                            self.ap.logger.warn("未找到字体文件，且无法使用Windows自带字体，更换为转发消息组件以发送长消息，您可以在config.py中调整相关设置。")
+                            config['blob_message_strategy'] = "forward"
+                        else:
+                            self.ap.logger.info("使用Windows自带字体：" + use_font)
+                            config['font-path'] = use_font
+                    else:
+                        self.ap.logger.warn("未找到字体文件，且无法使用系统自带字体，更换为转发消息组件以发送长消息，您可以在config.py中调整相关设置。")
+
+                        self.ap.platform_cfg.data['long-text-process']['strategy'] = "forward"
+            except:
+                traceback.print_exc()
+                self.ap.logger.error("加载字体文件失败({})，更换为转发消息组件以发送长消息，您可以在config.py中调整相关设置。".format(use_font))
+
+                self.ap.platform_cfg.data['long-text-process']['strategy'] = "forward"
+        
+        if config['strategy'] == 'image':
+            self.strategy_impl = image.Text2ImageStrategy(self.ap)
+        elif config['strategy'] == 'forward':
+            self.strategy_impl = forward.ForwardComponentStrategy(self.ap)
+        await self.strategy_impl.initialize()
+    
+    async def process(self, query: core_entities.Query, stage_inst_name: str) -> entities.StageProcessResult:
+        if len(str(query.resp_message_chain)) > self.ap.platform_cfg.data['long-text-process']['threshold']:
+            query.resp_message_chain = MessageChain(await self.strategy_impl.process(str(query.resp_message_chain), query))
+        return entities.StageProcessResult(
+            result_type=entities.ResultType.CONTINUE,
+            new_query=query
+        )

pkg/pipeline/longtext/strategies/forward.py

@@ -0,0 +1,63 @@
+# 转发消息组件
+from __future__ import annotations
+import typing
+
+from mirai.models import MessageChain
+from mirai.models.message import MessageComponent, ForwardMessageNode
+from mirai.models.base import MiraiBaseModel
+
+from .. import strategy as strategy_model
+from ....core import entities as core_entities
+
+
+class ForwardMessageDiaplay(MiraiBaseModel):
+    title: str = "群聊的聊天记录"
+    brief: str = "[聊天记录]"
+    source: str = "聊天记录"
+    preview: typing.List[str] = []
+    summary: str = "查看x条转发消息"
+
+
+class Forward(MessageComponent):
+    """合并转发。"""
+    type: str = "Forward"
+    """消息组件类型。"""
+    display: ForwardMessageDiaplay
+    """显示信息"""
+    node_list: typing.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 '[聊天记录]'
+
+
+class ForwardComponentStrategy(strategy_model.LongTextStrategy):
+
+    async def process(self, message: str, query: core_entities.Query) -> list[MessageComponent]:
+        display = ForwardMessageDiaplay(
+            title="群聊的聊天记录",
+            brief="[聊天记录]",
+            source="聊天记录",
+            preview=["QQ用户: "+message],
+            summary="查看1条转发消息"
+        )
+
+        node_list = [
+            ForwardMessageNode(
+                sender_id=query.adapter.bot_account_id,
+                sender_name='QQ用户',
+                message_chain=MessageChain([message])
+            )
+        ]
+
+        forward = Forward(
+            display=display,
+            node_list=node_list
+        )
+
+        return [forward]

pkg/pipeline/longtext/strategies/image.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+import typing
+import os
+import base64
+import time
+import re
+
+from PIL import Image, ImageDraw, ImageFont
+
+from mirai.models import MessageChain, Image as ImageComponent
+from mirai.models.message import MessageComponent
+
+from .. import strategy as strategy_model
+from ....core import entities as core_entities
+
+
+class Text2ImageStrategy(strategy_model.LongTextStrategy):
+
+    text_render_font: ImageFont.FreeTypeFont
+
+    async def initialize(self):
+        self.text_render_font = ImageFont.truetype(self.ap.platform_cfg.data['long-text-process']['font-path'], 32, encoding="utf-8")
+    
+    async def process(self, message: str, query: core_entities.Query) -> list[MessageComponent]:
+        img_path = self.text_to_image(
+            text_str=message,
+            save_as='temp/{}.png'.format(int(time.time()))
+        )
+
+        compressed_path, size = self.compress_image(
+            img_path,
+            outfile="temp/{}_compressed.png".format(int(time.time()))
+        )
+
+        with open(compressed_path, 'rb') as f:
+            img = f.read()
+
+        b64 = base64.b64encode(img)
+
+        # 删除图片
+        os.remove(img_path)
+
+        if os.path.exists(compressed_path):
+            os.remove(compressed_path)
+
+        return [
+            ImageComponent(
+                base64=b64.decode('utf-8'),
+            )
+        ]
+
+    def indexNumber(self, 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(self, file):
+        # 获取文件大小:KB
+        size = os.path.getsize(file)
+        return size / 1024
+
+
+    def get_outfile(self, infile, outfile):
+        if outfile:
+            return outfile
+        dir, suffix = os.path.splitext(infile)
+        outfile = '{}-out{}'.format(dir, suffix)
+        return outfile
+
+
+    def compress_image(self, infile, outfile='', kb=100, step=20, quality=90):
+        """不改变图片尺寸压缩到指定大小
+        :param infile: 压缩源文件
+        :param outfile: 压缩文件保存地址
+        :param mb: 压缩目标,KB
+        :param step: 每次调整的压缩比率
+        :param quality: 初始压缩比率
+        :return: 压缩文件地址，压缩文件大小
+        """
+        o_size = self.get_size(infile)
+        if o_size <= kb:
+            return infile, o_size
+        outfile = self.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 = self.get_size(outfile)
+        return outfile, self.get_size(outfile)
+
+
+    def text_to_image(self, text_str: str, save_as="temp.png", width=800):
+
+        text_str = text_str.replace("\t", "    ")
+        
+        # 分行
+        lines = text_str.split('\n')
+
+        # 计算并分割
+        final_lines = []
+
+        text_width = width-80
+
+        self.ap.logger.debug("lines: {}, text_width: {}".format(lines, text_width))
+        for line in lines:
+            # 如果长了就分割
+            line_width = self.text_render_font.getlength(line)
+            self.ap.logger.debug("line_width: {}".format(line_width))
+            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 = self.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 = self.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')
+
+        self.ap.logger.debug("正在绘制图片...")
+        # 绘制正文
+        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=self.text_render_font)
+            # 遍历此行,检查是否有emoji
+            idx_in_line = 0
+            for ch in final_line:
+                # 检查字符占位宽
+                char_code = ord(ch)
+                if char_code >= 127:
+                    idx_in_line += 1
+                else:
+                    idx_in_line += 0.5
+
+            line_number += 1
+
+        self.ap.logger.debug("正在保存图片...")
+        img.save(save_as)
+
+        return save_as

pkg/pipeline/longtext/strategy.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+import abc
+import typing
+
+import mirai
+from mirai.models.message import MessageComponent
+
+from ...core import app
+from ...core import entities as core_entities
+
+
+class LongTextStrategy(metaclass=abc.ABCMeta):
+    ap: app.Application
+
+    def __init__(self, ap: app.Application):
+        self.ap = ap
+    
+    async def initialize(self):
+        pass
+    
+    @abc.abstractmethod
+    async def process(self, message: str, query: core_entities.Query) -> list[MessageComponent]:
+        return []

pkg/pipeline/preproc/preproc.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from .. import stage, entities, stagemgr
+from ...core import entities as core_entities
+from ...provider import entities as llm_entities
+from ...plugin import events
+
+
+@stage.stage_class("PreProcessor")
+class PreProcessor(stage.PipelineStage):
+    """预处理器
+    """
+
+    async def process(
+        self,
+        query: core_entities.Query,
+        stage_inst_name: str,
+    ) -> entities.StageProcessResult:
+        """处理
+        """
+        session = await self.ap.sess_mgr.get_session(query)
+
+        conversation = await self.ap.sess_mgr.get_conversation(session)
+
+        # 从会话取出消息和情景预设到query
+        query.session = session
+        query.prompt = conversation.prompt.copy()
+        query.messages = conversation.messages.copy()
+
+        query.user_message = llm_entities.Message(
+            role='user',
+            content=str(query.message_chain).strip()
+        )
+
+        query.use_model = conversation.use_model
+
+        query.use_funcs = conversation.use_funcs
+
+        # =========== 触发事件 PromptPreProcessing
+        session = query.session
+
+        event_ctx = await self.ap.plugin_mgr.emit_event(
+            event=events.PromptPreProcessing(
+                session_name=f'{session.launcher_type.value}_{session.launcher_id}',
+                default_prompt=query.prompt.messages,
+                prompt=query.messages,
+                query=query
+            )
+        )
+
+        query.prompt.messages = event_ctx.event.default_prompt
+        query.messages = event_ctx.event.prompt
+
+        # 根据模型max_tokens剪裁
+        max_tokens = min(query.use_model.max_tokens, self.ap.pipeline_cfg.data['submit-messages-tokens'])
+
+        test_messages = query.prompt.messages + query.messages + [query.user_message]
+
+        while await query.use_model.tokenizer.count_token(test_messages, query.use_model) > max_tokens:
+            # 前文都pop完了，还是大于max_tokens，由于prompt和user_messages不能删减，报错
+            if len(query.prompt.messages) == 0:
+                return entities.StageProcessResult(
+                    result_type=entities.ResultType.INTERRUPT,
+                    new_query=query,
+                    user_notice='输入内容过长，请减少情景预设或者输入内容长度',
+                    console_notice='输入内容过长，请减少情景预设或者输入内容长度，或者增大配置文件中的 submit-messages-tokens 项（但不能超过所用模型最大tokens数）'
+                )
+
+            query.messages.pop(0) # pop第一个肯定是role=user的
+            # 继续pop到第二个role=user前一个
+            while len(query.messages) > 0 and query.messages[0].role != 'user':
+                query.messages.pop(0)
+
+            test_messages = query.prompt.messages + query.messages + [query.user_message]
+
+        return entities.StageProcessResult(
+            result_type=entities.ResultType.CONTINUE,
+            new_query=query
+        )

pkg/pipeline/process/handler.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import abc
+
+from ...core import app
+from ...core import entities as core_entities
+from .. import entities
+
+
+class MessageHandler(metaclass=abc.ABCMeta):
+    
+    ap: app.Application
+
+    def __init__(self, ap: app.Application):
+        self.ap = ap
+
+    async def initialize(self):
+        pass
+
+    @abc.abstractmethod
+    async def handle(
+        self,
+        query: core_entities.Query,
+    ) -> entities.StageProcessResult:
+        raise NotImplementedError
+
+    def cut_str(self, s: str) -> str:
+        """
+        取字符串第一行，最多20个字符，若有多行，或超过20个字符，则加省略号
+        """
+        s0 = s.split('\n')[0]
+        if len(s0) > 20 or '\n' in s:
+            s0 = s0[:20] + '...'
+        return s0

pkg/pipeline/process/handlers/chat.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import typing
+import time
+import traceback
+
+import mirai
+
+from .. import handler
+from ... import entities
+from ....core import entities as core_entities
+from ....provider import entities as llm_entities
+from ....plugin import events
+
+
+class ChatMessageHandler(handler.MessageHandler):
+
+    async def handle(
+        self,
+        query: core_entities.Query,
+    ) -> typing.AsyncGenerator[entities.StageProcessResult, None]:
+        """处理
+        """
+        # 取session
+        # 取conversation
+        # 调API
+        #   生成器
+
+        # 触发插件事件
+        event_class = events.PersonNormalMessageReceived if query.launcher_type == core_entities.LauncherTypes.PERSON else events.GroupNormalMessageReceived
+
+        event_ctx = await self.ap.plugin_mgr.emit_event(
+            event=event_class(
+                launcher_type=query.launcher_type.value,
+                launcher_id=query.launcher_id,
+                sender_id=query.sender_id,
+                text_message=str(query.message_chain),
+                query=query
+            )
+        )
+
+        if event_ctx.is_prevented_default():
+            if event_ctx.event.reply is not None:
+                query.resp_message_chain = mirai.MessageChain(event_ctx.event.reply)
+
+                yield entities.StageProcessResult(
+                    result_type=entities.ResultType.CONTINUE,
+                    new_query=query
+                )
+            else:
+                yield entities.StageProcessResult(
+                    result_type=entities.ResultType.INTERRUPT,
+                    new_query=query
+                )
+        else:
+
+            if not self.ap.provider_cfg.data['enable-chat']:
+                yield entities.StageProcessResult(
+                    result_type=entities.ResultType.INTERRUPT,
+                    new_query=query,
+                )
+
+            if event_ctx.event.alter is not None:
+                query.message_chain = mirai.MessageChain([
+                    mirai.Plain(event_ctx.event.alter)
+                ])
+
+            query.messages.append(
+                query.user_message
+            )
+
+            text_length = 0
+
+            start_time = time.time()
+
+            try:
+
+                async for result in query.use_model.requester.request(query):
+                    query.resp_messages.append(result)
+
+                    self.ap.logger.info(f'对话({query.query_id})响应: {self.cut_str(result.readable_str())}')
+
+                    if result.content is not None:
+                        text_length += len(result.content)
+
+                    yield entities.StageProcessResult(
+                        result_type=entities.ResultType.CONTINUE,
+                        new_query=query
+                    )
+            except Exception as e:
+                
+                self.ap.logger.error(f'对话({query.query_id})请求失败: {str(e)}')
+
+                yield entities.StageProcessResult(
+                    result_type=entities.ResultType.INTERRUPT,
+                    new_query=query,
+                    user_notice='请求失败' if self.ap.platform_cfg.data['hide-exception-info'] else f'{e}',
+                    error_notice=f'{e}',
+                    debug_notice=traceback.format_exc()
+                )
+            finally:
+                query.session.using_conversation.messages.append(query.user_message)
+                query.session.using_conversation.messages.extend(query.resp_messages)
+
+                await self.ap.ctr_mgr.usage.post_query_record(
+                    session_type=query.session.launcher_type.value,
+                    session_id=str(query.session.launcher_id),
+                    query_ability_provider="QChatGPT.Chat",
+                    usage=text_length,
+                    model_name=query.use_model.name,
+                    response_seconds=int(time.time() - start_time),
+                    retry_times=-1,
+                )

pkg/pipeline/process/handlers/command.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+import typing
+
+import mirai
+
+from .. import handler
+from ... import entities
+from ....core import entities as core_entities
+from ....provider import entities as llm_entities
+from ....plugin import events
+
+
+class CommandHandler(handler.MessageHandler):
+
+    async def handle(
+        self,
+        query: core_entities.Query,
+    ) -> typing.AsyncGenerator[entities.StageProcessResult, None]:
+        """处理
+        """
+
+        event_class = events.PersonCommandSent if query.launcher_type == core_entities.LauncherTypes.PERSON else events.GroupCommandSent
+
+
+        privilege = 1
+        
+        if f'{query.launcher_type.value}_{query.launcher_id}' in self.ap.system_cfg.data['admin-sessions']:
+            privilege = 2
+
+        spt = str(query.message_chain).strip().split(' ')
+
+        event_ctx = await self.ap.plugin_mgr.emit_event(
+            event=event_class(
+                launcher_type=query.launcher_type.value,
+                launcher_id=query.launcher_id,
+                sender_id=query.sender_id,
+                command=spt[0],
+                params=spt[1:] if len(spt) > 1 else [],
+                text_message=str(query.message_chain),
+                is_admin=(privilege==2),
+                query=query
+            )
+        )
+
+        if event_ctx.is_prevented_default():
+
+            if event_ctx.event.reply is not None:
+                mc = mirai.MessageChain(event_ctx.event.reply)
+
+                query.resp_messages.append(
+                    llm_entities.Message(
+                        role='command',
+                        content=str(mc),
+                    )
+                )
+
+                yield entities.StageProcessResult(
+                    result_type=entities.ResultType.CONTINUE,
+                    new_query=query
+                )
+            else:
+                yield entities.StageProcessResult(
+                    result_type=entities.ResultType.INTERRUPT,
+                    new_query=query
+                )
+
+        else:
+
+            if event_ctx.event.alter is not None:
+                query.message_chain = mirai.MessageChain([
+                    mirai.Plain(event_ctx.event.alter)
+                ])
+
+            session = await self.ap.sess_mgr.get_session(query)
+
+            command_text = str(query.message_chain).strip()[1:]
+
+            async for ret in self.ap.cmd_mgr.execute(
+                command_text=command_text,
+                query=query,
+                session=session
+            ):
+                if ret.error is not None:
+                    # query.resp_message_chain = mirai.MessageChain([
+                    #     mirai.Plain(str(ret.error))
+                    # ])
+                    query.resp_messages.append(
+                        llm_entities.Message(
+                            role='command',
+                            content=str(ret.error),
+                        )
+                    )
+
+                    self.ap.logger.info(f'命令({query.query_id})报错: {self.cut_str(str(ret.error))}')
+
+                    yield entities.StageProcessResult(
+                        result_type=entities.ResultType.CONTINUE,
+                        new_query=query
+                    )
+                elif ret.text is not None:
+                    # query.resp_message_chain = mirai.MessageChain([
+                    #     mirai.Plain(ret.text)
+                    # ])
+                    query.resp_messages.append(
+                        llm_entities.Message(
+                            role='command',
+                            content=ret.text,
+                        )
+                    )
+
+                    self.ap.logger.info(f'命令返回: {self.cut_str(ret.text)}')
+
+                    yield entities.StageProcessResult(
+                        result_type=entities.ResultType.CONTINUE,
+                        new_query=query
+                    )
+                else:
+                    yield entities.StageProcessResult(
+                        result_type=entities.ResultType.INTERRUPT,
+                        new_query=query
+                    )

pkg/pipeline/process/process.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from ...core import app, entities as core_entities
+from . import handler
+from .handlers import chat, command
+from .. import entities
+from .. import stage, entities, stagemgr
+from ...core import entities as core_entities
+from ...config import manager as cfg_mgr
+
+
+@stage.stage_class("MessageProcessor")
+class Processor(stage.PipelineStage):
+
+    cmd_handler: handler.MessageHandler
+
+    chat_handler: handler.MessageHandler
+
+    async def initialize(self):
+        self.cmd_handler = command.CommandHandler(self.ap)
+        self.chat_handler = chat.ChatMessageHandler(self.ap)
+
+        await self.cmd_handler.initialize()
+        await self.chat_handler.initialize()
+
+    async def process(
+        self,
+        query: core_entities.Query,
+        stage_inst_name: str,
+    ) -> entities.StageProcessResult:
+        """处理
+        """
+        message_text = str(query.message_chain).strip()
+
+        self.ap.logger.info(f"处理 {query.launcher_type.value}_{query.launcher_id} 的请求({query.query_id}): {message_text}")
+
+        async def generator():
+            if message_text.startswith('!') or message_text.startswith('！'):
+                async for result in self.cmd_handler.handle(query):
+                    yield result
+            else:
+                async for result in self.chat_handler.handle(query):
+                    yield result
+        
+        return generator()