chore: release v2.6.8

Feat: 支持 Google Gemini Pro 模型

.devcontainer/devcontainer.json

@@ -1,34 +0,0 @@
-// For format details, see https://aka.ms/devcontainer.json. For config options, see the
-// README at: https://github.com/devcontainers/templates/tree/main/src/python
-{
-	"name": "QChatGPT 3.10",
-	// Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
-	"image": "mcr.microsoft.com/devcontainers/python:0-3.10",
-
-	// Features to add to the dev container. More info: https://containers.dev/features.
-	// "features": {},
-
-	// Use 'forwardPorts' to make a list of ports inside the container available locally.
-	// "forwardPorts": [],
-
-	// Use 'postCreateCommand' to run commands after the container is created.
-	// "postCreateCommand": "pip3 install --user -r requirements.txt",
-
-	// Configure tool-specific properties.
-	// "customizations": {},
-	"customizations": {
-		"codespaces": {
-		  "repositories": {
-			"RockChinQ/QChatGPT": {
-			  "permissions": "write-all"
-			},
-			"RockChinQ/revLibs": {
-			  "permissions": "write-all"
-			}
-		  }
-		}
-	  }
-
-	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
-	// "remoteUser": "root"
-}

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -45,7 +45,7 @@ body:
       required: true
   - type: textarea
     attributes:
-      label: 报错信息
-      description: 请提供完整的**控制台**报错信息（若有）
+      label: 日志信息
+      description: 请提供完整的 **登录框架 和 QChatGPT控制台**的相关日志信息（若有），不提供日志信息**无法**为您排查问题
     validations:
       required: false

.github/dependabot.yml

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

.github/workflows/build_docker_image.yml

@@ -0,0 +1,38 @@
+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 }}
+          fi
+      - name: Check GITHUB_REF env
+        run: echo $GITHUB_REF
+      - name: Get version
+        id: get_version
+        if: (startsWith(env.GITHUB_REF, 'refs/tags/')||startsWith(github.ref, 'refs/tags/')) && startsWith(github.repository, 'RockChinQ/QChatGPT')
+        run: echo ::set-output name=VERSION::${GITHUB_REF/refs\/tags\//}
+      - name: Build  # image name: rockchin/qchatgpt:<VERSION>
+        run: docker build --network=host -t rockchin/qchatgpt:${{ steps.get_version.outputs.VERSION }} -t rockchin/qchatgpt:latest .
+      - name: Login to Registry
+        run: docker login --username=${{ secrets.DOCKER_USERNAME }} --password ${{ secrets.DOCKER_PASSWORD }}
+      
+      - name: Push image
+        if: (startsWith(env.GITHUB_REF, 'refs/tags/')||startsWith(github.ref, 'refs/tags/')) && startsWith(github.repository, 'RockChinQ/QChatGPT')
+        run: docker push rockchin/qchatgpt:${{ steps.get_version.outputs.VERSION }}
+
+      - name: Push latest image
+        if: (startsWith(env.GITHUB_REF, 'refs/tags/')||startsWith(github.ref, 'refs/tags/')) && startsWith(github.repository, 'RockChinQ/QChatGPT')
+        run: docker push rockchin/qchatgpt:latest

.github/workflows/sync-wiki.yml

@@ -1,7 +1,14 @@
 name: Update Wiki
 
 on:
+  pull_request:
+    branches:
+      - master
+    paths:
+      - 'res/wiki/**'
   push:
+    branches:
+      - master
     paths:
       - 'res/wiki/**'
 
@@ -20,14 +27,22 @@ jobs:
       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
-        if git diff --name-only; then
         git add .
         git commit -m "Update wiki"
         git push
-        fi

.github/workflows/update-cmdpriv-template.yml

@@ -21,12 +21,12 @@ jobs:
     - name: Set up Python
       uses: actions/setup-python@v2
       with:
-        python-version: 3.x
+        python-version: 3.10.13
 
     - name: Install dependencies
       run: |
-        python -m pip install --upgrade pip
-        python -m pip install --upgrade  yiri-mirai openai colorlog func_timeout dulwich Pillow
+        python -m pip install --upgrade  yiri-mirai-rc openai>=1.0.0 colorlog func_timeout dulwich Pillow CallingGPT tiktoken
+        python -m pip install -U openai>=1.0.0
 
     - name: Copy Scripts
       run: |

.github/workflows/update-override-all.yml

@@ -29,7 +29,6 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          # 在此处添加您的项目所需的其他依赖
 
       - name: Copy Scripts
         run: |

.gitignore

@@ -1,4 +1,4 @@
-config.py
+/config.py
 .idea/
 __pycache__/
 database.db
@@ -26,3 +26,8 @@ bin/
 test_*
 venv/
 hugchat.json
+qcapi
+claude.json
+bard.json
+/*yaml
+!/docker-compose.yaml

CONTRIBUTING.md

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

Dockerfile

@@ -1,17 +1,15 @@
-FROM python:3.9-slim
+FROM python:3.10.13-bullseye
 WORKDIR /QChatGPT
 
-RUN sed -i "s/deb.debian.org/mirrors.tencent.com/g" /etc/apt/sources.list \
-    && sed -i 's|security.debian.org/debian-security|mirrors.tencent.com/debian-security|g' /etc/apt/sources.list \
-    && apt-get clean \
-    && apt-get update \
-    && apt-get -y upgrade \
-    && apt-get install -y git \
-    && apt-get clean \
-    && rm -rf /var/lib/apt/lists/*
-
 COPY . /QChatGPT/
 
-RUN pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
+RUN ls
+
+RUN python -m pip install -r requirements.txt && \
+    python -m pip install -U websockets==10.0 && \
+    python -m pip install -U httpcore httpx openai
+
+# 生成配置文件
+RUN python main.py
 
 CMD [ "python", "main.py" ]

README.md

@@ -1,30 +1,54 @@
-# QChatGPT🤖
 
 <p align="center">
-<img src="res/social.png" alt="QChatGPT" width="640" />
+<img src="res/logo.png" alt="QChatGPT" width="120" />
 </p>
 
-[English](README_en.md) | 简体中文
+<div align="center">
 
-[![GitHub release (latest by date)](https://img.shields.io/github/v/release/RockChinQ/QChatGPT?style=flat-square)](https://github.com/RockChinQ/QChatGPT/releases/latest)
+# 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>
 ![Wakapi Count](https://wakapi.dev/api/badge/RockChinQ/interval:any/project:QChatGPT)
+<img src="https://img.shields.io/badge/python-3.9+-blue.svg" alt="python">
+<a href="https://github.com/RockChinQ/QChatGPT/wiki">
+<img alt="Static Badge" src="https://img.shields.io/badge/%E6%9F%A5%E7%9C%8B-%E9%A1%B9%E7%9B%AEWiki-blue">
+</a><br/>
+<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=738382634">
+<img alt="Static Badge" src="https://img.shields.io/badge/%E7%A4%BE%E5%8C%BA%E7%BE%A4-738382634-purple">
+</a>
+<a href="https://qchatgpt.rockchin.top">
+<img alt="Static Badge" src="https://img.shields.io/badge/%E6%9F%A5%E7%9C%8B-%E7%A4%BE%E5%8C%BA%E7%BC%96%E5%86%99%E4%BD%BF%E7%94%A8%E6%89%8B%E5%86%8C-blue">
+</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>
+<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>
 
-> 2023/4/27 正在对纯Python实现的QQ登录框架、YAML配置文件、异步编程等功能进行概念验证，欢迎体验[LightQChat](https://github.com/RockChinQ/LightQChat)项目  
-> 2023/4/24 支持使用go-cqhttp登录QQ，请查看[此文档](https://github.com/RockChinQ/QChatGPT/wiki/go-cqhttp%E9%85%8D%E7%BD%AE)  
-> 2023/3/18 现已支持GPT-4 API（内测），请查看`config-template.py`中的`completion_api_params`  
-> 2023/3/15 逆向库已支持New Bing，使用方法查看[插件文档](https://github.com/RockChinQ/revLibs)  
+<blockquote> 🥳 QChatGPT 一周年啦，感谢大家的支持！欢迎前往<a href="https://github.com/RockChinQ/QChatGPT/discussions/627">讨论</a>。</blockquote>
 
-- 到[项目Wiki](https://github.com/RockChinQ/QChatGPT/wiki)可了解项目详细信息
-- 官方交流、答疑群: 656285629  
-  - **进群提问前请您`确保`已经找遍文档和issue均无法解决**  
-- 社区群（内有一键部署包、图形化界面等资源）: 362515018
-- QQ频道机器人见[QQChannelChatGPT](https://github.com/Soulter/QQChannelChatGPT)
-- 欢迎各种形式的贡献，请查看[贡献指引](CONTRIBUTING.md)
+<!-- <details>
+<summary>回复效果演示（带有联网插件）</summary>
+<img alt="联网演示GIF" src="res/webwlkr-demo.gif" width="300px">
+</details> -->
 
-## 🍺模型适配一览
+<img alt="回复效果（带有联网插件）" src="res/QChatGPT-1211.png" width="500px"/>
+
+</div>
 
 <details>
-<summary>点击此处展开</summary>
+<summary>
+
+## 🍺模型一览和功能点
+
+</summary>
 
 ### 文字对话
 
@@ -35,6 +59,15 @@
 - ChatGPT网页版GPT-4模型, 目前需要ChatGPT Plus订阅, 由[插件](https://github.com/RockChinQ/revLibs)接入
 - New Bing逆向库, 由[插件](https://github.com/RockChinQ/revLibs)接入
 - HuggingChat, 由[插件](https://github.com/RockChinQ/revLibs)接入, 仅支持英文
+- Claude, 由[插件](https://github.com/RockChinQ/revLibs)接入
+- Google Bard, 由[插件](https://github.com/RockChinQ/revLibs)接入
+- Google Gemini Pro、Azure、Anthropic Claude、智谱 ChatGLM、百度文心一言、讯飞星火认知、阿里通义千问、360 智脑等官方接口, 通过[One API](https://github.com/songquanpeng/one-api)接入
+
+### 模型聚合平台
+
+- [One API](https://github.com/songquanpeng/one-api), Azure、Anthropic Claude、Google Gemini Pro、智谱 ChatGLM、百度文心一言、讯飞星火认知、阿里通义千问以及 360 智脑等模型的官方接口转换成 OpenAI API 接入，QChatGPT 原生支持，您需要先配置 One API，之后在`config.py`中设置反向代理和`One API`的密钥后使用。
+- [gpt4free](https://github.com/xtekky/gpt4free), 破解以免费使用多个平台的各种文字模型, 由[插件](https://github.com/RockChinQ/revLibs)接入, 无需鉴权, 稳定性较差。
+- [Poe](https://poe.com), 破解免费使用Poe上多个平台的模型, 由[oliverkirk-sudo/ChatPoeBot](https://github.com/oliverkirk-sudo/ChatPoeBot)接入（由于 Poe 上可用的大部分模型现已通过[revLibs插件](https://github.com/RockChinQ/revLubs)或其他方式接入，此插件现已停止维护）。
 
 ### 故事续写
 
@@ -42,7 +75,7 @@
 
 ### 图片绘制
 
-- 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)
+- OpenAI DALL·E模型, 本项目原生支持, 使用方法查看[Wiki功能使用页](https://github.com/RockChinQ/QChatGPT/wiki/1-%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8#%E5%8A%9F%E8%83%BD%E7%82%B9%E5%88%97%E4%B8%BE)
 - NovelAI API, 由[插件](https://github.com/dominoar/QCPNovelAi)接入
 
 ### 语音生成
@@ -51,14 +84,9 @@
 - Plachta/VITS-Umamusume-voice-synthesizer, 由[插件](https://github.com/oliverkirk-sudo/chat_voice)接入
 
 
-</details>
-
 安装[此插件](https://github.com/RockChinQ/Switcher)，即可在使用中切换文字模型。
 
-## ✅功能
-
-<details>
-<summary>点击此处展开概述</summary>
+### 功能点
 
 <details>
 <summary>✅支持敏感词过滤，避免账号风险</summary>
@@ -85,30 +113,31 @@
 </details>
 
 <details>
-<summary>✅支持预设指令文字</summary>
+<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)
+  - 支持设置多个预设情景，并通过!reset、!default等命令控制，详细请查看[wiki命令](https://github.com/RockChinQ/QChatGPT/wiki/1-%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>`即可使用绘图模型
+  - 向机器人发送命令`!draw <prompt>`即可使用绘图模型
 </details>
 <details>
-<summary>✅支持指令控制热重载、热更新</summary>
+<summary>✅支持命令控制热重载、热更新</summary>
 
-  - 允许在运行期间修改`config.py`或其他代码后，以管理员账号向机器人发送指令`!reload`进行热重载，无需重启
-  - 运行期间允许以管理员账号向机器人发送指令`!update`进行热更新，拉取远程最新代码并执行热重载
+  - 允许在运行期间修改`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)
+  - 支持GPT的Function Calling功能
+  - 详细查看[插件使用页](https://github.com/RockChinQ/QChatGPT/wiki/5-%E6%8F%92%E4%BB%B6%E4%BD%BF%E7%94%A8)
 </details>
 <details>
 <summary>✅私聊、群聊黑名单机制</summary>
@@ -152,13 +181,22 @@
 <br/>
 <img alt="New Bing" src="res/screenshots/person_newbing.png" width="400"/>
 
+详情请查看[Wiki功能使用页](https://github.com/RockChinQ/QChatGPT/wiki/1-%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8)
+
 </details>
 
-详情请查看[Wiki功能使用页](https://github.com/RockChinQ/QChatGPT/wiki/%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8#%E5%8A%9F%E8%83%BD%E7%82%B9%E5%88%97%E4%B8%BE)
+<details>
 
-## 🔩部署
+<summary>
 
-**部署过程中遇到任何问题，请先在[QChatGPT](https://github.com/RockChinQ/QChatGPT/issues)或[qcg-installer](https://github.com/RockChinQ/qcg-installer/issues)的issue里进行搜索**  
+## 🚀部署和使用
+
+</summary>
+
+> **NOTE**
+> - 部署过程中遇到任何问题，请先在[QChatGPT](https://github.com/RockChinQ/QChatGPT/issues)或[qcg-installer](https://github.com/RockChinQ/qcg-installer/issues)的issue里进行搜索  
+> - QChatGPT需要Python版本>=3.9  
+> - 官方群和社区群群号请见文档顶部
 
 ### - 注册OpenAI账号
 
@@ -177,17 +215,16 @@
 
 </details>
 
-### - 自动化部署
+### - Docker或自动化部署
 
 <details>
 <summary>展开查看，以下方式二选一，Linux首选Docker，Windows首选安装器</summary>
 
 #### Docker方式
 
-> docker方式目前仅支持使用mirai登录，若您不**熟悉**docker的操作及相关知识，强烈建议您使用其他方式部署，我们**不会且难以**解决您主机上多个容器的连接问题。
+> docker方式较为复杂，若您不**熟悉**docker的操作及相关知识，强烈建议您使用其他方式部署，我们**不会且难以**解决您主机上多个容器的连接问题。
 
-请查看[此文档](res/docs/docker_deploy.md)  
-由[@mikumifa](https://github.com/mikumifa)贡献
+请查看[此文档](res/docs/docker_deployment.md)  
 
 #### 安装器方式
 
@@ -219,7 +256,7 @@
 <details>
 <summary>go-cqhttp</summary>
 
-1. 按照[此文档](https://github.com/RockChinQ/QChatGPT/wiki/go-cqhttp%E9%85%8D%E7%BD%AE)配置go-cqhttp
+1. 按照[此文档](https://github.com/RockChinQ/QChatGPT/wiki/9-go-cqhttp%E9%85%8D%E7%BD%AE)配置go-cqhttp
 2. 启动go-cqhttp，确保登录成功，保持运行
 3. 在下一步配置主程序时请在config.py中将`msg_source_adapter`设为`nakuru`
 
@@ -237,7 +274,7 @@ cd QChatGPT
 2. 安装依赖
 
 ```bash
-pip3 install requests yiri-mirai openai colorlog func_timeout dulwich Pillow nakuru-project-idk
+pip3 install requests -r requirements.txt
 ```
 
 3. 运行一次主程序，生成配置文件
@@ -266,48 +303,60 @@ python3 main.py
 
 </details>
 
-## 🚀使用
+**部署完成后必看: [命令说明](https://github.com/RockChinQ/QChatGPT/wiki/1-%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)**  
 
-**部署完成后必看: [指令说明](https://github.com/RockChinQ/QChatGPT/wiki/%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8#%E6%9C%BA%E5%99%A8%E4%BA%BA%E6%8C%87%E4%BB%A4)**  
-所有功能查看[Wiki功能使用页](https://github.com/RockChinQ/QChatGPT/wiki/%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8#%E4%BD%BF%E7%94%A8%E6%96%B9%E5%BC%8F)  
+所有功能查看[Wiki功能使用页](https://github.com/RockChinQ/QChatGPT/wiki/1-%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8)  
+
+</details>
+
+<details>
+<summary>
 
 ## 🧩插件生态
 
-现已支持自行开发插件对功能进行扩展或自定义程序行为  
-详见[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)
+</summary>
 
-<details>
-<summary>查看插件列表</summary>
+⭐我们已经支持了[GPT的Function Calling能力](https://platform.openai.com/docs/guides/gpt/function-calling)，请查看[Wiki内容函数](https://github.com/RockChinQ/QChatGPT/wiki/6-%E6%8F%92%E4%BB%B6%E4%BD%BF%E7%94%A8-%E5%86%85%E5%AE%B9%E5%87%BD%E6%95%B0)  
 
-### 示例插件
+> 使用方法见：[Wiki插件使用](https://github.com/RockChinQ/QChatGPT/wiki/5-%E6%8F%92%E4%BB%B6%E4%BD%BF%E7%94%A8)  
+> 开发教程见：[Wiki插件开发](https://github.com/RockChinQ/QChatGPT/wiki/7-%E6%8F%92%E4%BB%B6%E5%BC%80%E5%8F%91)
 
-在`tests/plugin_examples`目录下，将其整个目录复制到`plugins`目录下即可使用
 
-- `cmdcn` - 主程序指令中文形式
-- `hello_plugin` - 在收到消息`hello`时回复相应消息
-- `urlikethisijustsix` - 收到冒犯性消息时回复相应消息
+[所有插件列表](https://github.com/stars/RockChinQ/lists/qchatgpt-%E6%8F%92%E4%BB%B6)，欢迎提出issue以提交新的插件
 
-### 更多
+### 部分插件
 
-[插件列表](https://github.com/stars/RockChinQ/lists/qchatgpt-%E6%8F%92%E4%BB%B6)，欢迎提出issue以提交新的插件
-
-- [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%E3%80%81ChatGPT%E7%BD%91%E9%A1%B5%E7%89%88%E3%80%81ChatGPT-API%E5%8C%BA%E5%88%AB)
-- [Switcher](https://github.com/RockChinQ/Switcher) - 支持通过指令切换使用的模型
+- [WebwlkrPlugin](https://github.com/RockChinQ/WebwlkrPlugin) - 让机器人能联网！！
+- [revLibs](https://github.com/RockChinQ/revLibs) - 将ChatGPT网页版、Claude、Bard、Hugging Chat等破解版接入此项目，关于[官方接口和网页版有什么区别](https://github.com/RockChinQ/QChatGPT/wiki/8-%E5%AE%98%E6%96%B9%E6%8E%A5%E5%8F%A3%E3%80%81ChatGPT%E7%BD%91%E9%A1%B5%E7%89%88%E3%80%81ChatGPT-API%E5%8C%BA%E5%88%AB)
+- [Switcher](https://github.com/RockChinQ/Switcher) - 支持通过命令切换使用的模型
 - [hello_plugin](https://github.com/RockChinQ/hello_plugin) - `hello_plugin` 的储存库形式，插件开发模板
-- [dominoar/QChatPlugins](https://github.com/dominoar/QchatPlugins) - dominoar编写的诸多新功能插件（语音输出、Ranimg、屏蔽词规则等）
-- [dominoar/QCP-NovelAi](https://github.com/dominoar/QCP-NovelAi) - NovelAI 故事叙述与绘画
-- [oliverkirk-sudo/chat_voice](https://github.com/oliverkirk-sudo/chat_voice) - 文字转语音输出，使用HuggingFace上的[VITS-Umamusume-voice-synthesizer模型](https://huggingface.co/spaces/Plachta/VITS-Umamusume-voice-synthesizer)
+- [oliverkirk-sudo/chat_voice](https://github.com/oliverkirk-sudo/chat_voice) - 文字转语音输出，支持HuggingFace上的[VITS模型](https://huggingface.co/spaces/Plachta/VITS-Umamusume-voice-synthesizer),azure语音合成,vits本地语音合成,sovits语音合成
 - [RockChinQ/WaitYiYan](https://github.com/RockChinQ/WaitYiYan) - 实时获取百度`文心一言`等待列表人数
 - [chordfish-k/QChartGPT_Emoticon_Plugin](https://github.com/chordfish-k/QChartGPT_Emoticon_Plugin) - 使机器人根据回复内容发送表情包
 - [oliverkirk-sudo/ChatPoeBot](https://github.com/oliverkirk-sudo/ChatPoeBot) - 接入[Poe](https://poe.com/)上的机器人
 - [lieyanqzu/WeatherPlugin](https://github.com/lieyanqzu/WeatherPlugin) - 天气查询插件
 - [SysStatPlugin](https://github.com/RockChinQ/SysStatPlugin) - 查看系统状态
+- [oliverkirk-sudo/qchat_system_status](https://github.com/oliverkirk-sudo/qchat_system_status) - 以图片的形式输出系统状态
+- [oliverkirk-sudo/QChatAIPaint](https://github.com/oliverkirk-sudo/QChatAIPaint) - 基于[Holara](https://holara.ai/)的ai绘图插件
+- [oliverkirk-sudo/QChatCodeRunner](https://github.com/oliverkirk-sudo/QChatCodeRunner) - 基于[CodeRunner-Plugin](https://github.com/oliverkirk-sudo/CodeRunner-Plugin)的代码运行与图表生成插件
+- [oliverkirk-sudo/QChatWeather](https://github.com/oliverkirk-sudo/QChatWeather) - 生成好看的天气图片，基于和风天气
+- [oliverkirk-sudo/QChatMarkdown](https://github.com/oliverkirk-sudo/QChatMarkdown) - 将机器人输出的markdown转换为图片，基于[playwright](https://playwright.dev/python/docs/intro)
+- [ruuuux/WikipediaSearch](https://github.com/ruuuux/WikipediaSearch) - Wikipedia 搜索插件
+- [zuo-shi-yun/discountAssistant](https://github.com/zuo-shi-yun/discountAssistant) - 自动筛选并发送羊毛群内的优惠券
+- [zuo-shi-yun/Gatekeeper ](https://github.com/zuo-shi-yun/Gatekeeper) - QChatGPT的看门狗，包含黑白名单、临时用户机制
+- [zuo-shi-yun/AutoSwitchProxy](https://github.com/zuo-shi-yun/AutoSwitchProxy)  - 自动切换Clash代理模式以节省流量
+
 </details>
 
-## 😘致谢
+<details>
 
-- [@the-lazy-me](https://github.com/the-lazy-me) 为本项目制作[视频教程](https://www.bilibili.com/video/BV15v4y1X7aP)
+<summary>
+
+## 😘致谢和赞赏
+
+</summary>
+
+- [@the-lazy-me](https://github.com/the-lazy-me) 为本项目制作[视频教程](https://www.bilibili.com/video/BV1Y14y1Q7kQ)
 - [@mikumifa](https://github.com/mikumifa) 本项目Docker部署仓库开发者
 - [@dominoar](https://github.com/dominoar) 为本项目开发多种插件
 - [@万神的星空](https://github.com/qq255204159)  整合包发行
@@ -315,6 +364,6 @@ python3 main.py
 
 以及所有[贡献者](https://github.com/RockChinQ/QChatGPT/graphs/contributors)和其他为本项目提供支持的朋友们。
 
-## 👍赞赏
-
 <img alt="赞赏码" src="res/mm_reward_qrcode_1672840549070.png" width="400" height="400"/>
+
+</details>

README_en.md

@@ -49,7 +49,7 @@ English | [简体中文](README.md)
 
 Install this [plugin](https://github.com/RockChinQ/Switcher) to switch between different models.
 
-## ✅Function Points
+## ✅Features
 
 <details>
 <summary>Details</summary>
@@ -141,7 +141,7 @@ cd QChatGPT
 2. Install dependencies
 
 ```bash
-pip3 install requests yiri-mirai openai colorlog func_timeout dulwich Pillow nakuru-project-idk
+pip3 install requests yiri-mirai-rc openai colorlog func_timeout dulwich Pillow nakuru-project-idk
 ```
 
 3. Generate `config.py`

config-template.py

@@ -62,6 +62,9 @@ nakuru_config = {
 #     },
 #     "reverse_proxy": "http://example.com:12345/v1"
 # }
+#
+# 作者开设公用反向代理地址: https://api.openai.rockchin.top/v1
+# 随时可能关闭，仅供测试使用，有条件建议使用正向代理或者自建反向代理
 openai_config = {
     "api_key": {
         "default": "openai_api_key"
@@ -70,6 +73,11 @@ openai_config = {
     "reverse_proxy": None
 }
 
+# api-key切换策略
+# active：每次请求时都会切换api-key
+# passive：仅当api-key超额时才会切换api-key
+switch_strategy = "active"
+
 # [必需] 管理员QQ号，用于接收报错等通知及执行管理员级别指令
 # 支持多个管理员，可以使用list形式设置，例如：
 # admin_qq = [12345678, 87654321]
@@ -106,7 +114,7 @@ admin_qq = 0
 # 
 # 还可以加载文件中的预设文字，使用方法请查看：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获取帮助”",
+    "default": "如果用户之后想获取帮助，请你说“输入!help获取帮助”。",
 }
 
 # 情景预设格式
@@ -152,7 +160,6 @@ response_rules = {
 }
 
 
-
 # 消息忽略规则
 # 适用于私聊及群聊
 # 符合此规则的消息将不会被响应
@@ -201,46 +208,84 @@ auto_reset = True
 
 # OpenAI补全API的参数
 # 请在下方填写模型，程序自动选择接口
+# 模型文档：https://platform.openai.com/docs/models
 # 现已支持的模型有：
 # 
-#    'gpt-4'
-#    'gpt-4-0314'
-#    'gpt-4-32k'
-#    'gpt-4-32k-0314'
-#    'gpt-3.5-turbo'
-#    'gpt-3.5-turbo-0301'
-#    'text-davinci-003'
-#    'text-davinci-002'
-#    'code-davinci-002'
-#    'code-cushman-001'
-#    'text-curie-001'
-#    'text-babbage-001'
-#    'text-ada-001'
+# ChatCompletions 接口：
+# # GPT 4 系列
+# "gpt-4-1106-preview",
+# "gpt-4-vision-preview",
+# "gpt-4",
+# "gpt-4-32k",
+# "gpt-4-0613",
+# "gpt-4-32k-0613",
+# "gpt-4-0314", # legacy
+# "gpt-4-32k-0314", # legacy
+# # GPT 3.5 系列
+# "gpt-3.5-turbo-1106",
+# "gpt-3.5-turbo",
+# "gpt-3.5-turbo-16k",
+# "gpt-3.5-turbo-0613", # legacy
+# "gpt-3.5-turbo-16k-0613", # legacy
+# "gpt-3.5-turbo-0301", # legacy
+# 
+# Completions接口：
+# "text-davinci-003", # legacy
+# "text-davinci-002", # legacy
+# "code-davinci-002", # legacy
+# "code-cushman-001", # legacy
+# "text-curie-001", # legacy
+# "text-babbage-001", # legacy
+# "text-ada-001", # legacy
+# "gpt-3.5-turbo-instruct",
 #
 # 具体请查看OpenAI的文档: https://beta.openai.com/docs/api-reference/completions/create
 # 请将内容修改到config.py中，请勿修改config-template.py
+# 
+# 支持通过 One API 接入多种模型，请在上方的openai_config中设置One API的代理地址，
+# 并在此填写您要使用的模型名称，详细请参考：https://github.com/songquanpeng/one-api
+# 
+# 支持的 One API 模型：
+# "SparkDesk",
+# "chatglm_pro",
+# "chatglm_std",
+# "chatglm_lite",
+# "qwen-v1",
+# "qwen-plus-v1",
+# "ERNIE-Bot",
+# "ERNIE-Bot-turbo",
+# "gemini-pro",
 completion_api_params = {
     "model": "gpt-3.5-turbo",
     "temperature": 0.9,  # 数值越低得到的回答越理性，取值范围[0, 1]
-    "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
+# 具体请查看OpenAI的文档: https://platform.openai.com/docs/api-reference/images/create
 image_api_params = {
-    "size": "256x256",  # 图片尺寸，支持256x256, 512x512, 1024x1024
+    "model": "dall-e-2", # 默认使用 dall-e-2 模型，也可以改为 dall-e-3
+    # 图片尺寸
+    # dall-e-2 模型支持 256x256, 512x512, 1024x1024
+    # dall-e-3 模型支持 1024x1024, 1792x1024, 1024x1792
+    "size": "256x256",
 }
 
+# 跟踪函数调用
+# 为True时，在每次GPT进行Function Calling时都会输出发送一条回复给用户
+# 同时，一次提问内所有的Function Calling和普通回复消息都会单独发送给用户
+trace_function_calls = False
+
 # 群内回复消息时是否引用原消息
-quote_origin = True
+quote_origin = False
+
+# 群内回复消息时是否at发送者
+at_sender = False
 
 # 回复绘图时是否包含图片描述
 include_image_description = True
 
 # 消息处理的超时时间，单位为秒
-process_message_timeout = 30
+process_message_timeout = 120
 
 # 回复消息时是否显示[GPT]前缀
 show_prefix = False
@@ -251,7 +296,7 @@ show_prefix = False
 # 当此次消息处理时间低于此秒数时，将会强制延迟至此秒数
 # 例如：[1.5, 3]，则每次处理时会随机取一个1.5-3秒的随机数，若处理时间低于此随机数，则强制延迟至此随机秒数
 # 若您不需要此功能，请将force_delay_range设置为[0, 0]
-force_delay_range = [1.5, 3]
+force_delay_range = [0, 0]
 
 # 应用长消息处理策略的阈值
 # 当回复消息长度超过此值时，将使用长消息处理策略
@@ -282,19 +327,6 @@ retry_times = 3
 # 设置为False时，向用户及管理员发送错误详细信息
 hide_exce_info_to_user = False
 
-# 线程池相关配置
-# 该参数决定机器人可以同时处理几个人的消息，超出线程池数量的请求会被阻塞，不会被丢弃
-# 如果你不清楚该参数的意义，请不要更改
-# 程序运行本身线程池，无代码层面修改请勿更改
-sys_pool_num = 8
-
-# 执行管理员请求和指令的线程池并行线程数量，一般和管理员数量相等
-admin_pool_num = 4
-
-# 执行用户请求和指令的线程池并行线程数量
-# 如需要更高的并发，可以增大该值
-user_pool_num = 8
-
 # 每个会话的过期时间，单位为秒
 # 默认值20分钟
 session_expire_time = 1200
@@ -334,7 +366,7 @@ rate_limitation = {
 rate_limit_strategy = "drop"
 
 # 是否在启动时进行依赖库更新
-upgrade_dependencies = True
+upgrade_dependencies = False
 
 # 是否上报统计信息
 # 用于统计机器人的使用情况，不会收集任何用户信息

docker-compose.yaml

@@ -0,0 +1,18 @@
+version: "3"
+
+services:
+  qchatgpt:
+    image: rockchin/qchatgpt:latest
+    volumes:
+      - ./config.py:/QChatGPT/config.py
+      - ./banlist.py:/QChatGPT/banlist.py
+      - ./cmdpriv.json:/QChatGPT/cmdpriv.json
+      - ./sensitive.json:/QChatGPT/sensitive.json
+      - ./tips.py:/QChatGPT/tips.py
+      # 目录映射
+      - ./plugins:/QChatGPT/plugins
+      - ./scenario:/QChatGPT/scenario
+      - ./temp:/QChatGPT/temp
+      - ./logs:/QChatGPT/logs
+    restart: always
+    # 根据具体环境配置网络

main.py

@@ -8,10 +8,56 @@ import time
 import logging
 import sys
 import traceback
+import asyncio
 
 sys.path.append(".")
 
+
+def check_file():
+    # 检查是否有banlist.py,如果没有就把banlist-template.py复制一份
+    if not os.path.exists('banlist.py'):
+        shutil.copy('res/templates/banlist-template.py', 'banlist.py')
+
+    # 检查是否有sensitive.json
+    if not os.path.exists("sensitive.json"):
+        shutil.copy("res/templates/sensitive-template.json", "sensitive.json")
+
+    # 检查是否有scenario/default.json
+    if not os.path.exists("scenario/default.json"):
+        shutil.copy("scenario/default-template.json", "scenario/default.json")
+
+    # 检查cmdpriv.json
+    if not os.path.exists("cmdpriv.json"):
+        shutil.copy("res/templates/cmdpriv-template.json", "cmdpriv.json")
+
+    # 检查tips_custom
+    if not os.path.exists("tips.py"):
+        shutil.copy("tips-custom-template.py", "tips.py")
+
+    # 检查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 not os.path.exists('config.py'):
+        shutil.copy('config-template.py', 'config.py')
+        print('请先在config.py中填写配置')
+        sys.exit(0)
+
+
+# 初始化相关文件
+check_file()
+
 from pkg.utils.log import init_runtime_log_file, reset_logging
+from pkg.config import manager as config_mgr
+from pkg.config.impls import pymodule as pymodule_cfg
+
 
 try:
     import colorlog
@@ -20,7 +66,6 @@ except ImportError:
     import pkg.utils.pkgmgr as pkgmgr
     try:
         pkgmgr.install_requirements("requirements.txt")
-        pkgmgr.install_upgrade("websockets")
         import colorlog
     except ImportError:
         print("依赖不满足,请查看 https://github.com/RockChinQ/qcg-installer/issues/15")
@@ -47,7 +92,7 @@ def init_db():
 
 def ensure_dependencies():
     import pkg.utils.pkgmgr as pkgmgr
-    pkgmgr.run_pip(["install", "openai", "Pillow", "nakuru-project-idk", "--upgrade",
+    pkgmgr.run_pip(["install", "openai", "Pillow", "nakuru-project-idk", "CallingGPT", "tiktoken", "--upgrade",
                     "-i", "https://pypi.tuna.tsinghua.edu.cn/simple",
                     "--trusted-host", "pypi.tuna.tsinghua.edu.cn"])
 
@@ -55,48 +100,27 @@ def ensure_dependencies():
 known_exception_caught = False
 
 
-def override_config():
-    import config
-    # 检查override.json覆盖
+def override_config_manager():
+    config = pkg.utils.context.get_config_manager().data
+
     if os.path.exists("override.json") and use_override:
         override_json = json.load(open("override.json", "r", encoding="utf-8"))
+        overrided = []
         for key in override_json:
-            if hasattr(config, key):
-                setattr(config, key, override_json[key])
-                logging.info("覆写配置[{}]为[{}]".format(key, override_json[key]))
+            if key in config:
+                config[key] = override_json[key]
+                # logging.info("覆写配置[{}]为[{}]".format(key, override_json[key]))
+                overrided.append(key)
             else:
                 logging.error("无法覆写配置[{}]为[{}]，该配置不存在，请检查override.json是否正确".format(key, override_json[key]))
-
-
-# 临时函数，用于加载config和上下文，未来统一放在config类
-def load_config():
-    logging.info("检查config模块完整性.")
-    # 完整性校验
-    is_integrity = True
-    config_template = importlib.import_module('config-template')
-    config = importlib.import_module('config')
-    for key in dir(config_template):
-        if not key.startswith("__") and not hasattr(config, key):
-            setattr(config, key, getattr(config_template, key))
-            logging.warning("[{}]不存在".format(key))
-            is_integrity = False
-    
-    if not is_integrity:
-        logging.warning("配置文件不完整，您可以依据config-template.py检查config.py")
-
-    # 检查override.json覆盖
-    override_config()
-
-    if not is_integrity:
-        logging.warning("以上不存在的配置已被设为默认值，将在3秒后继续启动... ")
-        time.sleep(3)
-
-    # 存进上下文
-    pkg.utils.context.set_config(config)
+        if len(overrided) > 0:
+            logging.info("已根据override.json覆写配置项: {}".format(", ".join(overrided)))
 
 
 def complete_tips():
     """根据tips-custom-template模块补全tips模块的属性"""
+    non_exist_keys = []
+
     is_integrity = True
     logging.info("检查tips模块完整性.")
     tips_template = importlib.import_module('tips-custom-template')
@@ -104,26 +128,40 @@ def complete_tips():
     for key in dir(tips_template):
         if not key.startswith("__") and not hasattr(tips, key):
             setattr(tips, key, getattr(tips_template, key))
-            logging.warning("[{}]不存在".format(key))
+            # logging.warning("[{}]不存在".format(key))
+            non_exist_keys.append(key)
             is_integrity = False
 
     if not is_integrity:
+        logging.warning("以下提示语字段不存在: {}".format(", ".join(non_exist_keys)))
         logging.warning("tips模块不完整，您可以依据tips-custom-template.py检查tips.py")
         logging.warning("以上配置已被设为默认值，将在3秒后继续启动... ")
         time.sleep(3)
 
 
-def start(first_time_init=False):
+async def start_process(first_time_init=False):
     """启动流程，reload之后会被执行"""
 
     global known_exception_caught
     import pkg.utils.context
 
-    config = pkg.utils.context.get_config()
+    # 加载配置
+    cfg_inst: pymodule_cfg.PythonModuleConfigFile = pymodule_cfg.PythonModuleConfigFile(
+        'config.py',
+        'config-template.py'
+    )
+    await config_mgr.ConfigManager(cfg_inst).load_config()
+
+    override_config_manager()
+
+    # 检查tips模块
+    complete_tips()
+
+    cfg = pkg.utils.context.get_config_manager().data
     # 更新openai库到最新版本
-    if not hasattr(config, 'upgrade_dependencies') or config.upgrade_dependencies:
+    if 'upgrade_dependencies' not in cfg or cfg['upgrade_dependencies']:
         print("正在更新依赖库，请等待...")
-        if not hasattr(config, 'upgrade_dependencies'):
+        if 'upgrade_dependencies' not in cfg:
             print("这个操作不是必须的,如果不想更新,请在config.py中添加upgrade_dependencies=False")
         else:
             print("这个操作不是必须的,如果不想更新,请在config.py中将upgrade_dependencies设置为False")
@@ -132,6 +170,10 @@ def start(first_time_init=False):
         except Exception as e:
             print("更新openai库失败:{}, 请忽略或自行更新".format(e))
 
+    # 初始化文字转图片
+    from pkg.utils import text2img
+    text2img.initialize()
+
     known_exception_caught = False
     try:
         try:
@@ -140,11 +182,11 @@ def start(first_time_init=False):
             pkg.utils.context.context['logger_handler'] = sh
 
             # 检查是否设置了管理员
-            if not (hasattr(config, 'admin_qq') and config.admin_qq != 0):
+            if cfg['admin_qq'] == 0:
                 # logging.warning("未设置管理员QQ,管理员权限指令及运行告警将无法使用,如需设置请修改config.py中的admin_qq字段")
                 while True:
                     try:
-                        config.admin_qq = int(input("未设置管理员QQ,管理员权限指令及运行告警将无法使用,请输入管理员QQ号: "))
+                        cfg['admin_qq'] = int(input("未设置管理员QQ,管理员权限指令及运行告警将无法使用,请输入管理员QQ号: "))
                         # 写入到文件
 
                         # 读取文件
@@ -152,7 +194,7 @@ def start(first_time_init=False):
                         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))
+                        config_file_str = config_file_str.replace("admin_qq = 0", "admin_qq = " + str(cfg['admin_qq']))
                         # 写入
                         with open("config.py", "w", encoding="utf-8") as f:
                             f.write(config_file_str)
@@ -178,17 +220,26 @@ def start(first_time_init=False):
                 logging.error(e)
                 traceback.print_exc()
 
-            # 配置openai api_base
-            if "reverse_proxy" in config.openai_config and config.openai_config["reverse_proxy"] is not None:
+            # 配置OpenAI proxy
             import openai
-                openai.api_base = config.openai_config["reverse_proxy"]
+            openai.proxies = None  # 先重置，因为重载后可能需要清除proxy
+            if "http_proxy" in cfg['openai_config'] and cfg['openai_config']["http_proxy"] is not None:
+                openai.proxies = {
+                    "http": cfg['openai_config']["http_proxy"],
+                    "https": cfg['openai_config']["http_proxy"]
+                }
+
+            # 配置openai api_base
+            if "reverse_proxy" in cfg['openai_config'] and cfg['openai_config']["reverse_proxy"] is not None:
+                logging.debug("设置反向代理: "+cfg['openai_config']['reverse_proxy'])
+                openai.base_url = cfg['openai_config']["reverse_proxy"]
 
             # 主启动流程
             database = pkg.database.manager.DatabaseManager()
 
             database.initialize_database()
 
-            openai_interact = pkg.openai.manager.OpenAIInteract(config.openai_config['api_key'])
+            openai_interact = pkg.openai.manager.OpenAIInteract(cfg['openai_config']['api_key'])
 
             # 加载所有未超时的session
             pkg.openai.session.load_sessions()
@@ -209,7 +260,7 @@ def start(first_time_init=False):
                 def run_bot_wrapper():
                     global known_exception_caught
                     try:
-                        logging.info("使用账号: {}".format(qqbot.bot_account_id))
+                        logging.debug("使用账号: {}".format(qqbot.bot_account_id))
                         qqbot.adapter.run_sync()
                     except TypeError as e:
                         if str(e).__contains__("argument 'debug'"):
@@ -277,13 +328,12 @@ def start(first_time_init=False):
         
         if first_time_init:
             if not known_exception_caught:
-                import config
-                if config.msg_source_adapter == "yirimirai":
-                    logging.info("QQ: {}, MAH: {}".format(config.mirai_http_api_config['qq'], config.mirai_http_api_config['host']+":"+str(config.mirai_http_api_config['port'])))
+                if cfg['msg_source_adapter'] == "yirimirai":
+                    logging.info("QQ: {}, MAH: {}".format(cfg['mirai_http_api_config']['qq'], cfg['mirai_http_api_config']['host']+":"+str(cfg['mirai_http_api_config']['port'])))
                     logging.critical('程序启动完成,如长时间未显示 "成功登录到账号xxxxx" ,并且不回复消息,解决办法(请勿到群里问): '
                                 'https://github.com/RockChinQ/QChatGPT/issues/37')
-                elif config.msg_source_adapter == 'nakuru':
-                    logging.info("host: {}, port: {}, http_port: {}".format(config.nakuru_config['host'], config.nakuru_config['port'], config.nakuru_config['http_port']))
+                elif cfg['msg_source_adapter'] == 'nakuru':
+                    logging.info("host: {}, port: {}, http_port: {}".format(cfg['nakuru_config']['host'], cfg['nakuru_config']['port'], cfg['nakuru_config']['http_port']))
                     logging.critical('程序启动完成,如长时间未显示 "Protocol: connected" ,并且不回复消息,请检查config.py中的nakuru_config是否正确')
             else:
                 sys.exit(1)
@@ -291,7 +341,7 @@ def start(first_time_init=False):
             logging.info('热重载完成')
 
     # 发送赞赏码
-    if config.encourage_sponsor_at_start \
+    if cfg['encourage_sponsor_at_start'] \
         and pkg.utils.context.get_openai_manager().audit_mgr.get_total_text_length() >= 2048:
 
         logging.info("发送赞赏码")
@@ -313,7 +363,8 @@ def start(first_time_init=False):
         if pkg.utils.updater.is_new_version_available():
             logging.info("新版本可用，请发送 !update 进行自动更新\n更新日志:\n{}".format("\n".join(pkg.utils.updater.get_rls_notes())))
         else:
-            logging.info("当前已是最新版本")
+            # logging.info("当前已是最新版本")
+            pass
 
     except Exception as e:
         logging.warning("检查更新失败:{}".format(e))
@@ -348,70 +399,22 @@ def stop():
             raise e
 
 
-def check_file():
-    # 检查是否有banlist.py,如果没有就把banlist-template.py复制一份
-    if not os.path.exists('banlist.py'):
-        shutil.copy('res/templates/banlist-template.py', 'banlist.py')
-
-    # 检查是否有sensitive.json
-    if not os.path.exists("sensitive.json"):
-        shutil.copy("res/templates/sensitive-template.json", "sensitive.json")
-
-    # 检查是否有scenario/default.json
-    if not os.path.exists("scenario/default.json"):
-        shutil.copy("scenario/default-template.json", "scenario/default.json")
-
-    # 检查cmdpriv.json
-    if not os.path.exists("cmdpriv.json"):
-        shutil.copy("res/templates/cmdpriv-template.json", "cmdpriv.json")
-
-    # 检查tips_custom
-    if not os.path.exists("tips.py"):
-        shutil.copy("tips-custom-template.py", "tips.py")
-
-    # 检查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 not os.path.exists('config.py'):
-        shutil.copy('config-template.py', 'config.py')
-        print('请先在config.py中填写配置')
-        sys.exit(0)
-
-
 def main():
     global use_override
     # 检查是否携带了 --override 或 -r 参数
     if '--override' in sys.argv or '-r' in sys.argv:
         use_override = True
 
-    # 初始化相关文件
-    check_file()
-
     # 初始化logging
     init_runtime_log_file()
     pkg.utils.context.context['logger_handler'] = reset_logging()
 
-    # 加载配置
-    load_config()
-    config = pkg.utils.context.get_config()
-
-    # 检查tips模块
-    complete_tips()
-
     # 配置线程池
     from pkg.utils import ThreadCtl
     thread_ctl = ThreadCtl(
-        sys_pool_num=config.sys_pool_num,
-        admin_pool_num=config.admin_pool_num,
-        user_pool_num=config.user_pool_num
+        sys_pool_num=8,
+        admin_pool_num=4,
+        user_pool_num=8
     )
     # 存进上下文
     pkg.utils.context.set_thread_ctl(thread_ctl)
@@ -430,9 +433,11 @@ def main():
     # 关闭urllib的http警告
     requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
 
+    def run_wrapper():
+        asyncio.run(start_process(True))
+
     pkg.utils.context.get_thread_ctl().submit_sys_task(
-        start,
-        True
+        run_wrapper
     )
 
     # 主线程循环
@@ -442,12 +447,19 @@ def main():
         except:
             stop()
             pkg.utils.context.get_thread_ctl().shutdown()
+
+            launch_args = sys.argv.copy()
+
+            if "--cov-report" not in launch_args:
                 import platform
                 if platform.system() == 'Windows':
                     cmd = "taskkill /F /PID {}".format(os.getpid())
                 elif platform.system() in ['Linux', 'Darwin']:
                     cmd = "kill -9 {}".format(os.getpid())
                 os.system(cmd)
+            else:
+                print("正常退出以生成覆盖率报告")
+                sys.exit(0)
 
 
 if __name__ == '__main__':

override-all.json

@@ -21,9 +21,10 @@
         "http_proxy": null,
         "reverse_proxy": null
     },
+    "switch_strategy": "active",
     "admin_qq": 0,
     "default_prompt": {
-        "default": "如果我之后想获取帮助，请你说“输入!help获取帮助”"
+        "default": "如果用户之后想获取帮助，请你说“输入!help获取帮助”。"
     },
     "preset_mode": "normal",
     "response_rules": {
@@ -56,21 +57,21 @@
     "auto_reset": true,
     "completion_api_params": {
         "model": "gpt-3.5-turbo",
-        "temperature": 0.9,
-        "top_p": 1,
-        "frequency_penalty": 0.2,
-        "presence_penalty": 1.0
+        "temperature": 0.9
     },
     "image_api_params": {
+        "model": "dall-e-2",
         "size": "256x256"
     },
-    "quote_origin": true,
+    "trace_function_calls": false,
+    "quote_origin": false,
+    "at_sender": false,
     "include_image_description": true,
-    "process_message_timeout": 30,
+    "process_message_timeout": 120,
     "show_prefix": false,
     "force_delay_range": [
-        1.5,
-        3
+        0,
+        0
     ],
     "blob_message_threshold": 256,
     "blob_message_strategy": "forward",
@@ -78,15 +79,12 @@
     "font_path": "",
     "retry_times": 3,
     "hide_exce_info_to_user": false,
-    "sys_pool_num": 8,
-    "admin_pool_num": 4,
-    "user_pool_num": 8,
     "session_expire_time": 1200,
     "rate_limitation": {
         "default": 60
     },
     "rate_limit_strategy": "drop",
-    "upgrade_dependencies": true,
+    "upgrade_dependencies": false,
     "report_usage": true,
     "logging_level": 20
 }

pkg/audit/gatherer.py

@@ -5,11 +5,12 @@
 import hashlib
 import json
 import logging
+import threading
 
 import requests
 
-import pkg.utils.context
-import pkg.utils.updater
+from ..utils import context
+from ..utils import updater
 
 
 class DataGatherer:
@@ -32,7 +33,7 @@ class DataGatherer:
     def __init__(self):
         self.load_from_db()
         try:
-            self.version_str = pkg.utils.updater.get_current_tag()  # 从updater模块获取版本号
+            self.version_str = updater.get_current_tag()  # 从updater模块获取版本号
         except:
             pass
 
@@ -42,23 +43,28 @@ class DataGatherer:
         只会报告此次请求的使用量，不会报告总量。
         不包含除版本号、使用类型、使用量以外的任何信息，仅供开发者分析使用情况。
         """
+        
+        def thread_func():
+        
             try:
-            config = pkg.utils.context.get_config()
-            if not config.report_usage:
+                config = context.get_config_manager().data
+                if not config['report_usage']:
                     return
-            res = requests.get("http://reports.rockchin.top:18989/usage?service_name=qchatgpt.{}&version={}&count={}&msg_source={}".format(subservice_name, self.version_str, count, config.msg_source_adapter))
+                res = requests.get("http://reports.rockchin.top:18989/usage?service_name=qchatgpt.{}&version={}&count={}&msg_source={}".format(subservice_name, self.version_str, count, config['msg_source_adapter']))
                 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
             
+        threading.Thread(target=thread_func).start()
+
     def get_usage(self, key_md5):
         return self.usage[key_md5] if key_md5 in self.usage else {}
 
     def report_text_model_usage(self, model, total_tokens):
         """调用方报告文字模型请求文字使用量"""
 
-        key_md5 = pkg.utils.context.get_openai_manager().key_mgr.get_using_key_md5()  # 以key的md5进行储存
+        key_md5 = context.get_openai_manager().key_mgr.get_using_key_md5()  # 以key的md5进行储存
 
         if key_md5 not in self.usage:
             self.usage[key_md5] = {}
@@ -78,7 +84,7 @@ class DataGatherer:
     def report_image_model_usage(self, size):
         """调用方报告图片模型请求图片使用量"""
 
-        key_md5 = pkg.utils.context.get_openai_manager().key_mgr.get_using_key_md5()
+        key_md5 = context.get_openai_manager().key_mgr.get_using_key_md5()
 
         if key_md5 not in self.usage:
             self.usage[key_md5] = {}
@@ -125,9 +131,9 @@ class DataGatherer:
         return total
 
     def dump_to_db(self):
-        pkg.utils.context.get_database_manager().dump_usage_json(self.usage)
+        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()
+        json_str = context.get_database_manager().load_usage_json()
         if json_str is not None:
             self.usage = json.loads(json_str)

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,23 @@
+from . import model as file_model
+from ..utils import context
+
+
+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 = {}
+        context.set_config_manager(self)
+
+    async def load_config(self):
+        self.data = await self.file.load()
+
+    async def dump_config(self):
+        await self.file.save(self.data)

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/database/manager.py

@@ -5,11 +5,10 @@ import hashlib
 import json
 import logging
 import time
-from sqlite3 import Cursor
 
 import sqlite3
 
-import pkg.utils.context
+from ..utils import context
 
 
 class DatabaseManager:
@@ -22,7 +21,7 @@ class DatabaseManager:
 
         self.reconnect()
 
-        pkg.utils.context.set_database_manager(self)
+        context.set_database_manager(self)
 
     # 连接到数据库文件
     def reconnect(self):
@@ -33,7 +32,7 @@ class DatabaseManager:
     def close(self):
         self.conn.close()
 
-    def __execute__(self, *args, **kwargs) -> Cursor:
+    def __execute__(self, *args, **kwargs) -> sqlite3.Cursor:
         # logging.debug('SQL: {}'.format(sql))
         logging.debug('SQL: {}'.format(args))
         c = self.cursor.execute(*args, **kwargs)
@@ -145,11 +144,11 @@ class DatabaseManager:
     # 从数据库加载还没过期的session数据
     def load_valid_sessions(self) -> dict:
         # 从数据库中加载所有还没过期的session
-        config = pkg.utils.context.get_config()
+        config = context.get_config_manager().data
         self.__execute__("""
         select `name`, `type`, `number`, `create_timestamp`, `last_interact_timestamp`, `prompt`, `status`, `default_prompt`, `token_counts`
         from `sessions` where `last_interact_timestamp` > {}
-        """.format(int(time.time()) - config.session_expire_time))
+        """.format(int(time.time()) - config['session_expire_time']))
         results = self.cursor.fetchall()
         sessions = {}
         for result in results:

pkg/openai/api/chat_completion.py

@@ -0,0 +1,220 @@
+import json
+import logging
+
+import openai
+from openai.types.chat import chat_completion_message
+
+from .model import RequestBase
+from .. import funcmgr
+
+
+class ChatCompletionRequest(RequestBase):
+    """调用ChatCompletion接口的请求类。
+    
+    此类保证每一次返回的角色为assistant的信息的finish_reason一定为stop。
+    若有函数调用响应，本类的返回瀑布是：函数调用请求->函数调用结果->...->assistant的信息->stop。
+    """
+
+    model: str
+    messages: list[dict[str, str]]
+    kwargs: dict
+
+    stopped: bool = False
+
+    pending_func_call: chat_completion_message.FunctionCall = None
+
+    pending_msg: str
+
+    def flush_pending_msg(self):
+        self.append_message(
+            role="assistant",
+            content=self.pending_msg
+        )
+        self.pending_msg = ""
+
+    def append_message(self, role: str, content: str, name: str=None, function_call: dict=None):
+        msg = {
+            "role": role,
+            "content": content
+        }
+
+        if name is not None:
+            msg['name'] = name
+
+        if function_call is not None:
+            msg['function_call'] = function_call
+
+        self.messages.append(msg)
+
+    def __init__(
+        self,
+        client: openai.Client,
+        model: str,
+        messages: list[dict[str, str]],
+        **kwargs
+    ):
+        self.client = client
+        self.model = model
+        self.messages = messages.copy()
+
+        self.kwargs = kwargs
+
+        self.req_func = self.client.chat.completions.create
+
+        self.pending_func_call = None
+
+        self.stopped = False
+
+        self.pending_msg = ""
+
+    def __iter__(self):
+        return self
+
+    def __next__(self) -> dict:
+        if self.stopped:
+            raise StopIteration()
+
+        if self.pending_func_call is None:  # 没有待处理的函数调用请求
+
+            args = {
+                "model": self.model,
+                "messages": self.messages,
+            }
+
+            funcs = funcmgr.get_func_schema_list()
+
+            if len(funcs) > 0:
+                args['functions'] = funcs
+
+            # 拼接kwargs
+            args = {**args, **self.kwargs}
+            
+            from openai.types.chat import chat_completion
+
+            resp: chat_completion.ChatCompletion = self._req(**args)
+
+            choice0 = resp.choices[0]
+
+            # 如果不是函数调用，且finish_reason为stop，则停止迭代
+            if choice0.finish_reason == 'stop':  #  and choice0["finish_reason"] == "stop"
+                self.stopped = True
+            
+            if hasattr(choice0.message, 'function_call') and choice0.message.function_call is not None:
+                self.pending_func_call = choice0.message.function_call
+
+                self.append_message(
+                    role="assistant",
+                    content=choice0.message.content,
+                    function_call=choice0.message.function_call
+                )
+
+                return {
+                    "id": resp.id,
+                    "choices": [
+                        {
+                            "index": choice0.index,
+                            "message": {
+                                "role": "assistant",
+                                "type": "function_call",
+                                "content": choice0.message.content,
+                                "function_call": {
+                                    "name": choice0.message.function_call.name,
+                                    "arguments": choice0.message.function_call.arguments
+                                }
+                            },
+                            "finish_reason": "function_call"
+                        }
+                    ],
+                    "usage": {
+                        "prompt_tokens": resp.usage.prompt_tokens,
+                        "completion_tokens": resp.usage.completion_tokens,
+                        "total_tokens": resp.usage.total_tokens
+                    }
+                }
+            else:
+
+                # self.pending_msg += choice0['message']['content']
+                # 普通回复一定处于最后方，故不用再追加进内部messages
+
+                return {
+                    "id": resp.id,
+                    "choices": [
+                        {
+                            "index": choice0.index,
+                            "message": {
+                                "role": "assistant",
+                                "type": "text",
+                                "content": choice0.message.content
+                            },
+                            "finish_reason": choice0.finish_reason
+                        }
+                    ],
+                    "usage": {
+                        "prompt_tokens": resp.usage.prompt_tokens,
+                        "completion_tokens": resp.usage.completion_tokens,
+                        "total_tokens": resp.usage.total_tokens
+                    }
+                }
+        else:  # 处理函数调用请求
+
+            cp_pending_func_call = self.pending_func_call.copy()
+            
+            self.pending_func_call = None
+
+            func_name = cp_pending_func_call.name
+            arguments = {}
+
+            try:
+
+                try:
+                    arguments = json.loads(cp_pending_func_call.arguments)
+                # 若不是json格式的异常处理
+                except json.decoder.JSONDecodeError:
+                    # 获取函数的参数列表
+                    func_schema = funcmgr.get_func_schema(func_name)
+
+                    arguments = {
+                        func_schema['parameters']['required'][0]: cp_pending_func_call.arguments
+                    }
+                
+                logging.info("执行函数调用: name={}, arguments={}".format(func_name, arguments))
+
+                # 执行函数调用
+                ret = ""
+                try:
+                    ret = funcmgr.execute_function(func_name, arguments)
+
+                    logging.info("函数执行完成。")
+                except Exception as e:
+                    ret = "error: execute function failed: {}".format(str(e))
+                    logging.error("函数执行失败: {}".format(str(e)))
+
+                self.append_message(
+                    role="function",
+                    content=json.dumps(ret, ensure_ascii=False),
+                    name=func_name
+                )
+
+                return {
+                    "id": -1,
+                    "choices": [
+                        {
+                            "index": -1,
+                            "message": {
+                                "role": "function",
+                                "type": "function_return",
+                                "function_name": func_name,
+                                "content": json.dumps(ret, ensure_ascii=False)
+                            },
+                            "finish_reason": "function_return"
+                        }
+                    ],
+                    "usage": {
+                        "prompt_tokens": 0,
+                        "completion_tokens": 0,
+                        "total_tokens": 0
+                    }
+                }
+
+            except funcmgr.ContentFunctionNotFoundError:
+                raise Exception("没有找到函数: {}".format(func_name))

pkg/openai/api/completion.py

@@ -0,0 +1,100 @@
+import openai
+from openai.types import completion, completion_choice
+
+from . import model
+
+
+class CompletionRequest(model.RequestBase):
+    """调用Completion接口的请求类。
+    
+    调用方可以一直next completion直到finish_reason为stop。
+    """
+
+    model: str
+    prompt: str
+    kwargs: dict
+
+    stopped: bool = False
+
+    def __init__(
+        self,
+        client: openai.Client,
+        model: str,
+        messages: list[dict[str, str]],
+        **kwargs
+    ):
+        self.client = client
+        self.model = model
+        self.prompt = ""
+        
+        for message in messages:
+            self.prompt += message["role"] + ": " + message["content"] + "\n"
+        
+        self.prompt += "assistant: "
+
+        self.kwargs = kwargs
+
+        self.req_func = self.client.completions.create
+
+    def __iter__(self):
+        return self
+
+    def __next__(self) -> dict:
+        """调用Completion接口，返回生成的文本
+        
+        {
+            "id": "id",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "type": "text",
+                        "content": "message"
+                    },
+                    "finish_reason": "reason"
+                }
+            ],
+            "usage": {
+                "prompt_tokens": 10,
+                "completion_tokens": 20,
+                "total_tokens": 30
+            }
+        }
+        """
+
+        if self.stopped:
+            raise StopIteration()
+
+        resp: completion.Completion = self._req(
+            model=self.model,
+            prompt=self.prompt,
+            **self.kwargs
+        )
+
+        if resp.choices[0].finish_reason == "stop":
+            self.stopped = True
+
+        choice0: completion_choice.CompletionChoice = resp.choices[0]
+
+        self.prompt += choice0.text
+
+        return {
+            "id": resp.id,
+            "choices": [
+                {
+                    "index": choice0.index,
+                    "message": {
+                        "role": "assistant",
+                        "type": "text",
+                        "content": choice0.text
+                    },
+                    "finish_reason": choice0.finish_reason
+                }
+            ],
+            "usage": {
+                "prompt_tokens": resp.usage.prompt_tokens,
+                "completion_tokens": resp.usage.completion_tokens,
+                "total_tokens": resp.usage.total_tokens
+            }
+        }

pkg/openai/api/model.py

@@ -0,0 +1,40 @@
+# 定义不同接口请求的模型
+import logging
+
+import openai
+
+from ...utils import context
+
+
+class RequestBase:
+
+    client: openai.Client
+
+    req_func: callable
+
+    def __init__(self, *args, **kwargs):
+        raise NotImplementedError
+
+    def _next_key(self):
+        switched, name = context.get_openai_manager().key_mgr.auto_switch()
+        logging.debug("切换api-key: switched={}, name={}".format(switched, name))
+        self.client.api_key = context.get_openai_manager().key_mgr.get_using_key()
+
+    def _req(self, **kwargs):
+        """处理代理问题"""
+        logging.debug("请求接口参数: %s", str(kwargs))
+        config = context.get_config_manager().data
+
+        ret = self.req_func(**kwargs)
+        logging.debug("接口请求返回：%s", str(ret))
+
+        if config['switch_strategy'] == 'active':
+            self._next_key()
+
+        return ret
+
+    def __iter__(self):
+        raise self
+
+    def __next__(self):
+        raise NotImplementedError

pkg/openai/dprompt.py

@@ -1,9 +1,10 @@
 # 多情景预设值管理
 import json
 import logging
-import config
 import os
 
+from ..utils import context
+
 # __current__ = "default"
 # """当前默认使用的情景预设的名称
 
@@ -16,10 +17,6 @@ import os
 # __scenario_from_files__ = {}
 
 
-__universal_first_reply__ = "ok, I'll follow your commands."
-"""通用首次回复"""
-
-
 class ScenarioMode:
     """情景预设模式抽象类"""
 
@@ -66,29 +63,24 @@ class NormalScenarioMode(ScenarioMode):
     """普通情景预设模式"""
 
     def __init__(self):
-        global __universal_first_reply__
+        config = context.get_config_manager().data
+
         # 加载config中的default_prompt值
-        if type(config.default_prompt) == str:
+        if type(config['default_prompt']) == str:
             self.using_prompt_name = "default"
             self.prompts = {"default": [
                 {
-                    "role": "user",
-                    "content": config.default_prompt
-                },{
-                    "role": "assistant",
-                    "content": __universal_first_reply__
+                    "role": "system",
+                    "content": config['default_prompt']
                 }
             ]}
         
-        elif type(config.default_prompt) == dict:
-            for key in config.default_prompt:
+        elif type(config['default_prompt']) == dict:
+            for key in config['default_prompt']:
                 self.prompts[key] = [
                     {
-                        "role": "user",
-                        "content": config.default_prompt[key]
-                    },{
-                        "role": "assistant",
-                        "content": __universal_first_reply__
+                        "role": "system",
+                        "content": config['default_prompt'][key]
                     }
                 ]
 
@@ -98,11 +90,8 @@ class NormalScenarioMode(ScenarioMode):
             with open(os.path.join("prompts", file), encoding="utf-8") as f:
                 self.prompts[file] = [
                     {
-                        "role": "user",
+                        "role": "system",
                         "content": f.read()
-                    },{
-                        "role": "assistant",
-                        "content": __universal_first_reply__
                     }
                 ]
 
@@ -137,9 +126,9 @@ def register_all():
 
 def mode_inst() -> ScenarioMode:
     """获取指定名称的情景预设模式对象"""
-    import config
+    config = context.get_config_manager().data
 
-    if config.preset_mode == "default":
-        config.preset_mode = "normal"
+    if config['preset_mode'] == "default":
+        config['preset_mode'] = "normal"
 
-    return scenario_mode_mapping[config.preset_mode]
+    return scenario_mode_mapping[config['preset_mode']]

pkg/openai/funcmgr.py

@@ -0,0 +1,46 @@
+# 封装了function calling的一些支持函数
+import logging
+
+from ..plugin import host
+
+
+class ContentFunctionNotFoundError(Exception):
+    pass
+
+
+def get_func_schema_list() -> list:
+    """从plugin包中的函数结构中获取并处理成受GPT支持的格式"""
+    if not host.__enable_content_functions__:
+        return []
+
+    schemas = []
+
+    for func in host.__callable_functions__:
+        if func['enabled']:
+            fun_cp = func.copy()
+
+            del fun_cp['enabled']
+
+            schemas.append(fun_cp)
+
+    return schemas
+
+def get_func(name: str) -> callable:
+    if name not in host.__function_inst_map__:
+        raise ContentFunctionNotFoundError("没有找到内容函数: {}".format(name))
+
+    return host.__function_inst_map__[name]
+
+def get_func_schema(name: str) -> dict:
+    for func in host.__callable_functions__:
+        if func['name'] == name:
+            return func
+    raise ContentFunctionNotFoundError("没有找到内容函数: {}".format(name))
+
+def execute_function(name: str, kwargs: dict) -> any:
+    """执行函数调用"""
+
+    logging.debug("executing function: name='{}', kwargs={}".format(name, kwargs))
+
+    func = get_func(name)
+    return func(**kwargs)

pkg/openai/keymgr.py

@@ -2,8 +2,8 @@
 import hashlib
 import logging
 
-import pkg.plugin.host as plugin_host
-import pkg.plugin.models as plugin_models
+from ..plugin import host as plugin_host
+from ..plugin import models as plugin_models
 
 
 class KeysManager:
@@ -54,7 +54,24 @@ class KeysManager:
             是否切换成功, 切换后的api-key的别名
         """
 
+        index = 0
+
         for key_name in self.api_key:
+            if self.api_key[key_name] == self.using_key:
+                break
+            
+            index += 1
+
+        # 从当前key开始向后轮询
+        start_index = index
+        index += 1
+        if index >= len(self.api_key):
+            index = 0
+
+        while index != start_index:
+            
+            key_name = list(self.api_key.keys())[index]
+
             if self.api_key[key_name] not in self.exceeded:
                 self.using_key = self.api_key[key_name]
 
@@ -69,10 +86,14 @@ class KeysManager:
 
                 return True, key_name
 
-        self.using_key = list(self.api_key.values())[0]
-        logging.info("使用api-key:" + list(self.api_key.keys())[0])
+            index += 1
+            if index >= len(self.api_key):
+                index = 0
 
-        return False, ""
+        self.using_key = list(self.api_key.values())[start_index]
+        logging.debug("使用api-key:" + list(self.api_key.keys())[start_index])
+
+        return False, list(self.api_key.keys())[start_index]
 
     def add(self, key_name, key):
         self.api_key[key_name] = key

pkg/openai/manager.py

@@ -1,11 +1,13 @@
 import logging
 
 import openai
+from openai.types import images_response
 
-import pkg.openai.keymgr
-import pkg.utils.context
-import pkg.audit.gatherer
-from pkg.openai.modelmgr import ModelRequest, create_openai_model_request
+from ..openai import keymgr
+from ..utils import context
+from ..audit import gatherer
+from ..openai import modelmgr
+from ..openai.api import model as api_model
 
 
 class OpenAIInteract:
@@ -14,66 +16,57 @@ class OpenAIInteract:
     将文字接口和图片接口封装供调用方使用
     """
 
-    key_mgr: pkg.openai.keymgr.KeysManager = None
+    key_mgr: keymgr.KeysManager = None
 
-    audit_mgr: pkg.audit.gatherer.DataGatherer = None
+    audit_mgr: gatherer.DataGatherer = None
 
     default_image_api_params = {
         "size": "256x256",
     }
 
+    client: openai.Client = None
+
     def __init__(self, api_key: str):
 
-        self.key_mgr = pkg.openai.keymgr.KeysManager(api_key)
-        self.audit_mgr = pkg.audit.gatherer.DataGatherer()
+        self.key_mgr = keymgr.KeysManager(api_key)
+        self.audit_mgr = gatherer.DataGatherer()
 
-        logging.info("文字总使用量：%d", self.audit_mgr.get_total_text_length())
+        # logging.info("文字总使用量：%d", self.audit_mgr.get_total_text_length())
 
-        openai.api_key = self.key_mgr.get_using_key()
+        self.client = openai.Client(
+            api_key=self.key_mgr.get_using_key(),
+            base_url=openai.base_url
+        )
 
-        pkg.utils.context.set_openai_manager(self)
+        context.set_openai_manager(self)
 
-    # 请求OpenAI Completion
-    def request_completion(self, prompts) -> tuple[str, int]:
-        """请求补全接口回复
-
-        Parameters:
-            prompts (str): 提示语
-
-        Returns:
-            str: 回复
+    def request_completion(self, messages: list):
+        """请求补全接口回复=
         """
+        # 选择接口请求类
+        config = context.get_config_manager().data
 
-        config = pkg.utils.context.get_config()
+        request: api_model.RequestBase
 
-        # 根据模型选择使用的接口
-        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
+        model: str = config['completion_api_params']['model']
+
+        cp_parmas = config['completion_api_params'].copy()
+        del cp_parmas['model']
+
+        request = modelmgr.select_request_cls(self.client, model, messages, cp_parmas)
+
+        # 请求接口
+        for resp in request:
+
+            if resp['usage']['total_tokens'] > 0:
+                self.audit_mgr.report_text_model_usage(
+                    model,
+                    resp['usage']['total_tokens']
                 )
-        ai.request(
-            prompts,
-            **config.completion_api_params
-        )
-        response = ai.get_response()
 
-        logging.debug("OpenAI response: %s", response)
+            yield resp
 
-        # 记录使用量
-        current_round_token = 0
-        if 'model' in config.completion_api_params:
-            self.audit_mgr.report_text_model_usage(config.completion_api_params['model'],
-                                                   ai.get_total_tokens())
-            current_round_token = ai.get_total_tokens()
-        elif 'engine' in config.completion_api_params:
-            self.audit_mgr.report_text_model_usage(config.completion_api_params['engine'],
-                                                   response['usage']['total_tokens'])
-            current_round_token = response['usage']['total_tokens']
-
-        return ai.get_message(), current_round_token
-
-    def request_image(self, prompt) -> dict:
+    def request_image(self, prompt) -> images_response.ImagesResponse:
         """请求图片接口回复
 
         Parameters:
@@ -82,10 +75,10 @@ class OpenAIInteract:
         Returns:
             dict: 响应
         """
-        config = pkg.utils.context.get_config()
-        params = config.image_api_params
+        config = context.get_config_manager().data
+        params = config['image_api_params']
 
-        response = openai.Image.create(
+        response = self.client.images.generate(
             prompt=prompt,
             n=1,
             **params

pkg/openai/modelmgr.py

@@ -5,26 +5,51 @@ ChatCompletion - gpt-3.5-turbo 等模型
 Completion - text-davinci-003 等模型
 此模块封装此两个接口的请求实现，为上层提供统一的调用方式
 """
-import openai, logging, threading, asyncio
-import openai.error as aiE
+import tiktoken
+import openai
+
+from ..openai.api import model as api_model
+from ..openai.api import completion as api_completion
+from ..openai.api import chat_completion as api_chat_completion
 
 COMPLETION_MODELS = {
-    'text-davinci-003',
-    'text-davinci-002',
-    'code-davinci-002',
-    'code-cushman-001',
-    'text-curie-001',
-    'text-babbage-001',
-    'text-ada-001',
+    "text-davinci-003", # legacy
+    "text-davinci-002", # legacy
+    "code-davinci-002", # legacy
+    "code-cushman-001", # legacy
+    "text-curie-001", # legacy
+    "text-babbage-001", # legacy
+    "text-ada-001", # legacy
+    "gpt-3.5-turbo-instruct",
 }
 
 CHAT_COMPLETION_MODELS = {
-    'gpt-3.5-turbo',
-    'gpt-3.5-turbo-0301',
-    'gpt-4',
-    'gpt-4-0314',
-    'gpt-4-32k',
-    'gpt-4-32k-0314'
+    # GPT 4 系列
+    "gpt-4-1106-preview",
+    "gpt-4-vision-preview",
+    "gpt-4",
+    "gpt-4-32k",
+    "gpt-4-0613",
+    "gpt-4-32k-0613",
+    "gpt-4-0314", # legacy
+    "gpt-4-32k-0314", # legacy
+    # GPT 3.5 系列
+    "gpt-3.5-turbo-1106",
+    "gpt-3.5-turbo",
+    "gpt-3.5-turbo-16k",
+    "gpt-3.5-turbo-0613", # legacy
+    "gpt-3.5-turbo-16k-0613", # legacy
+    "gpt-3.5-turbo-0301", # legacy
+    # One-API 接入
+    "SparkDesk",
+    "chatglm_pro",
+    "chatglm_std",
+    "chatglm_lite",
+    "qwen-v1",
+    "qwen-plus-v1",
+    "ERNIE-Bot",
+    "ERNIE-Bot-turbo",
+    "gemini-pro",
 }
 
 EDIT_MODELS = {
@@ -36,153 +61,86 @@ IMAGE_MODELS = {
 }
 
 
-class ModelRequest:
-    """模型接口请求父类"""
-
-    can_chat = False
-    runtime: threading.Thread = None
-    ret = {}
-    proxy: str = None
-    request_ready = True
-    error_info: str = "若在没有任何错误的情况下看到这句话，请带着配置文件上报Issues"
-
-    def __init__(self, model_name, user_name, request_fun, http_proxy:str = None, time_out = None):
-        self.model_name = model_name
-        self.user_name = user_name
-        self.request_fun = request_fun
-        self.time_out = time_out
-        if http_proxy != None:
-            self.proxy = http_proxy
-            openai.proxy = self.proxy
-            self.request_ready = False
-
-    async def __a_request__(self, **kwargs):
-        """异步请求"""
-
-        try:
-            self.ret: dict = await self.request_fun(**kwargs)
-            self.request_ready = True
-        except aiE.APIConnectionError as e:
-            self.error_info = "{}\n请检查网络连接或代理是否正常".format(e)
-            raise ConnectionError(self.error_info)
-        except ValueError as e:
-            self.error_info = "{}\n该错误可能是由于http_proxy格式设置错误引起的"
-        except Exception as e:
-            self.error_info = "{}\n由于请求异常产生的未知错误，请查看日志".format(e)
-            raise type(e)(self.error_info)
-
-    def request(self, **kwargs):
-        """向接口发起请求"""
-
-        if self.proxy != None: #异步请求
-            self.request_ready = False
-            loop = asyncio.new_event_loop()
-            self.runtime = threading.Thread(
-                target=loop.run_until_complete,
-                args=(self.__a_request__(**kwargs),)
-            )
-            self.runtime.start()
-        else: #同步请求
-            self.ret = self.request_fun(**kwargs)
-
-    def __msg_handle__(self, msg):
-        """将prompt dict转换成接口需要的格式"""
-        return msg
-    
-    def ret_handle(self):
-        '''
-        API消息返回处理函数
-        若重写该方法，应检查异步线程状态，或在需要检查处super该方法
-        '''
-        if self.runtime != None and isinstance(self.runtime, threading.Thread):
-            self.runtime.join(self.time_out)
-        if self.request_ready:
-            return
-        raise Exception(self.error_info)
-
-    def get_total_tokens(self):
-        try:
-            return self.ret['usage']['total_tokens']
-        except:
-            return 0
-
-    def get_message(self):
-        return self.message
-
-    def get_response(self):
-        return self.ret
-
-
-class ChatCompletionModel(ModelRequest):
-    """ChatCompletion接口的请求实现"""
-
-    Chat_role = ['system', 'user', 'assistant']
-    def __init__(self, model_name, user_name, http_proxy:str = None, **kwargs):
-        if http_proxy == None:
-            request_fun = openai.ChatCompletion.create
-        else:
-            request_fun = openai.ChatCompletion.acreate
-        self.can_chat = True
-        super().__init__(model_name, user_name, request_fun, http_proxy, **kwargs)
-
-    def request(self, prompts, **kwargs):
-        prompts = self.__msg_handle__(prompts)
-        kwargs['messages'] = prompts
-        super().request(**kwargs)
-        self.ret_handle()
-
-    def __msg_handle__(self, msgs):
-        temp_msgs = []
-        # 把msgs拷贝进temp_msgs
-        for msg in msgs:
-            temp_msgs.append(msg.copy())
-        return temp_msgs
-
-    def get_message(self):
-        return self.ret["choices"][0]["message"]['content'] #需要时直接加载加快请求速度，降低内存消耗
-
-
-class CompletionModel(ModelRequest):
-    """Completion接口的请求实现"""
-
-    def __init__(self, model_name, user_name, http_proxy:str = None, **kwargs):
-        if http_proxy == None:
-            request_fun = openai.Completion.create
-        else:
-            request_fun = openai.Completion.acreate
-        super().__init__(model_name, user_name, request_fun, http_proxy, **kwargs)
-
-    def request(self, prompts, **kwargs):
-        prompts = self.__msg_handle__(prompts)
-        kwargs['prompt'] = prompts
-        super().request(**kwargs)
-        self.ret_handle()
-
-    def __msg_handle__(self, msgs):
-        prompt = ''
-        for msg in msgs:
-            prompt = prompt + "{}: {}\n".format(msg['role'], msg['content'])
-        # for msg in msgs:
-        #     if msg['role'] == 'assistant':
-        #         prompt = prompt + "{}\n".format(msg['content'])
-        #     else:
-        #         prompt = prompt + "{}:{}\n".format(msg['role'] , msg['content'])
-        prompt = prompt + "assistant: "
-        return prompt
-
-    def get_message(self):
-        return self.ret["choices"][0]["text"]
-
-
-def create_openai_model_request(model_name: str, user_name: str = 'user', http_proxy:str = None) -> ModelRequest:
-    """使用给定的模型名称创建模型请求对象"""
+def select_request_cls(client: openai.Client, model_name: str, messages: list, args: dict) -> api_model.RequestBase:
     if model_name in CHAT_COMPLETION_MODELS:
-        model = ChatCompletionModel(model_name, user_name, http_proxy)
+        return api_chat_completion.ChatCompletionRequest(client, model_name, messages, **args)
     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
+        return api_completion.CompletionRequest(client, model_name, messages, **args)
+    raise ValueError("不支持模型[{}]，请检查配置文件".format(model_name))
+
+
+def count_chat_completion_tokens(messages: list, model: str) -> int:
+    """Return the number of tokens used by a list of messages."""
+    try:
+        encoding = tiktoken.encoding_for_model(model)
+    except KeyError:
+        print("Warning: model not found. Using cl100k_base encoding.")
+        encoding = tiktoken.get_encoding("cl100k_base")
+    if model in {
+        "gpt-3.5-turbo-0613",
+        "gpt-3.5-turbo-16k-0613",
+        "gpt-4-0314",
+        "gpt-4-32k-0314",
+        "gpt-4-0613",
+        "gpt-4-32k-0613",
+        "SparkDesk",
+        "chatglm_pro",
+        "chatglm_std",
+        "chatglm_lite",
+        "qwen-v1",
+        "qwen-plus-v1",
+        "ERNIE-Bot",
+        "ERNIE-Bot-turbo",
+        "gemini-pro",
+        }:
+        tokens_per_message = 3
+        tokens_per_name = 1
+    elif model == "gpt-3.5-turbo-0301":
+        tokens_per_message = 4  # every message follows <|start|>{role/name}\n{content}<|end|>\n
+        tokens_per_name = -1  # if there's a name, the role is omitted
+    elif "gpt-3.5-turbo" in model:
+        # print("Warning: gpt-3.5-turbo may update over time. Returning num tokens assuming gpt-3.5-turbo-0613.")
+        return count_chat_completion_tokens(messages, model="gpt-3.5-turbo-0613")
+    elif "gpt-4" in model:
+        # print("Warning: gpt-4 may update over time. Returning num tokens assuming gpt-4-0613.")
+        return count_chat_completion_tokens(messages, model="gpt-4-0613")
+    else:
+        raise NotImplementedError(
+            f"""count_chat_completion_tokens() is not implemented for model {model}. See https://github.com/openai/openai-python/blob/main/chatml.md for information on how messages are converted to tokens."""
+        )
+    num_tokens = 0
+    for message in messages:
+        num_tokens += tokens_per_message
+        for key, value in message.items():
+            num_tokens += len(encoding.encode(value))
+            if key == "name":
+                num_tokens += tokens_per_name
+    num_tokens += 3  # every reply is primed with <|start|>assistant<|message|>
+    return num_tokens
+
+
+def count_completion_tokens(messages: list, model: str) -> int:
+
+    try:
+        encoding = tiktoken.encoding_for_model(model)
+    except KeyError:
+        print("Warning: model not found. Using cl100k_base encoding.")
+        encoding = tiktoken.get_encoding("cl100k_base")
+
+    text = ""
+
+    for message in messages:
+        text += message['role'] + message['content'] + "\n"
+
+    text += "assistant: "
+
+    return len(encoding.encode(text))
+
+
+def count_tokens(messages: list, model: str):
+
+    if model in CHAT_COMPLETION_MODELS:
+        return count_chat_completion_tokens(messages, model)
+    elif model in COMPLETION_MODELS:
+        return count_completion_tokens(messages, model)
+    raise ValueError("不支持模型[{}]，请检查配置文件".format(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

@@ -8,13 +8,13 @@ import threading
 import time
 import json
 
-import pkg.openai.manager
-import pkg.openai.modelmgr
-import pkg.database.manager
-import pkg.utils.context
+from ..openai import manager as openai_manager
+from ..openai import modelmgr as openai_modelmgr
+from ..database import manager as database_manager
+from ..utils import context as context
 
-import pkg.plugin.host as plugin_host
-import pkg.plugin.models as plugin_models
+from ..plugin import host as plugin_host
+from ..plugin import models as plugin_models
 
 # 运行时保存的所有session
 sessions = {}
@@ -36,11 +36,11 @@ def reset_session_prompt(session_name, prompt):
     f.write(prompt)
     f.close()
     # 生成新数据
-    config = pkg.utils.context.get_config()
+    config = context.get_config_manager().data
     prompt = [
         {
             'role': 'system',
-            'content': config.default_prompt['default'] if type(config.default_prompt) == dict else config.default_prompt
+            'content': config['default_prompt']['default'] if type(config['default_prompt']) == dict else config['default_prompt']
         }
     ]
     # 警告
@@ -59,12 +59,12 @@ def load_sessions():
 
     global sessions
 
-    db_inst = pkg.utils.context.get_database_manager()
+    db_inst = context.get_database_manager()
 
     session_data = db_inst.load_valid_sessions()
 
     for session_name in session_data:
-        logging.info('加载session: {}'.format(session_name))
+        logging.debug('加载session: {}'.format(session_name))
 
         temp_session = Session(session_name)
         temp_session.name = session_name
@@ -107,9 +107,6 @@ class Session:
     prompt = []
     """使用list来保存会话中的回合"""
 
-    token_counts = []
-    """每个回合的token数量"""
-
     default_prompt = []
     """本session的默认prompt"""
 
@@ -173,17 +170,17 @@ class 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:
+            config = context.get_config_manager().data
+            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
+                    'session_expire_time': config['session_expire_time']
                 }
-                event = pkg.plugin.host.emit(plugin_models.SessionExpired, **args)
+                event = plugin_host.emit(plugin_models.SessionExpired, **args)
                 if event.is_prevented_default():
                     return
 
@@ -195,8 +192,15 @@ class Session:
 
     # 请求回复
     # 这个函数是阻塞的
-    def append(self, text: str) -> str:
-        """向session中添加一条消息，返回接口回复"""
+    def query(self, text: str=None) -> tuple[str, str, list[str]]:
+        """向session中添加一条消息，返回接口回复
+        
+        Args:
+            text (str): 用户消息
+
+        Returns:
+            tuple[str, str]: (接口回复, finish_reason, 已调用的函数列表)
+        """
 
         self.last_interact_timestamp = int(time.time())
 
@@ -208,42 +212,144 @@ class Session:
                 'default_prompt': self.default_prompt,
             }
 
-            event = pkg.plugin.host.emit(plugin_models.SessionFirstMessageReceived, **args)
+            event = plugin_host.emit(plugin_models.SessionFirstMessageReceived, **args)
             if event.is_prevented_default():
-                return None
+                return None, None, None
 
-        config = pkg.utils.context.get_config()
-        max_length = config.prompt_submit_length
+        config = context.get_config_manager().data
+        max_length = config['prompt_submit_length']
 
-        prompts, counts = self.cut_out(text, max_length)
+        local_default_prompt = self.default_prompt.copy()
+        local_prompt = self.prompt.copy()
 
-        # 计算请求前的prompt数量
-        total_token_before_query = 0
-        for token_count in counts:
-            total_token_before_query += token_count
+        # 触发PromptPreProcessing事件
+        args = {
+            'session_name': self.name,
+            'default_prompt': self.default_prompt,
+            'prompt': self.prompt,
+            'text_message': text,
+        }
 
-        # 向API请求补全
-        message, total_token = pkg.utils.context.get_openai_manager().request_completion(
-            prompts,
+        event = plugin_host.emit(plugin_models.PromptPreProcessing, **args)
+        
+        if event.get_return_value('default_prompt') is not None:
+            local_default_prompt = event.get_return_value('default_prompt')
+        
+        if event.get_return_value('prompt') is not None:
+            local_prompt = event.get_return_value('prompt')
+
+        if event.get_return_value('text_message') is not None:
+            text = event.get_return_value('text_message')
+
+        # 裁剪messages到合适长度
+        prompts, _ = self.cut_out(text, max_length, local_default_prompt, local_prompt)
+
+        res_text = ""
+
+        pending_msgs = []
+
+        total_tokens = 0
+
+        finish_reason: str = ""
+
+        funcs = []
+
+        trace_func_calls = config['trace_function_calls']
+        botmgr = context.get_qqbot_manager()
+
+        session_name_spt: list[str] = self.name.split("_")
+
+        pending_res_text = ""
+
+        # TODO 对不起，我知道这样非常非常屎山，但我之后会重构的
+        for resp in context.get_openai_manager().request_completion(prompts):
+
+            if pending_res_text != "":
+                botmgr.adapter.send_message(
+                    session_name_spt[0],
+                    session_name_spt[1],
+                    pending_res_text
+                )
+                pending_res_text = ""
+
+            finish_reason = resp['choices'][0]['finish_reason']
+
+            if resp['choices'][0]['message']['role'] == "assistant" and resp['choices'][0]['message']['content'] != None:  # 包含纯文本响应
+
+                if not trace_func_calls:
+                    res_text += resp['choices'][0]['message']['content']
+                else:
+                    res_text = resp['choices'][0]['message']['content']
+                    pending_res_text = resp['choices'][0]['message']['content']
+
+                total_tokens += resp['usage']['total_tokens']
+
+                msg = {
+                    "role": "assistant",
+                    "content": resp['choices'][0]['message']['content']
+                }
+
+                if 'function_call' in resp['choices'][0]['message']:
+                    msg['function_call'] = json.dumps(resp['choices'][0]['message']['function_call'])
+
+                pending_msgs.append(msg)
+
+            if resp['choices'][0]['message']['type'] == 'function_call':
+                # self.prompt.append(
+                #     {
+                #         "role": "assistant",
+                #         "content": "function call: "+json.dumps(resp['choices'][0]['message']['function_call'])
+                #     }
+                # )
+                if trace_func_calls:
+                    botmgr.adapter.send_message(
+                        session_name_spt[0],
+                        session_name_spt[1],
+                        "调用函数 "+resp['choices'][0]['message']['function_call']['name'] + "..."
                     )
 
+                total_tokens += resp['usage']['total_tokens']
+            elif resp['choices'][0]['message']['type'] == 'function_return':
+                # self.prompt.append(
+                #     {
+                #         "role": "function",
+                #         "name": resp['choices'][0]['message']['function_name'],
+                #         "content": json.dumps(resp['choices'][0]['message']['content'])
+                #     }
+                # )
+
+                # total_tokens += resp['usage']['total_tokens']
+                funcs.append(
+                    resp['choices'][0]['message']['function_name']
+                )
+                pass
+
+        # 向API请求补全
+        # message, total_token = pkg.utils.context.get_openai_manager().request_completion(
+        #     prompts,
+        # )
+
         # 成功获取，处理回复
-        res_test = message
-        res_ans = res_test.strip()
+        # res_test = message
+        res_ans = res_text.strip()
 
         # 将此次对话的双方内容加入到prompt中
+        # self.prompt.append({'role': 'user', 'content': text})
+        # self.prompt.append({'role': 'assistant', 'content': res_ans})
+        if text:
             self.prompt.append({'role': 'user', 'content': text})
-        self.prompt.append({'role': 'assistant', 'content': res_ans})
+        # 添加pending_msgs
+        self.prompt += pending_msgs
 
         # 向token_counts中添加本回合的token数量
-        self.token_counts.append(total_token-total_token_before_query)
-        logging.debug("本回合使用token: {}, session counts: {}".format(total_token-total_token_before_query, self.token_counts))
+        # self.token_counts.append(total_tokens-total_token_before_query)
+        # logging.debug("本回合使用token: {}, session counts: {}".format(total_tokens-total_token_before_query, self.token_counts))
 
         if self.just_switched_to_exist_session:
             self.just_switched_to_exist_session = False
             self.set_ongoing()
 
-        return res_ans if res_ans[0] != '\n' else res_ans[1:]
+        return res_ans if res_ans[0] != '\n' else res_ans[1:], finish_reason, funcs
 
     # 删除上一回合并返回上一回合的问题
     def undo(self) -> str:
@@ -261,7 +367,7 @@ class Session:
         return question
 
     # 构建对话体
-    def cut_out(self, msg: str, max_tokens: int) -> tuple[list, list]:
+    def cut_out(self, msg: str, max_tokens: int, default_prompt: list, prompt: list) -> tuple[list, list]:
         """将现有prompt进行切割处理，使得新的prompt长度不超过max_tokens
 
         :return: (新的prompt, 新的token_counts)
@@ -274,29 +380,25 @@ class Session:
 
         # 包装目前的对话回合内容
         changable_prompts = []
-        changable_counts = []
-        # 倒着来, 遍历prompt的步长为2, 遍历tokens_counts的步长为1
-        changable_index = len(self.prompt) - 1
-        token_count_index = len(self.token_counts) - 1
 
-        packed_tokens = 0
+        use_model = context.get_config_manager().data['completion_api_params']['model']
 
-        while changable_index >= 0 and token_count_index >= 0:
-            if packed_tokens + self.token_counts[token_count_index] > max_tokens:
+        ptr = len(prompt) - 1
+
+        # 直接从后向前扫描拼接，不管是否是整回合
+        while ptr >= 0:
+            if openai_modelmgr.count_tokens(prompt[ptr:ptr+1]+changable_prompts, use_model) > max_tokens:
                 break
 
-            changable_prompts.insert(0, self.prompt[changable_index])
-            changable_prompts.insert(0, self.prompt[changable_index - 1])
-            changable_counts.insert(0, self.token_counts[token_count_index])
-            packed_tokens += self.token_counts[token_count_index]
+            changable_prompts.insert(0, prompt[ptr])
 
-            changable_index -= 2
-            token_count_index -= 1
+            ptr -= 1
 
         # 将default_prompt和changable_prompts合并
-        result_prompt = self.default_prompt + changable_prompts
+        result_prompt = default_prompt + changable_prompts
 
         # 添加当前问题
+        if msg:
             result_prompt.append(
                 {
                     'role': 'user',
@@ -304,19 +406,16 @@ class Session:
                 }
             )
 
-        logging.debug('cut_out: {}\nchangable section tokens: {}\npacked counts: {}\nsession counts: {}'.format(json.dumps(result_prompt, ensure_ascii=False, indent=4),
-                                                                             packed_tokens,
-                                                                             changable_counts,
-                                                                             self.token_counts))
+        logging.debug("cut_out: {}".format(json.dumps(result_prompt, ensure_ascii=False, indent=4)))
 
-        return result_prompt, changable_counts
+        return result_prompt, openai_modelmgr.count_tokens(changable_prompts, use_model)
 
     # 持久化session
     def persistence(self):
         if self.prompt == self.get_default_prompt():
             return
 
-        db_inst = pkg.utils.context.get_database_manager()
+        db_inst = context.get_database_manager()
 
         name_spt = self.name.split('_')
 
@@ -327,7 +426,7 @@ class Session:
                                     json.dumps(self.prompt), json.dumps(self.default_prompt), json.dumps(self.token_counts))
 
     # 重置session
-    def reset(self, explicit: bool = False, expired: bool = False, schedule_new: bool = True, use_prompt: str = None):
+    def reset(self, explicit: bool = False, expired: bool = False, schedule_new: bool = True, use_prompt: str = None, persist: bool = False):
         if self.prompt:
             self.persistence()
             if explicit:
@@ -338,13 +437,14 @@ class Session:
                 }
 
                 # 此事件不支持阻止默认行为
-                _ = pkg.plugin.host.emit(plugin_models.SessionExplicitReset, **args)
+                _ = plugin_host.emit(plugin_models.SessionExplicitReset, **args)
 
-                pkg.utils.context.get_database_manager().explicit_close_session(self.name, self.create_timestamp)
+                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)
+                context.get_database_manager().set_session_expired(self.name, self.create_timestamp)
 
+        if not persist:  # 不要求保持default prompt
             self.default_prompt = self.get_default_prompt(use_prompt)
         self.prompt = []
         self.token_counts = []
@@ -359,11 +459,11 @@ class Session:
 
     # 将本session的数据库状态设置为on_going
     def set_ongoing(self):
-        pkg.utils.context.get_database_manager().set_session_ongoing(self.name, self.create_timestamp)
+        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)
+        last_one = context.get_database_manager().last_session(self.name, self.last_interact_timestamp)
         if last_one is None:
             return None
         else:
@@ -384,7 +484,7 @@ class Session:
 
     # 切换到下一个session
     def next_session(self):
-        next_one = pkg.utils.context.get_database_manager().next_session(self.name, self.last_interact_timestamp)
+        next_one = context.get_database_manager().next_session(self.name, self.last_interact_timestamp)
         if next_one is None:
             return None
         else:
@@ -404,13 +504,13 @@ class Session:
             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)
+        return context.get_database_manager().list_history(self.name, capacity, page)
 
     def delete_history(self, index: int) -> bool:
-        return pkg.utils.context.get_database_manager().delete_history(self.name, index)
+        return context.get_database_manager().delete_history(self.name, index)
 
     def delete_all_history(self) -> bool:
-        return pkg.utils.context.get_database_manager().delete_all_history(self.name)
+        return context.get_database_manager().delete_all_history(self.name)
 
     def draw_image(self, prompt: str):
-        return pkg.utils.context.get_openai_manager().request_image(prompt)
+        return context.get_openai_manager().request_image(prompt)

pkg/plugin/host.py

@@ -7,14 +7,21 @@ import pkgutil
 import sys
 import shutil
 import traceback
+import time
+import re
 
-import pkg.utils.updater as updater
-import pkg.utils.context as context
-import pkg.plugin.switch as switch
-import pkg.plugin.settings as settings
-import pkg.qqbot.adapter as msadapter
+from ..utils import updater as updater
+from ..utils import network as network
+from ..utils import context as context
+from ..plugin import switch as switch
+from ..plugin import settings as settings
+from ..qqbot import adapter as msadapter
+from ..plugin import metadata as metadata
 
 from mirai import Mirai
+import requests
+
+from CallingGPT.session.session import Session
 
 __plugins__ = {}
 """插件列表
@@ -42,6 +49,15 @@ __plugins__ = {}
 __plugins_order__ = []
 """插件顺序"""
 
+__enable_content_functions__ = True
+"""是否启用内容函数"""
+
+__callable_functions__ = []
+"""供GPT调用的函数结构"""
+
+__function_inst_map__: dict[str, callable] = {}
+"""函数名:实例 映射"""
+
 
 def generate_plugin_order():
     """根据__plugin__生成插件初始顺序，无视是否启用"""
@@ -54,6 +70,8 @@ def generate_plugin_order():
 def iter_plugins():
     """按照顺序迭代插件"""
     for plugin_name in __plugins_order__:
+        if plugin_name not in __plugins__:
+            continue
         yield __plugins__[plugin_name]
 
 
@@ -88,7 +106,7 @@ def walk_plugin_path(module, prefix='', path_prefix=''):
 
 def load_plugins():
     """加载插件"""
-    logging.info("加载插件")
+    logging.debug("加载插件")
     PluginHost()
     walk_plugin_path(__import__('plugins'))
 
@@ -102,20 +120,36 @@ def load_plugins():
     # 加载插件顺序
     settings.load_settings()
 
+    logging.debug("registered plugins: {}".format(__plugins__))
+
+    # 输出已注册的内容函数列表
+    logging.debug("registered content functions: {}".format(__callable_functions__))
+    logging.debug("function instance map: {}".format(__function_inst_map__))
+
+    # 迁移插件源地址记录
+    metadata.do_plugin_git_repo_migrate()
+
 
 def initialize_plugins():
     """初始化插件"""
     logging.info("初始化插件")
     import pkg.plugin.models as models
+
+    successfully_initialized_plugins = []
+
     for plugin in iter_plugins():
         # if not plugin['enabled']:
         #     continue
         try:
             models.__current_registering_plugin__ = plugin['name']
             plugin['instance'] = plugin["class"](plugin_host=context.get_plugin_host())
-            logging.info("插件 {} 已初始化".format(plugin['name']))
+            # logging.info("插件 {} 已初始化".format(plugin['name']))
+            successfully_initialized_plugins.append(plugin['name'])
         except:
             logging.error("插件{}初始化时发生错误: {}".format(plugin['name'], sys.exc_info()))
+            logging.debug(traceback.format_exc())
+    
+    logging.info("以下插件已初始化: {}".format(", ".join(successfully_initialized_plugins)))
 
 
 def unload_plugins():
@@ -134,34 +168,100 @@ def unload_plugins():
     #                 logging.error("插件{}卸载时发生错误: {}".format(plugin['name'], sys.exc_info()))
 
 
-def install_plugin(repo_url: str):
-    """安装插件，从git储存库获取并解决依赖"""
-    try:
-        import pkg.utils.pkgmgr
-        pkg.utils.pkgmgr.ensure_dulwich()
-    except:
-        pass
+def get_github_plugin_repo_label(repo_url: str) -> list[str]:
+    """获取username, repo"""
 
-    try:
-        import dulwich
-    except ModuleNotFoundError:
-        raise Exception("dulwich模块未安装,请查看 https://github.com/RockChinQ/QChatGPT/issues/77")
+    # 提取 username/repo , 正则表达式
+    repo =  re.findall(r'(?:https?://github\.com/|git@github\.com:)([^/]+/[^/]+?)(?:\.git|/|$)', repo_url)
 
-    from dulwich import porcelain
+    if len(repo) > 0: # github
+        return repo[0].split("/")
+    else:
+        return None
 
-    logging.info("克隆插件储存库: {}".format(repo_url))
-    repo = porcelain.clone(repo_url, "plugins/"+repo_url.split(".git")[0].split("/")[-1]+"/", checkout=True)
 
+def download_plugin_source_code(repo_url: str, target_path: str) -> str:
+    """下载插件源码"""
+    # 检查源类型
+    
+    # 提取 username/repo , 正则表达式
+    repo =  get_github_plugin_repo_label(repo_url)
+
+    target_path += repo[1]
+
+    if repo is not None: # github
+        logging.info("从 GitHub 下载插件源码...")
+
+        zipball_url = f"https://api.github.com/repos/{'/'.join(repo)}/zipball/HEAD"
+
+        zip_resp = requests.get(
+            url=zipball_url,
+            proxies=network.wrapper_proxies(),
+            stream=True
+        )
+
+        if zip_resp.status_code != 200:
+            raise Exception("下载源码失败: {}".format(zip_resp.text))
+        
+        if os.path.exists("temp/"+target_path):
+            shutil.rmtree("temp/"+target_path)
+
+        if os.path.exists(target_path):
+            shutil.rmtree(target_path)
+
+        os.makedirs("temp/"+target_path)
+
+        with open("temp/"+target_path+"/source.zip", "wb") as f:
+            for chunk in zip_resp.iter_content(chunk_size=1024):
+                if chunk:
+                    f.write(chunk)
+
+        logging.info("下载完成, 解压...")
+        import zipfile
+        with zipfile.ZipFile("temp/"+target_path+"/source.zip", 'r') as zip_ref:
+            zip_ref.extractall("temp/"+target_path)
+        os.remove("temp/"+target_path+"/source.zip")
+
+        # 目标是 username-repo-hash , 用正则表达式提取完整的文件夹名，复制到 plugins/repo
+        import glob
+
+        # 获取解压后的文件夹名
+        unzip_dir = glob.glob("temp/"+target_path+"/*")[0]
+
+        # 复制到 plugins/repo
+        shutil.copytree(unzip_dir, target_path+"/")
+
+        # 删除解压后的文件夹
+        shutil.rmtree(unzip_dir)
+
+        logging.info("解压完成")
+    else:
+        raise Exception("暂不支持的源类型，请使用 GitHub 仓库发行插件。")
+    
+    return repo[1]
+
+
+def check_requirements(path: str):
     # 检查此目录是否包含requirements.txt
-    if os.path.exists("plugins/"+repo_url.split(".git")[0].split("/")[-1]+"/requirements.txt"):
+    if os.path.exists(path+"/requirements.txt"):
         logging.info("检测到requirements.txt，正在安装依赖")
         import pkg.utils.pkgmgr
-        pkg.utils.pkgmgr.install_requirements("plugins/"+repo_url.split(".git")[0].split("/")[-1]+"/requirements.txt")
+        pkg.utils.pkgmgr.install_requirements(path+"/requirements.txt")
 
         import pkg.utils.log as log
         log.reset_logging()
 
 
+def install_plugin(repo_url: str):
+    """安装插件，从git储存库获取并解决依赖"""
+
+    repo_label = download_plugin_source_code(repo_url, "plugins/")
+
+    check_requirements("plugins/"+repo_label)
+
+    metadata.set_plugin_metadata(repo_label, repo_url, int(time.time()), "HEAD")
+
+
 def uninstall_plugin(plugin_name: str) -> str:
     """卸载插件"""
     if plugin_name not in __plugins__:
@@ -181,39 +281,43 @@ def uninstall_plugin(plugin_name: str) -> str:
 def update_plugin(plugin_name: str):
     """更新插件"""
     # 检查是否有远程地址记录
-    target_plugin_dir = "plugins/" + __plugins__[plugin_name]['path'].replace("\\", "/").split("plugins/")[1].split("/")[0]
+    plugin_path_name = get_plugin_path_name_by_plugin_name(plugin_name)
 
-    remote_url = updater.get_remote_url(target_plugin_dir)
+    meta = metadata.get_plugin_metadata(plugin_path_name)
+
+    if meta == {}:
+        raise Exception("没有此插件元数据信息，无法更新")
+
+    remote_url = meta['source']
     if remote_url == "https://github.com/RockChinQ/QChatGPT" or remote_url == "https://gitee.com/RockChin/QChatGPT" \
         or remote_url == "" or remote_url is None or remote_url == "http://github.com/RockChinQ/QChatGPT" or remote_url == "http://gitee.com/RockChin/QChatGPT":
         raise Exception("插件没有远程地址记录，无法更新")
     
-    # 把远程clone到temp/plugins/update/插件名
-    logging.info("克隆插件储存库: {}".format(remote_url))
+    # 重新安装插件
+    logging.info("正在重新安装插件以进行更新...")
 
-    from dulwich import porcelain
-    clone_target_dir = "temp/plugins/update/"+target_plugin_dir.split("/")[-1]+"/"
+    install_plugin(remote_url)
 
-    if os.path.exists(clone_target_dir):
-        shutil.rmtree(clone_target_dir)
 
-    if not os.path.exists(clone_target_dir):
-        os.makedirs(clone_target_dir)
-    repo = porcelain.clone(remote_url, clone_target_dir, checkout=True)
+def get_plugin_name_by_path_name(plugin_path_name: str) -> str:
+    for k, v in __plugins__.items():
+        if v['path'] == "plugins/"+plugin_path_name+"/main.py":
+            return k
+    return None
 
-    # 检查此目录是否包含requirements.txt
-    if os.path.exists(clone_target_dir+"requirements.txt"):
-        logging.info("检测到requirements.txt，正在安装依赖")
-        import pkg.utils.pkgmgr
-        pkg.utils.pkgmgr.install_requirements(clone_target_dir+"requirements.txt")
 
-        import pkg.utils.log as log
-        log.reset_logging()
+def get_plugin_path_name_by_plugin_name(plugin_name: str) -> str:
+    if plugin_name not in __plugins__:
+        return None
     
-    # 将temp/plugins/update/插件名 覆盖到 plugins/插件名
-    shutil.rmtree(target_plugin_dir)
+    plugin_main_module_path = __plugins__[plugin_name]['path']
+
+    plugin_main_module_path = plugin_main_module_path.replace("\\", "/")
+
+    spt = plugin_main_module_path.split("/")
+
+    return spt[1]
 
-    shutil.copytree(clone_target_dir, target_plugin_dir)
 
 class EventContext:
     """事件上下文"""
@@ -251,7 +355,7 @@ class EventContext:
             self.__return_value__[key] = []
         self.__return_value__[key].append(ret)
 
-    def get_return(self, key: str):
+    def get_return(self, key: str) -> list:
         """获取key的所有返回值"""
         if key in self.__return_value__:
             return self.__return_value__[key]
@@ -300,7 +404,9 @@ class PluginHost:
     """插件宿主"""
 
     def __init__(self):
+        """初始化插件宿主"""
         context.set_plugin_host(self)
+        self.calling_gpt_session = Session([])
 
     def get_runtime_context(self) -> context:
         """获取运行时上下文（pkg.utils.context模块的对象）
@@ -370,7 +476,7 @@ class PluginHost:
                         logging.debug("插件 {} 已要求阻止事件 {} 的默认行为".format(plugin['name'], event_name))
 
                 except Exception as e:
-                    logging.error("插件{}触发事件{}时发生错误".format(plugin['name'], event_name))
+                    logging.error("插件{}响应事件{}时发生错误".format(plugin['name'], event_name))
                     logging.error(traceback.format_exc())
 
             # print("done:{}".format(plugin['name']))

pkg/plugin/metadata.py

@@ -0,0 +1,87 @@
+import os
+import shutil
+import json
+import time
+
+import dulwich.errors as dulwich_err
+
+from ..utils import updater
+
+
+def read_metadata_file() -> dict:
+    # 读取 plugins/metadata.json 文件
+    if not os.path.exists('plugins/metadata.json'):
+        return {}
+    with open('plugins/metadata.json', 'r') as f:
+        return json.load(f)
+
+
+def write_metadata_file(metadata: dict):
+    if not os.path.exists('plugins'):
+        os.mkdir('plugins')
+
+    with open('plugins/metadata.json', 'w') as f:
+        json.dump(metadata, f, indent=4, ensure_ascii=False)
+
+
+def do_plugin_git_repo_migrate():
+    # 仅在 plugins/metadata.json 不存在时执行
+    if os.path.exists('plugins/metadata.json'):
+        return
+
+    metadata = read_metadata_file()
+
+    # 遍历 plugins 下所有目录，获取目录的git远程地址
+    for plugin_name in os.listdir('plugins'):
+        plugin_path = os.path.join('plugins', plugin_name)
+        if not os.path.isdir(plugin_path):
+            continue
+        
+        remote_url = None
+        try:
+            remote_url = updater.get_remote_url(plugin_path)
+        except dulwich_err.NotGitRepository:
+            continue
+        if remote_url == "https://github.com/RockChinQ/QChatGPT" or remote_url == "https://gitee.com/RockChin/QChatGPT" \
+            or remote_url == "" or remote_url is None or remote_url == "http://github.com/RockChinQ/QChatGPT" or remote_url == "http://gitee.com/RockChin/QChatGPT":
+            continue
+
+        from . import host
+
+        if plugin_name not in metadata:
+            metadata[plugin_name] = {
+                'source': remote_url,
+                'install_timestamp': int(time.time()),
+                'ref': 'HEAD',
+            }
+
+    write_metadata_file(metadata)
+    
+
+def set_plugin_metadata(
+    plugin_name: str,
+    source: str,
+    install_timestamp: int,
+    ref: str,
+):
+    metadata = read_metadata_file()
+    metadata[plugin_name] = {
+        'source': source,
+        'install_timestamp': install_timestamp,
+        'ref': ref,
+    }
+    write_metadata_file(metadata)
+
+
+def remove_plugin_metadata(plugin_name: str):
+    metadata = read_metadata_file()
+    if plugin_name in metadata:
+        del metadata[plugin_name]
+        write_metadata_file(metadata)
+
+
+def get_plugin_metadata(plugin_name: str) -> dict:
+    metadata = read_metadata_file()
+    if plugin_name in metadata:
+        return metadata[plugin_name]
+    return {}

pkg/plugin/models.py

@@ -1,7 +1,7 @@
 import logging
 
-import pkg.plugin.host as host
-import pkg.utils.context
+from ..plugin import host
+from ..utils import context
 
 PersonMessageReceived = "person_message_received"
 """收到私聊消息时，在判断是否应该响应前触发
@@ -88,6 +88,8 @@ NormalMessageResponded = "normal_message_responded"
         session: pkg.openai.session.Session 会话对象
         prefix: str 回复文字消息的前缀
         response_text: str 响应文本
+        finish_reason: str 响应结束原因
+        funcs_called: list[str] 此次响应中调用的函数列表
     
     returns (optional):
         prefix: str 修改后的回复文字消息的前缀
@@ -132,18 +134,64 @@ KeySwitched = "key_switched"
         key_list: list[str] api-key列表
 """
 
+PromptPreProcessing = "prompt_pre_processing"
+"""每回合调用接口前对prompt进行预处理时触发，此事件不支持阻止默认行为
+    kwargs:
+        session_name: str 会话名称(<launcher_type>_<launcher_id>)
+        default_prompt: list 此session使用的情景预设内容
+        prompt: list 此session现有的prompt内容
+        text_message: str 用户发送的消息文本
     
-def on(event: str):
+    returns (optional):
+        default_prompt: list 修改后的情景预设内容
+        prompt: list 修改后的prompt内容
+        text_message: str 修改后的消息文本
+"""
+
+
+def on(*args, **kwargs):
     """注册事件监听器
-    :param
-        event: str 事件名称
     """
-    return Plugin.on(event)
+    return Plugin.on(*args, **kwargs)
+
+def func(*args, **kwargs):
+    """注册内容函数，声明此函数为一个内容函数，在对话中将发送此函数给GPT以供其调用
+    此函数可以具有任意的参数，但必须按照[此文档](https://github.com/RockChinQ/CallingGPT/wiki/1.-Function-Format#function-format)
+    所述的格式编写函数的docstring。
+    此功能仅支持在使用gpt-3.5或gpt-4系列模型时使用。
+    """
+    return Plugin.func(*args, **kwargs)
 
 
 __current_registering_plugin__ = ""
 
 
+def require_ver(ge: str, le: str="v999.9.9") -> bool:
+    """插件版本要求装饰器
+
+    Args:
+        ge (str): 最低版本要求
+        le (str, optional): 最高版本要求
+
+    Returns:
+        bool: 是否满足要求, False时为无法获取版本号，True时为满足要求，报错为不满足要求
+    """
+    qchatgpt_version = ""
+    
+    from pkg.utils.updater import get_current_tag, compare_version_str
+
+    try:
+        qchatgpt_version = get_current_tag()  # 从updater模块获取版本号
+    except:
+        return False
+
+    if compare_version_str(qchatgpt_version, ge) < 0 or \
+        (compare_version_str(qchatgpt_version, le) > 0):
+        raise Exception("QChatGPT 版本不满足要求，某些功能（可能是由插件提供的）无法正常使用。（要求版本：{}-{}，但当前版本：{}）".format(ge, le, qchatgpt_version))
+
+    return True
+
+
 class Plugin:
     """插件基类"""
 
@@ -176,6 +224,34 @@ class Plugin:
 
         return wrapper
 
+    @classmethod
+    def func(cls, name: str=None):
+        """内容函数装饰器
+        """
+        global __current_registering_plugin__
+        from CallingGPT.entities.namespace import get_func_schema
+
+        def wrapper(func):
+
+            function_schema = get_func_schema(func)
+            function_schema['name'] = __current_registering_plugin__ + '-' + (func.__name__ if name is None else name)
+
+            function_schema['enabled'] = True
+
+            host.__function_inst_map__[function_schema['name']] = function_schema['function']
+
+            del function_schema['function']
+
+            # logging.debug("registering content function: p='{}', f='{}', s={}".format(__current_registering_plugin__, func, function_schema))
+
+            host.__callable_functions__.append(
+                function_schema
+            )
+
+            return func
+
+        return wrapper
+
 
 def register(name: str, description: str, version: str, author: str):
     """注册插件, 此函数作为装饰器使用
@@ -209,7 +285,7 @@ def register(name: str, description: str, version: str, author: str):
         cls.description = description
         cls.version = version
         cls.author = author
-        cls.host = pkg.utils.context.get_plugin_host()
+        cls.host = context.get_plugin_host()
         cls.enabled = True
         cls.path = host.__current_module_path__
 

pkg/plugin/settings.py

@@ -1,14 +1,17 @@
 import json
 import os
 
-import pkg.plugin.host as host
 import logging
 
+from ..plugin import host
 
 def wrapper_dict_from_runtime_context() -> dict:
     """从变量中包装settings.json的数据字典"""
     settings = {
-        "order": []
+        "order": [],
+        "functions": {
+            "enabled": host.__enable_content_functions__
+        }
     }
 
     for plugin_name in host.__plugins_order__:
@@ -22,6 +25,11 @@ def apply_settings(settings: dict):
     if "order" in settings:
         host.__plugins_order__ = settings["order"]
 
+    if "functions" in settings:
+        if "enabled" in settings["functions"]:
+            host.__enable_content_functions__ = settings["functions"]["enabled"]
+            # logging.debug("set content function enabled: {}".format(host.__enable_content_functions__))
+
 
 def dump_settings():
     """保存settings.json数据"""
@@ -78,6 +86,17 @@ def load_settings():
             settings["order"].append(plugin_name)
             settings_modified = True
 
+    if "functions" not in settings:
+        settings["functions"] = {
+            "enabled": host.__enable_content_functions__
+        }
+        settings_modified = True
+    elif "enabled" not in settings["functions"]:
+        settings["functions"]["enabled"] = host.__enable_content_functions__
+        settings_modified = True
+
+    logging.info("已全局{}内容函数。".format("启用" if settings["functions"]["enabled"] else "禁用"))
+
     apply_settings(settings)
 
     if settings_modified:

pkg/plugin/switch.py

@@ -3,7 +3,7 @@ import json
 import logging
 import os
 
-import pkg.plugin.host as host
+from ..plugin import host
 
 
 def wrapper_dict_from_plugin_list() -> dict:
@@ -28,6 +28,11 @@ def apply_switch(switch: dict):
     for plugin_name in switch:
         host.__plugins__[plugin_name]["enabled"] = switch[plugin_name]["enabled"]
 
+        # 查找此插件的所有内容函数
+        for func in host.__callable_functions__:
+            if func['name'].startswith(plugin_name + '-'):
+                func['enabled'] = switch[plugin_name]["enabled"]
+
 
 def dump_switch():
     """保存开关数据"""

pkg/qqbot/adapter.py

@@ -5,6 +5,7 @@ import mirai
 
 
 class MessageSourceAdapter:
+    bot_account_id: int
     def __init__(self, config: dict):
         pass
 

pkg/qqbot/banlist.py

@@ -1,18 +1,18 @@
-import pkg.utils.context
+from ..utils import context
 
 
 def is_banned(launcher_type: str, launcher_id: int, sender_id: int) -> bool:
-    if not pkg.utils.context.get_qqbot_manager().enable_banlist:
+    if not context.get_qqbot_manager().enable_banlist:
         return False
     
     result = False
     
     if launcher_type == 'group':
         # 检查是否显式声明发起人QQ要被person忽略
-        if sender_id in pkg.utils.context.get_qqbot_manager().ban_person:
+        if sender_id in context.get_qqbot_manager().ban_person:
             result = True
         else:
-            for group_rule in pkg.utils.context.get_qqbot_manager().ban_group:
+            for group_rule in context.get_qqbot_manager().ban_group:
                 if type(group_rule) == int:
                     if group_rule == launcher_id:  # 此群群号被禁用
                         result = True
@@ -32,7 +32,7 @@ def is_banned(launcher_type: str, launcher_id: int, sender_id: int) -> bool:
                     
     else:
         # ban_person, 与群规则相同
-        for person_rule in pkg.utils.context.get_qqbot_manager().ban_person:
+        for person_rule in context.get_qqbot_manager().ban_person:
             if type(person_rule) == int:
                 if person_rule == launcher_id:
                     result = True

pkg/qqbot/blob.py

@@ -2,21 +2,21 @@
 import os
 import time
 import base64
+import typing
 
-import config
 from mirai.models.message import MessageComponent, MessageChain, Image
 from mirai.models.message import ForwardMessageNode
 from mirai.models.base import MiraiBaseModel
-from typing import List
-import pkg.utils.context as context
-import pkg.utils.text2img as text2img
+
+from ..utils import text2img
+from ..utils import context
 
 
 class ForwardMessageDiaplay(MiraiBaseModel):
     title: str = "群聊的聊天记录"
     brief: str = "[聊天记录]"
     source: str = "聊天记录"
-    preview: List[str] = []
+    preview: typing.List[str] = []
     summary: str = "查看x条转发消息"
 
 
@@ -26,7 +26,7 @@ class Forward(MessageComponent):
     """消息组件类型。"""
     display: ForwardMessageDiaplay
     """显示信息"""
-    node_list: List[ForwardMessageNode]
+    node_list: typing.List[ForwardMessageNode]
     """转发消息节点列表。"""
     def __init__(self, *args, **kwargs):
         if len(args) == 1:
@@ -64,13 +64,16 @@ def text_to_image(text: str) -> MessageComponent:
 
 def check_text(text: str) -> list:
     """检查文本是否为长消息，并转换成该使用的消息链组件"""
-    if len(text) > config.blob_message_threshold:
+
+    config = context.get_config_manager().data
+
+    if len(text) > config['blob_message_threshold']:
 
         # logging.info("长消息: {}".format(text))
-        if config.blob_message_strategy == 'image':
+        if config['blob_message_strategy'] == 'image':
             # 转换成图片
             return [text_to_image(text)]
-        elif config.blob_message_strategy == 'forward':
+        elif config['blob_message_strategy'] == 'forward':
 
             # 包装转发消息
             display = ForwardMessageDiaplay(
@@ -82,7 +85,7 @@ def check_text(text: str) -> list:
             )
 
             node = ForwardMessageNode(
-                sender_id=config.mirai_http_api_config['qq'],
+                sender_id=config['mirai_http_api_config']['qq'],
                 sender_name='bot',
                 message_chain=MessageChain([text])
             )

pkg/qqbot/cmds/aamgr.py

@@ -1,10 +1,7 @@
-import importlib
-import inspect
 import logging
 import copy
 import pkgutil
 import traceback
-import types
 import json
 
 
@@ -327,6 +324,10 @@ def apply_privileges():
     for path, priv in data.items():
         if path == 'comment':
             continue
+        
+        if path not in __command_list__:
+            continue
+        
         if __command_list__[path]['privilege'] != priv:
             logging.debug('应用权限: {} -> {}(default: {})'.format(path, priv, __command_list__[path]['privilege']))
 

pkg/qqbot/cmds/funcs/draw.py

@@ -1,11 +1,12 @@
-from ..aamgr import AbstractCommandNode, Context
 import logging
 
-from mirai import Image
-import config
+import mirai
+
+from .. import aamgr
+from ....utils import context
 
 
-@AbstractCommandNode.register(
+@aamgr.AbstractCommandNode.register(
     parent=None,
     name="draw",
     description="使用DALL·E生成图片",
@@ -13,9 +14,9 @@ import config
     aliases=[],
     privilege=1
 )
-class DrawCommand(AbstractCommandNode):
+class DrawCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         import pkg.openai.session
 
         reply = []
@@ -28,9 +29,9 @@ class DrawCommand(AbstractCommandNode):
             res = session.draw_image(" ".join(ctx.params))
 
             logging.debug("draw_image result:{}".format(res))
-            reply = [Image(url=res['data'][0]['url'])]
-            if not (hasattr(config, 'include_image_description')
-                    and not config.include_image_description):
+            reply = [mirai.Image(url=res.data[0].url)]
+            config = context.get_config_manager().data
+            if config['include_image_description']:
                 reply.append(" ".join(ctx.params))
 
         return True, reply

pkg/qqbot/cmds/funcs/func.py

@@ -0,0 +1,32 @@
+import logging
+import json
+
+from .. import aamgr
+
+@aamgr.AbstractCommandNode.register(
+    parent=None,
+    name="func",
+    description="管理内容函数",
+    usage="!func",
+    aliases=[],
+    privilege=1
+)
+class FuncCommand(aamgr.AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
+        from pkg.plugin.models import host
+
+        reply = []
+
+        reply_str = "当前已加载的内容函数：\n\n"
+
+        logging.debug("host.__callable_functions__: {}".format(json.dumps(host.__callable_functions__, indent=4)))
+
+        index = 1
+        for func in host.__callable_functions__:
+            reply_str += "{}. {}{}:\n{}\n\n".format(index, ("(已禁用) " if not func['enabled'] else ""), func['name'], func['description'])
+            index += 1
+            
+        reply = [reply_str]
+
+        return True, reply

pkg/qqbot/cmds/plugin/plugin.py

@@ -1,22 +1,19 @@
-from ..aamgr import AbstractCommandNode, Context
-
-import os
-
-import pkg.plugin.host as plugin_host
-import pkg.utils.updater as updater
+from ....plugin import host as plugin_host
+from ....utils import updater
+from .. import aamgr
 
 
-@AbstractCommandNode.register(
+@aamgr.AbstractCommandNode.register(
     parent=None,
     name="plugin",
     description="插件管理",
     usage="!plugin\n!plugin get <插件仓库地址>\n!plugin update\n!plugin del <插件名>\n!plugin on <插件名>\n!plugin off <插件名>",
     aliases=[],
-    privilege=2
+    privilege=1
 )
-class PluginCommand(AbstractCommandNode):
+class PluginCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         reply = []
         plugin_list = plugin_host.__plugins__
         if len(ctx.params) == 0:
@@ -48,7 +45,7 @@ class PluginCommand(AbstractCommandNode):
             return False, []
 
     
-@AbstractCommandNode.register(
+@aamgr.AbstractCommandNode.register(
     parent=PluginCommand,
     name="get",
     description="安装插件",
@@ -56,9 +53,9 @@ class PluginCommand(AbstractCommandNode):
     aliases=[],
     privilege=2
 )
-class PluginGetCommand(AbstractCommandNode):
+class PluginGetCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         import threading
         import logging
         import pkg.utils.context
@@ -81,17 +78,17 @@ class PluginGetCommand(AbstractCommandNode):
         return True, reply
 
 
-@AbstractCommandNode.register(
+@aamgr.AbstractCommandNode.register(
     parent=PluginCommand,
     name="update",
-    description="更新所有插件",
+    description="更新指定插件或全部插件",
     usage="!plugin update",
     aliases=[],
     privilege=2
 )
-class PluginUpdateCommand(AbstractCommandNode):
+class PluginUpdateCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         import threading
         import logging
         plugin_list = plugin_host.__plugins__
@@ -110,7 +107,9 @@ class PluginUpdateCommand(AbstractCommandNode):
                             plugin_host.update_plugin(key)
                             updated.append(key)
                     else:
-                        if ctx.crt_params[0] in plugin_list:
+                        plugin_path_name = plugin_host.get_plugin_path_name_by_plugin_name(ctx.crt_params[0])
+
+                        if plugin_path_name is not None:
                             plugin_host.update_plugin(ctx.crt_params[0])
                             updated.append(ctx.crt_params[0])
                         else:
@@ -119,7 +118,7 @@ class PluginUpdateCommand(AbstractCommandNode):
                     pkg.utils.context.get_qqbot_manager().notify_admin("已更新插件: {}, 请发送 !reload 重载插件".format(", ".join(updated)))
                 except Exception as e:
                     logging.error("插件更新失败:{}".format(e))
-                    pkg.utils.context.get_qqbot_manager().notify_admin("插件更新失败:{} 请尝试手动更新插件".format(e))
+                    pkg.utils.context.get_qqbot_manager().notify_admin("插件更新失败:{} 请使用 !plugin 命令确认插件名称或尝试手动更新插件".format(e))
 
             reply = ["[bot]正在更新插件，请勿重复发起..."]
             threading.Thread(target=closure).start()
@@ -128,7 +127,7 @@ class PluginUpdateCommand(AbstractCommandNode):
         return True, reply
 
 
-@AbstractCommandNode.register(
+@aamgr.AbstractCommandNode.register(
     parent=PluginCommand,
     name="del",
     description="删除插件",
@@ -136,9 +135,9 @@ class PluginUpdateCommand(AbstractCommandNode):
     aliases=[],
     privilege=2
 )
-class PluginDelCommand(AbstractCommandNode):
+class PluginDelCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         plugin_list = plugin_host.__plugins__
         reply = []
 
@@ -155,7 +154,7 @@ class PluginDelCommand(AbstractCommandNode):
         return True, reply
 
 
-@AbstractCommandNode.register(
+@aamgr.AbstractCommandNode.register(
     parent=PluginCommand,
     name="on",
     description="启用指定插件",
@@ -163,7 +162,7 @@ class PluginDelCommand(AbstractCommandNode):
     aliases=[],
     privilege=2
 )
-@AbstractCommandNode.register(
+@aamgr.AbstractCommandNode.register(
     parent=PluginCommand,
     name="off",
     description="禁用指定插件",
@@ -171,9 +170,9 @@ class PluginDelCommand(AbstractCommandNode):
     aliases=[],
     privilege=2
 )
-class PluginOnOffCommand(AbstractCommandNode):
+class PluginOnOffCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         import pkg.plugin.switch as plugin_switch
 
         plugin_list = plugin_host.__plugins__
@@ -188,6 +187,11 @@ class PluginOnOffCommand(AbstractCommandNode):
             plugin_name = ctx.crt_params[0]
             if plugin_name in plugin_list:
                 plugin_list[plugin_name]['enabled'] = new_status
+
+                for func in plugin_host.__callable_functions__:
+                    if func['name'].startswith(plugin_name+"-"):
+                        func['enabled'] = new_status
+
                 plugin_switch.dump_switch()
                 reply = ["[bot]已{}插件: {}".format("启用" if new_status else "禁用", plugin_name)]
             else:

pkg/qqbot/cmds/session/default.py

@@ -1,7 +1,8 @@
-from ..aamgr import AbstractCommandNode, Context
+from .. import aamgr
+from ....utils import context
 
 
-@AbstractCommandNode.register(
+@aamgr.AbstractCommandNode.register(
     parent=None,
     name="default",
     description="操作情景预设",
@@ -9,19 +10,20 @@ from ..aamgr import AbstractCommandNode, Context
     aliases=[],
     privilege=1
 )
-class DefaultCommand(AbstractCommandNode):
+class DefaultCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         import pkg.openai.session
         session_name = ctx.session_name
         params = ctx.params
         reply = []
-        import config
+
+        config = context.get_config_manager().data
 
         if len(params) == 0:
             # 输出目前所有情景预设
             import pkg.openai.dprompt as dprompt
-            reply_str = "[bot]当前所有情景预设({}模式):\n\n".format(config.preset_mode)
+            reply_str = "[bot]当前所有情景预设({}模式):\n\n".format(config['preset_mode'])
 
             prompts = dprompt.mode_inst().list()
 
@@ -45,7 +47,7 @@ class DefaultCommand(AbstractCommandNode):
         return True, reply
 
 
-@AbstractCommandNode.register(
+@aamgr.AbstractCommandNode.register(
     parent=DefaultCommand,
     name="set",
     description="设置默认情景预设",
@@ -53,9 +55,9 @@ class DefaultCommand(AbstractCommandNode):
     aliases=[],
     privilege=2
 )
-class DefaultSetCommand(AbstractCommandNode):
+class DefaultSetCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         reply = []
 
         if len(ctx.crt_params) == 0:

pkg/qqbot/cmds/session/del.py

@@ -1,8 +1,7 @@
-from ..aamgr import AbstractCommandNode, Context
-import datetime
+from .. import aamgr
 
 
-@AbstractCommandNode.register(
+@aamgr.AbstractCommandNode.register(
     parent=None,
     name="del",
     description="删除当前会话的历史记录",
@@ -10,9 +9,9 @@ import datetime
     aliases=[],
     privilege=1
 )
-class DelCommand(AbstractCommandNode):
+class DelCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         import pkg.openai.session
         session_name = ctx.session_name
         params = ctx.params
@@ -33,7 +32,7 @@ class DelCommand(AbstractCommandNode):
         return True, reply
 
 
-@AbstractCommandNode.register(
+@aamgr.AbstractCommandNode.register(
     parent=DelCommand,
     name="all",
     description="删除当前会话的全部历史记录",
@@ -41,9 +40,9 @@ class DelCommand(AbstractCommandNode):
     aliases=[],
     privilege=1
 )
-class DelAllCommand(AbstractCommandNode):
+class DelAllCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         import pkg.openai.session
         session_name = ctx.session_name
         reply = []

pkg/qqbot/cmds/session/delhst.py

@@ -1,7 +1,7 @@
-from ..aamgr import AbstractCommandNode, Context
+from .. import aamgr
 
 
-@AbstractCommandNode.register(
+@aamgr.AbstractCommandNode.register(
     parent=None,
     name="delhst",
     description="删除指定会话的所有历史记录",
@@ -9,9 +9,9 @@ from ..aamgr import AbstractCommandNode, Context
     aliases=[],
     privilege=2
 )
-class DelHistoryCommand(AbstractCommandNode):
+class DelHistoryCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         import pkg.openai.session
         import pkg.utils.context
         params = ctx.params
@@ -31,7 +31,7 @@ class DelHistoryCommand(AbstractCommandNode):
         return True, reply
     
 
-@AbstractCommandNode.register(
+@aamgr.AbstractCommandNode.register(
     parent=DelHistoryCommand,
     name="all",
     description="删除所有会话的全部历史记录",
@@ -39,9 +39,9 @@ class DelHistoryCommand(AbstractCommandNode):
     aliases=[],
     privilege=2
 )
-class DelAllHistoryCommand(AbstractCommandNode):
+class DelAllHistoryCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         import pkg.utils.context
         reply = []
         pkg.utils.context.get_database_manager().delete_all_session_history()

pkg/qqbot/cmds/session/last.py

@@ -1,8 +1,9 @@
-from ..aamgr import AbstractCommandNode, Context
 import datetime
 
+from .. import aamgr
 
-@AbstractCommandNode.register(
+
+@aamgr.AbstractCommandNode.register(
     parent=None,
     name="last",
     description="切换前一次对话",
@@ -10,9 +11,9 @@ import datetime
     aliases=[],
     privilege=1
 )
-class LastCommand(AbstractCommandNode):
+class LastCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         import pkg.openai.session
         session_name = ctx.session_name
 

pkg/qqbot/cmds/session/list.py

@@ -1,9 +1,10 @@
-from ..aamgr import AbstractCommandNode, Context
 import datetime
 import json
 
+from .. import aamgr
 
-@AbstractCommandNode.register(
+
+@aamgr.AbstractCommandNode.register(
     parent=None,
     name='list',
     description='列出当前会话的所有历史记录',
@@ -11,9 +12,9 @@ import json
     aliases=[],
     privilege=1
 )
-class ListCommand(AbstractCommandNode):
+class ListCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         import pkg.openai.session
         session_name = ctx.session_name
         params = ctx.params

pkg/qqbot/cmds/session/next.py

@@ -1,8 +1,9 @@
-from ..aamgr import AbstractCommandNode, Context
 import datetime
 
+from .. import aamgr
 
-@AbstractCommandNode.register(
+
+@aamgr.AbstractCommandNode.register(
     parent=None,
     name="next",
     description="切换后一次对话",
@@ -10,9 +11,9 @@ import datetime
     aliases=[],
     privilege=1
 )
-class NextCommand(AbstractCommandNode):
+class NextCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         import pkg.openai.session
         session_name = ctx.session_name
         reply = []

pkg/qqbot/cmds/session/prompt.py

@@ -1,8 +1,7 @@
-from ..aamgr import AbstractCommandNode, Context
-import datetime
+from .. import aamgr
 
 
-@AbstractCommandNode.register(
+@aamgr.AbstractCommandNode.register(
     parent=None,
     name="prompt",
     description="获取当前会话的前文",
@@ -10,9 +9,9 @@ import datetime
     aliases=[],
     privilege=1
 )
-class PromptCommand(AbstractCommandNode):
+class PromptCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         import pkg.openai.session
         session_name = ctx.session_name
         params = ctx.params

pkg/qqbot/cmds/session/resend.py

@@ -1,8 +1,7 @@
-from ..aamgr import AbstractCommandNode, Context
-import datetime
+from .. import aamgr
 
 
-@AbstractCommandNode.register(
+@aamgr.AbstractCommandNode.register(
     parent=None,
     name="resend",
     description="重新获取上一次问题的回复",
@@ -10,20 +9,22 @@ import datetime
     aliases=[],
     privilege=1
 )
-class ResendCommand(AbstractCommandNode):
+class ResendCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
-        import pkg.openai.session
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
+        from ....openai import session as openai_session
+        from ....utils import context
+        from ....qqbot import message
         import config
         session_name = ctx.session_name
         reply = []
 
-        session = pkg.openai.session.get_session(session_name)
+        session = openai_session.get_session(session_name)
         to_send = session.undo()
 
-        mgr = pkg.utils.context.get_qqbot_manager()
+        mgr = context.get_qqbot_manager()
 
-        reply = pkg.qqbot.message.process_normal_message(to_send, mgr, config,
+        reply = message.process_normal_message(to_send, mgr, config,
                                                         ctx.launcher_type, ctx.launcher_id,
                                                         ctx.sender_id)
 

pkg/qqbot/cmds/session/reset.py

@@ -1,11 +1,11 @@
-from ..aamgr import AbstractCommandNode, Context
 import tips as tips_custom
 
-import pkg.openai.session
-import pkg.utils.context
+from .. import aamgr
+from ....openai import session
+from ....utils import context
 
 
-@AbstractCommandNode.register(
+@aamgr.AbstractCommandNode.register(
     parent=None,
     name='reset',
     description='重置当前会话',
@@ -13,21 +13,21 @@ import pkg.utils.context
     aliases=[],
     privilege=1
 )
-class ResetCommand(AbstractCommandNode):
+class ResetCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         params = ctx.params
         session_name = ctx.session_name
         
         reply = ""
 
         if len(params) == 0:
-            pkg.openai.session.get_session(session_name).reset(explicit=True)
+            session.get_session(session_name).reset(explicit=True)
             reply = [tips_custom.command_reset_message]
         else:
             try:
                 import pkg.openai.dprompt as dprompt
-                pkg.openai.session.get_session(session_name).reset(explicit=True, use_prompt=params[0])
+                session.get_session(session_name).reset(explicit=True, use_prompt=params[0])
                 reply = [tips_custom.command_reset_name_message+"{}".format(dprompt.mode_inst().get_full_name(params[0]))]
             except Exception as e:
                 reply = ["[bot]会话重置失败：{}".format(e)]

pkg/qqbot/cmds/system/cconfig.py

@@ -1,6 +1,7 @@
-from ..aamgr import AbstractCommandNode, Context
 import json
 
+from .. import aamgr
+
 
 def config_operation(cmd, params):
     reply = []
@@ -85,7 +86,7 @@ def config_operation(cmd, params):
     return reply
 
 
-@AbstractCommandNode.register(
+@aamgr.AbstractCommandNode.register(
     parent=None,
     name="cfg",
     description="配置项管理",
@@ -93,8 +94,8 @@ def config_operation(cmd, params):
     aliases=[],
     privilege=2
 )
-class CfgCommand(AbstractCommandNode):
+class CfgCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         return True, config_operation(ctx.command, ctx.params)
     

pkg/qqbot/cmds/system/cmd.py

@@ -1,7 +1,7 @@
-from ..aamgr import AbstractCommandNode, Context, __command_list__
+from .. import aamgr
 
 
-@AbstractCommandNode.register(
+@aamgr.AbstractCommandNode.register(
     parent=None,
     name="cmd",
     description="显示指令列表",
@@ -9,10 +9,10 @@ from ..aamgr import AbstractCommandNode, Context, __command_list__
     aliases=[],
     privilege=1
 )
-class CmdCommand(AbstractCommandNode):
+class CmdCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
-        command_list = __command_list__
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
+        command_list = aamgr.__command_list__
 
         reply = []
 

pkg/qqbot/cmds/system/help.py

@@ -1,7 +1,7 @@
-from ..aamgr import AbstractCommandNode, Context
+from .. import aamgr
 
 
-@AbstractCommandNode.register(
+@aamgr.AbstractCommandNode.register(
     parent=None,
     name="help",
     description="显示自定义的帮助信息",
@@ -9,9 +9,9 @@ from ..aamgr import AbstractCommandNode, Context
     aliases=[],
     privilege=1
 )
-class HelpCommand(AbstractCommandNode):
+class HelpCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         import tips
         reply = ["[bot] "+tips.help_message + "\n请输入 !cmd 查看指令列表"]
 

pkg/qqbot/cmds/system/reload.py

@@ -1,7 +1,9 @@
-from ..aamgr import AbstractCommandNode, Context
 import threading
 
-@AbstractCommandNode.register(
+from .. import aamgr
+
+
+@aamgr.AbstractCommandNode.register(
     parent=None,
     name="reload",
     description="执行热重载",
@@ -9,9 +11,9 @@ import threading
     aliases=[],
     privilege=2
 )
-class ReloadCommand(AbstractCommandNode):
+class ReloadCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         reply = []
 
         import pkg.utils.reloader

pkg/qqbot/cmds/system/update.py

@@ -1,9 +1,10 @@
-from ..aamgr import AbstractCommandNode, Context
 import threading
 import traceback
 
+from .. import aamgr
 
-@AbstractCommandNode.register(
+
+@aamgr.AbstractCommandNode.register(
     parent=None,
     name="update",
     description="更新程序",
@@ -11,9 +12,9 @@ import traceback
     aliases=[],
     privilege=2
 )
-class UpdateCommand(AbstractCommandNode):
+class UpdateCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         reply = []
         import pkg.utils.updater
         import pkg.utils.reloader
@@ -22,8 +23,7 @@ class UpdateCommand(AbstractCommandNode):
         def update_task():
             try:
                 if pkg.utils.updater.update_all():
-                    pkg.utils.reloader.reload_all(notify=False)
-                    pkg.utils.context.get_qqbot_manager().notify_admin("更新完成")
+                    pkg.utils.context.get_qqbot_manager().notify_admin("更新完成, 请手动重启程序。")
                 else:
                     pkg.utils.context.get_qqbot_manager().notify_admin("无新版本")
             except Exception as e0:

pkg/qqbot/cmds/system/usage.py

@@ -1,8 +1,7 @@
-from ..aamgr import AbstractCommandNode, Context
-import logging
+from .. import aamgr
 
 
-@AbstractCommandNode.register(
+@aamgr.AbstractCommandNode.register(
     parent=None,
     name="usage",
     description="获取使用情况",
@@ -10,9 +9,9 @@ import logging
     aliases=[],
     privilege=1
 )
-class UsageCommand(AbstractCommandNode):
+class UsageCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         import config
         import pkg.utils.credit as credit
         import pkg.utils.context

pkg/qqbot/cmds/system/version.py

@@ -1,7 +1,7 @@
-from ..aamgr import AbstractCommandNode, Context
+from .. import aamgr
 
 
-@AbstractCommandNode.register(
+@aamgr.AbstractCommandNode.register(
     parent=None,
     name="version",
     description="查看版本信息",
@@ -9,9 +9,9 @@ from ..aamgr import AbstractCommandNode, Context
     aliases=[],
     privilege=1
 )
-class VersionCommand(AbstractCommandNode):
+class VersionCommand(aamgr.AbstractCommandNode):
     @classmethod
-    def process(cls, ctx: Context) -> tuple[bool, list]:
+    def process(cls, ctx: aamgr.Context) -> tuple[bool, list]:
         reply = []
         import pkg.utils.updater
     

pkg/qqbot/command.py

@@ -1,26 +1,10 @@
 # 指令处理模块
 import logging
-import json
-import datetime
-import os
-import threading
-import traceback
 
-import pkg.openai.session
-import pkg.openai.manager
-import pkg.utils.reloader
-import pkg.utils.updater
-import pkg.utils.context
-import pkg.qqbot.message
-import pkg.utils.credit as credit
-# import pkg.qqbot.cmds.model as cmdmodel
-import pkg.qqbot.cmds.aamgr as cmdmgr
-
-from mirai import Image
+from ..qqbot.cmds import aamgr as cmdmgr
 
 
-
-def process_command(session_name: str, text_message: str, mgr, config,
+def process_command(session_name: str, text_message: str, mgr, config: dict,
                     launcher_type: str, launcher_id: int, sender_id: int, is_admin: bool) -> list:
     reply = []
     try:

pkg/qqbot/filter.py

@@ -4,6 +4,8 @@ import requests
 import json
 import logging
 
+from ..utils import context
+
 
 class ReplyFilter:
     sensitive_words = []
@@ -20,12 +22,13 @@ class ReplyFilter:
         self.sensitive_words = sensitive_words
         self.mask = mask
         self.mask_word = mask_word
-        import config
 
-        self.baidu_check = config.baidu_check
-        self.baidu_api_key = config.baidu_api_key
-        self.baidu_secret_key = config.baidu_secret_key
-        self.inappropriate_message_tips = config.inappropriate_message_tips
+        config = context.get_config_manager().data
+
+        self.baidu_check = config['baidu_check']
+        self.baidu_api_key = config['baidu_api_key']
+        self.baidu_secret_key = config['baidu_secret_key']
+        self.inappropriate_message_tips = config['inappropriate_message_tips']
 
     def is_illegal(self, message: str) -> bool:
         processed = self.process(message)

pkg/qqbot/ignore.py

@@ -1,16 +1,18 @@
 import re
 
+from ..utils import context
+
 
 def ignore(msg: str) -> bool:
     """检查消息是否应该被忽略"""
-    import config
+    config = context.get_config_manager().data
     
-    if 'prefix' in config.ignore_rules:
-        for rule in config.ignore_rules['prefix']:
+    if 'prefix' in config['ignore_rules']:
+        for rule in config['ignore_rules']['prefix']:
             if msg.startswith(rule):
                 return True
 
-    if 'regexp' in config.ignore_rules:
-        for rule in config.ignore_rules['regexp']:
+    if 'regexp' in config['ignore_rules']:
+        for rule in config['ignore_rules']['regexp']:
             if re.search(rule, msg):
                 return True

pkg/qqbot/manager.py

@@ -1,41 +1,34 @@
-import asyncio
 import json
 import os
-import threading
-
-
-from mirai import At, GroupMessage, MessageEvent, Mirai, StrangerMessage, WebSocketAdapter, HTTPAdapter, \
-    FriendMessage, Image, MessageChain, Plain
-from func_timeout import func_set_timeout
-
-import pkg.openai.session
-import pkg.openai.manager
-from func_timeout import FunctionTimedOut
 import logging
 
-import pkg.qqbot.filter
-import pkg.qqbot.process as processor
-import pkg.utils.context
+from mirai import At, GroupMessage, MessageEvent, StrangerMessage, \
+    FriendMessage, Image, MessageChain, Plain
+import func_timeout
 
-import pkg.plugin.host as plugin_host
-import pkg.plugin.models as plugin_models
+from ..openai import session as openai_session
+
+from ..qqbot import filter as qqbot_filter
+from ..qqbot import process as processor
+from ..utils import context
+from ..plugin import host as plugin_host
+from ..plugin import models as plugin_models
 import tips as tips_custom
-
-import pkg.qqbot.adapter as msadapter
+from ..qqbot import adapter as msadapter
 
 
 # 检查消息是否符合泛响应匹配机制
 def check_response_rule(group_id:int, text: str):
-    config = pkg.utils.context.get_config()
+    config = context.get_config_manager().data
 
-    rules = config.response_rules
+    rules = config['response_rules']
 
     # 检查是否有特定规则
-    if 'prefix' not in config.response_rules:
-        if str(group_id) in config.response_rules:
-            rules = config.response_rules[str(group_id)]
+    if 'prefix' not in config['response_rules']:
+        if str(group_id) in config['response_rules']:
+            rules = config['response_rules'][str(group_id)]
         else:
-            rules = config.response_rules['default']
+            rules = config['response_rules']['default']
 
     # 检查前缀匹配
     if 'prefix' in rules:
@@ -55,16 +48,16 @@ def check_response_rule(group_id:int, text: str):
 
 
 def response_at(group_id: int):
-    config = pkg.utils.context.get_config()
+    config = context.get_config_manager().data
 
-    use_response_rule = config.response_rules
+    use_response_rule = config['response_rules']
 
     # 检查是否有特定规则
-    if 'prefix' not in config.response_rules:
-        if str(group_id) in config.response_rules:
-            use_response_rule = config.response_rules[str(group_id)]
+    if 'prefix' not in config['response_rules']:
+        if str(group_id) in config['response_rules']:
+            use_response_rule = config['response_rules'][str(group_id)]
         else:
-            use_response_rule = config.response_rules['default']
+            use_response_rule = config['response_rules']['default']
 
     if 'at' not in use_response_rule:
         return True
@@ -73,16 +66,16 @@ def response_at(group_id: int):
 
 
 def random_responding(group_id):
-    config = pkg.utils.context.get_config()
+    config = context.get_config_manager().data
 
-    use_response_rule = config.response_rules
+    use_response_rule = config['response_rules']
 
     # 检查是否有特定规则
-    if 'prefix' not in config.response_rules:
-        if str(group_id) in config.response_rules:
-            use_response_rule = config.response_rules[str(group_id)]
+    if 'prefix' not in config['response_rules']:
+        if str(group_id) in config['response_rules']:
+            use_response_rule = config['response_rules'][str(group_id)]
         else:
-            use_response_rule = config.response_rules['default']
+            use_response_rule = config['response_rules']['default']
 
     if 'random_rate' in use_response_rule:
         import random
@@ -109,31 +102,31 @@ class QQBotManager:
     ban_group = []
 
     def __init__(self, first_time_init=True):
-        import config
+        config = context.get_config_manager().data
 
-        self.timeout = config.process_message_timeout
-        self.retry = config.retry_times
+        self.timeout = config['process_message_timeout']
+        self.retry = config['retry_times']
 
         # 由于YiriMirai的bot对象是单例的，且shutdown方法暂时无法使用
         # 故只在第一次初始化时创建bot对象，重载之后使用原bot对象
         # 因此，bot的配置不支持热重载
         if first_time_init:
-            logging.info("Use adapter:" + config.msg_source_adapter)
-            if config.msg_source_adapter == 'yirimirai':
+            logging.debug("Use adapter:" + config['msg_source_adapter'])
+            if config['msg_source_adapter'] == 'yirimirai':
                 from pkg.qqbot.sources.yirimirai import YiriMiraiAdapter
 
-                mirai_http_api_config = config.mirai_http_api_config
-                self.bot_account_id = config.mirai_http_api_config['qq']
+                mirai_http_api_config = config['mirai_http_api_config']
+                self.bot_account_id = config['mirai_http_api_config']['qq']
                 self.adapter = YiriMiraiAdapter(mirai_http_api_config)
-            elif config.msg_source_adapter == 'nakuru':
+            elif config['msg_source_adapter'] == 'nakuru':
                 from pkg.qqbot.sources.nakuru import NakuruProjectAdapter
-                self.adapter = NakuruProjectAdapter(config.nakuru_config)
+                self.adapter = NakuruProjectAdapter(config['nakuru_config'])
                 self.bot_account_id = self.adapter.bot_account_id
         else:
-            self.adapter = pkg.utils.context.get_qqbot_manager().adapter
-            self.bot_account_id = pkg.utils.context.get_qqbot_manager().bot_account_id
+            self.adapter = context.get_qqbot_manager().adapter
+            self.bot_account_id = context.get_qqbot_manager().bot_account_id
 
-        pkg.utils.context.set_qqbot_manager(self)
+        context.set_qqbot_manager(self)
 
         # 注册诸事件
         # Caution: 注册新的事件处理器之后，请务必在unsubscribe_all中编写相应的取消订阅代码
@@ -154,7 +147,7 @@ class QQBotManager:
 
                 self.on_person_message(event)
 
-            pkg.utils.context.get_thread_ctl().submit_user_task(
+            context.get_thread_ctl().submit_user_task(
                 friend_message_handler,
             )
         self.adapter.register_listener(
@@ -179,11 +172,11 @@ class QQBotManager:
 
                 self.on_person_message(event)
 
-            pkg.utils.context.get_thread_ctl().submit_user_task(
+            context.get_thread_ctl().submit_user_task(
                 stranger_message_handler,
             )
         # nakuru不区分好友和陌生人，故仅为yirimirai注册陌生人事件
-        if config.msg_source_adapter == 'yirimirai':
+        if config['msg_source_adapter'] == 'yirimirai':
             self.adapter.register_listener(
                 StrangerMessage,
                 on_stranger_message
@@ -206,7 +199,7 @@ class QQBotManager:
 
                 self.on_group_message(event)
 
-            pkg.utils.context.get_thread_ctl().submit_user_task(
+            context.get_thread_ctl().submit_user_task(
                 group_message_handler,
                 event
             )
@@ -220,12 +213,11 @@ class QQBotManager:
 
             用于在热重载流程中卸载所有事件处理器
             """
-            import config
             self.adapter.unregister_listener(
                 FriendMessage,
                 on_friend_message
             )
-            if config.msg_source_adapter == 'yirimirai':
+            if config['msg_source_adapter'] == 'yirimirai':
                 self.adapter.unregister_listener(
                     StrangerMessage,
                     on_stranger_message
@@ -250,33 +242,50 @@ class QQBotManager:
             if hasattr(banlist, "enable_group"):
                 self.enable_group = banlist.enable_group
 
-        config = pkg.utils.context.get_config()
+        config = context.get_config_manager().data
         if os.path.exists("sensitive.json") \
-                and config.sensitive_word_filter is not None \
-                and config.sensitive_word_filter:
+                and config['sensitive_word_filter'] is not None \
+                and config['sensitive_word_filter']:
             with open("sensitive.json", "r", encoding="utf-8") as f:
                 sensitive_json = json.load(f)
-                self.reply_filter = pkg.qqbot.filter.ReplyFilter(
+                self.reply_filter = qqbot_filter.ReplyFilter(
                     sensitive_words=sensitive_json['words'],
                     mask=sensitive_json['mask'] if 'mask' in sensitive_json else '*',
                     mask_word=sensitive_json['mask_word'] if 'mask_word' in sensitive_json else ''
                 )
         else:
-            self.reply_filter = pkg.qqbot.filter.ReplyFilter([])
+            self.reply_filter = qqbot_filter.ReplyFilter([])
+
+    def send(self, event, msg, check_quote=True, check_at_sender=True):
+        config = context.get_config_manager().data
+        
+        if check_at_sender and config['at_sender']:
+            msg.insert(
+                0,
+                Plain(" \n")
+            )
+
+            # 当回复的正文中包含换行时，quote可能会自带at，此时就不再单独添加at，只添加换行
+            if "\n" not in str(msg[1]) or config['msg_source_adapter'] == 'nakuru':
+                msg.insert(
+                    0,
+                    At(
+                        event.sender.id
+                    )
+                )
 
-    def send(self, event, msg, check_quote=True):
-        config = pkg.utils.context.get_config()
         self.adapter.reply_message(
             event,
             msg,
-            quote_origin=True if config.quote_origin and check_quote else False
+            quote_origin=True if config['quote_origin'] and check_quote else False
         )
 
     # 私聊消息处理
     def on_person_message(self, event: MessageEvent):
-        import config
         reply = ''
 
+        config = context.get_config_manager().data
+
         if not self.enable_private:
             logging.debug("已在banlist.py中禁用所有私聊")
         elif event.sender.id == self.bot_account_id:
@@ -290,7 +299,7 @@ class QQBotManager:
                 for i in range(self.retry):
                     try:
                         
-                        @func_set_timeout(config.process_message_timeout)
+                        @func_timeout.func_set_timeout(config['process_message_timeout'])
                         def time_ctrl_wrapper():
                             reply = processor.process_message('person', event.sender.id, str(event.message_chain),
                                                             event.message_chain,
@@ -299,26 +308,28 @@ class QQBotManager:
                         
                         reply = time_ctrl_wrapper()
                         break
-                    except FunctionTimedOut:
+                    except func_timeout.FunctionTimedOut:
                         logging.warning("person_{}: 超时，重试中({})".format(event.sender.id, i))
-                        pkg.openai.session.get_session('person_{}'.format(event.sender.id)).release_response_lock()
-                        if "person_{}".format(event.sender.id) in pkg.qqbot.process.processing:
-                            pkg.qqbot.process.processing.remove('person_{}'.format(event.sender.id))
+                        openai_session.get_session('person_{}'.format(event.sender.id)).release_response_lock()
+                        if "person_{}".format(event.sender.id) in processor.processing:
+                            processor.processing.remove('person_{}'.format(event.sender.id))
                         failed += 1
                         continue
 
                 if failed == self.retry:
-                    pkg.openai.session.get_session('person_{}'.format(event.sender.id)).release_response_lock()
+                    openai_session.get_session('person_{}'.format(event.sender.id)).release_response_lock()
                     self.notify_admin("{} 请求超时".format("person_{}".format(event.sender.id)))
                     reply = [tips_custom.reply_message]
 
         if reply:
-            return self.send(event, reply, check_quote=False)
+            return self.send(event, reply, check_quote=False, check_at_sender=False)
 
     # 群消息处理
     def on_group_message(self, event: GroupMessage):
-        import config
         reply = ''
+
+        config = context.get_config_manager().data
+
         def process(text=None) -> str:
             replys = ""
             if At(self.bot_account_id) in event.message_chain:
@@ -328,7 +339,7 @@ class QQBotManager:
             failed = 0
             for i in range(self.retry):
                 try:
-                    @func_set_timeout(config.process_message_timeout)
+                    @func_timeout.func_set_timeout(config['process_message_timeout'])
                     def time_ctrl_wrapper():
                         replys = processor.process_message('group', event.group.id,
                                                         str(event.message_chain).strip() if text is None else text,
@@ -338,16 +349,16 @@ class QQBotManager:
                     
                     replys = time_ctrl_wrapper()
                     break
-                except FunctionTimedOut:
+                except func_timeout.FunctionTimedOut:
                     logging.warning("group_{}: 超时，重试中({})".format(event.group.id, i))
-                    pkg.openai.session.get_session('group_{}'.format(event.group.id)).release_response_lock()
-                    if "group_{}".format(event.group.id) in pkg.qqbot.process.processing:
-                        pkg.qqbot.process.processing.remove('group_{}'.format(event.group.id))
+                    openai_session.get_session('group_{}'.format(event.group.id)).release_response_lock()
+                    if "group_{}".format(event.group.id) in processor.processing:
+                        processor.processing.remove('group_{}'.format(event.group.id))
                     failed += 1
                     continue
 
             if failed == self.retry:
-                pkg.openai.session.get_session('group_{}'.format(event.group.id)).release_response_lock()
+                openai_session.get_session('group_{}'.format(event.group.id)).release_response_lock()
                 self.notify_admin("{} 请求超时".format("group_{}".format(event.group.id)))
                 replys = [tips_custom.replys_message]
 
@@ -376,17 +387,17 @@ class QQBotManager:
 
     # 通知系统管理员
     def notify_admin(self, message: str):
-        config = pkg.utils.context.get_config()
-        if config.admin_qq != 0 and config.admin_qq != []:
+        config = context.get_config_manager().data
+        if config['admin_qq'] != 0 and config['admin_qq'] != []:
             logging.info("通知管理员:{}".format(message))
-            if type(config.admin_qq) == int:
+            if type(config['admin_qq']) == int:
                 self.adapter.send_message(
                     "person",
-                    config.admin_qq,
+                    config['admin_qq'],
                     MessageChain([Plain("[bot]{}".format(message))])
                 )
             else:
-                for adm in config.admin_qq:
+                for adm in config['admin_qq']:
                     self.adapter.send_message(
                         "person",
                         adm,
@@ -394,17 +405,17 @@ class QQBotManager:
                     )
 
     def notify_admin_message_chain(self, message):
-        config = pkg.utils.context.get_config()
-        if config.admin_qq != 0 and config.admin_qq != []:
+        config = context.get_config_manager().data
+        if config['admin_qq'] != 0 and config['admin_qq'] != []:
             logging.info("通知管理员:{}".format(message))
-            if type(config.admin_qq) == int:
+            if type(config['admin_qq']) == int:
                 self.adapter.send_message(
                     "person",
-                    config.admin_qq,
+                    config['admin_qq'],
                     message
                 )
             else:
-                for adm in config.admin_qq:
+                for adm in config['admin_qq']:
                     self.adapter.send_message(
                         "person",
                         adm,

pkg/qqbot/message.py

@@ -1,32 +1,33 @@
 # 普通消息处理模块
 import logging
-import openai
-import pkg.utils.context
-import pkg.openai.session
 
-import pkg.plugin.host as plugin_host
-import pkg.plugin.models as plugin_models
-import pkg.qqbot.blob as blob
+import openai
+
+from ..utils import context
+from ..openai import session as openai_session
+
+from ..plugin import host as plugin_host
+from ..plugin import models as plugin_models
 import tips as tips_custom
 
 
 def handle_exception(notify_admin: str = "", set_reply: str = "") -> list:
     """处理异常，当notify_admin不为空时，会通知管理员，返回通知用户的消息"""
-    import config
-    pkg.utils.context.get_qqbot_manager().notify_admin(notify_admin)
-    if config.hide_exce_info_to_user:
+    config = context.get_config_manager().data
+    context.get_qqbot_manager().notify_admin(notify_admin)
+    if config['hide_exce_info_to_user']:
         return [tips_custom.alter_tip_message] if tips_custom.alter_tip_message else []
     else:
         return [set_reply]
 
 
-def process_normal_message(text_message: str, mgr, config, launcher_type: str,
+def process_normal_message(text_message: str, mgr, config: dict, launcher_type: str,
                            launcher_id: int, sender_id: int) -> list:
     session_name = f"{launcher_type}_{launcher_id}"
     logging.info("[{}]发送消息:{}".format(session_name, text_message[:min(20, len(text_message))] + (
         "..." if len(text_message) > 20 else "")))
 
-    session = pkg.openai.session.get_session(session_name)
+    session = openai_session.get_session(session_name)
 
     unexpected_exception_times = 0
 
@@ -38,9 +39,9 @@ def process_normal_message(text_message: str, mgr, config, launcher_type: str,
             reply = handle_exception(notify_admin=f"{session_name}，多次尝试失败。", set_reply=f"[bot]多次尝试失败，请重试或联系管理员")
             break
         try:
-            prefix = "[GPT]" if config.show_prefix else ""
+            prefix = "[GPT]" if config['show_prefix'] else ""
 
-            text = session.append(text_message)
+            text, finish_reason, funcs = session.query(text_message)
 
             # 触发插件事件
             args = {
@@ -49,10 +50,12 @@ def process_normal_message(text_message: str, mgr, config, launcher_type: str,
                 "sender_id": sender_id,
                 "session": session,
                 "prefix": prefix,
-                "response_text": text
+                "response_text": text,
+                "finish_reason": finish_reason,
+                "funcs_called": funcs,
             }
 
-            event = pkg.plugin.host.emit(plugin_models.NormalMessageResponded, **args)
+            event = plugin_host.emit(plugin_models.NormalMessageResponded, **args)
 
             if event.get_return_value("prefix") is not None:
                 prefix = event.get_return_value("prefix")
@@ -62,42 +65,43 @@ def process_normal_message(text_message: str, mgr, config, launcher_type: str,
 
             if not event.is_prevented_default():
                 reply = [prefix + text]
-        except openai.error.APIConnectionError as e:
+
+        except openai.APIConnectionError as e:
             err_msg = str(e)
             if err_msg.__contains__('Error communicating with OpenAI'):
-                reply = handle_exception("{}会话调用API失败:{}\n请尝试关闭网络代理来解决此问题。".format(session_name, e),
+                reply = handle_exception("{}会话调用API失败:{}\n您的网络无法访问OpenAI接口或网络代理不正常".format(session_name, e),
                                          "[bot]err:调用API失败，请重试或联系管理员，或等待修复")
             else:
                 reply = handle_exception("{}会话调用API失败:{}".format(session_name, e), "[bot]err:调用API失败，请重试或联系管理员，或等待修复")
-        except openai.error.RateLimitError as e:
+        except openai.RateLimitError as e:
             logging.debug(type(e))
             logging.debug(e.error['message'])
 
             if 'message' in e.error and e.error['message'].__contains__('You exceeded your current quota'):
                 # 尝试切换api-key
-                current_key_name = pkg.utils.context.get_openai_manager().key_mgr.get_key_name(
-                    pkg.utils.context.get_openai_manager().key_mgr.using_key
+                current_key_name = context.get_openai_manager().key_mgr.get_key_name(
+                    context.get_openai_manager().key_mgr.using_key
                 )
-                pkg.utils.context.get_openai_manager().key_mgr.set_current_exceeded()
+                context.get_openai_manager().key_mgr.set_current_exceeded()
 
                 # 触发插件事件
                 args = {
                     'key_name': current_key_name,
-                    'usage': pkg.utils.context.get_openai_manager().audit_mgr
-                            .get_usage(pkg.utils.context.get_openai_manager().key_mgr.get_using_key_md5()),
-                    'exceeded_keys': pkg.utils.context.get_openai_manager().key_mgr.exceeded,
+                    'usage': context.get_openai_manager().audit_mgr
+                            .get_usage(context.get_openai_manager().key_mgr.get_using_key_md5()),
+                    'exceeded_keys': context.get_openai_manager().key_mgr.exceeded,
                 }
                 event = plugin_host.emit(plugin_models.KeyExceeded, **args)
 
                 if not event.is_prevented_default():
-                    switched, name = pkg.utils.context.get_openai_manager().key_mgr.auto_switch()
+                    switched, name = context.get_openai_manager().key_mgr.auto_switch()
 
                     if not switched:
                         reply = handle_exception(
                             "api-key调用额度超限({}),无可用api_key,请向OpenAI账户充值或在config.py中更换api_key；如果你认为这是误判，请尝试重启程序。".format(
                                 current_key_name), "[bot]err:API调用额度超额，请联系管理员，或等待修复")
                     else:
-                        openai.api_key = pkg.utils.context.get_openai_manager().key_mgr.get_using_key()
+                        openai.api_key = context.get_openai_manager().key_mgr.get_using_key()
                         mgr.notify_admin("api-key调用额度超限({}),接口报错,已切换到{}".format(current_key_name, name))
                         reply = ["[bot]err:API调用额度超额，已自动切换，请重新发送消息"]
                         continue
@@ -113,14 +117,14 @@ def process_normal_message(text_message: str, mgr, config, launcher_type: str,
             else:
                 reply = handle_exception("{}会话调用API失败:{}".format(session_name, e),
                                          "[bot]err:RateLimitError,请重试或联系作者，或等待修复")
-        except openai.error.InvalidRequestError as e:
-            if config.auto_reset and "This model's maximum context length is" in str(e):
-                session.reset()
+        except openai.BadRequestError as e:
+            if config['auto_reset'] and "This model's maximum context length is" in str(e):
+                session.reset(persist=True)
                 reply = [tips_custom.session_auto_reset_message]
             else:
                 reply = handle_exception("{}API调用参数错误:{}\n".format(
                                 session_name, e), "[bot]err:API调用参数错误，请联系管理员，或等待修复")
-        except openai.error.ServiceUnavailableError as e:
+        except openai.APIStatusError as e:
             reply = handle_exception("{}API调用服务不可用:{}".format(session_name, e), "[bot]err:API调用服务不可用，请重试或联系管理员，或等待修复")
         except Exception as e:
             logging.exception(e)

pkg/qqbot/process.py

@@ -1,32 +1,27 @@
 # 此模块提供了消息处理的具体逻辑的接口
 import asyncio
 import time
+import traceback
 
 import mirai
 import logging
 
-from mirai import MessageChain, Plain
-
 # 这里不使用动态引入config
 # 因为在这里动态引入会卡死程序
 # 而此模块静态引用config与动态引入的表现一致
 # 已弃用，由于超时时间现已动态使用
 # import config as config_init_import
 
-import pkg.openai.session
-import pkg.openai.manager
-import pkg.utils.reloader
-import pkg.utils.updater
-import pkg.utils.context
-import pkg.qqbot.message
-import pkg.qqbot.command
-import pkg.qqbot.ratelimit as ratelimit
+from ..qqbot import ratelimit
+from ..qqbot import command, message
+from ..openai import session as openai_session
+from ..utils import context
 
-import pkg.plugin.host as plugin_host
-import pkg.plugin.models as plugin_models
-import pkg.qqbot.ignore as ignore
-import pkg.qqbot.banlist as banlist
-import pkg.qqbot.blob as blob
+from ..plugin import host as plugin_host
+from ..plugin import models as plugin_models
+from ..qqbot import ignore
+from ..qqbot import banlist
+from ..qqbot import blob
 import tips as tips_custom
 
 processing = []
@@ -34,18 +29,18 @@ processing = []
 
 def is_admin(qq: int) -> bool:
     """兼容list和int类型的管理员判断"""
-    import config
-    if type(config.admin_qq) == list:
-        return qq in config.admin_qq
+    config = context.get_config_manager().data
+    if type(config['admin_qq']) == list:
+        return qq in config['admin_qq']
     else:
-        return qq == config.admin_qq
+        return qq == config['admin_qq']
 
 
-def process_message(launcher_type: str, launcher_id: int, text_message: str, message_chain: MessageChain,
-                    sender_id: int) -> MessageChain:
+def process_message(launcher_type: str, launcher_id: int, text_message: str, message_chain: mirai.MessageChain,
+                    sender_id: int) -> mirai.MessageChain:
     global processing
 
-    mgr = pkg.utils.context.get_qqbot_manager()
+    mgr = context.get_qqbot_manager()
 
     reply = []
     session_name = "{}_{}".format(launcher_type, launcher_id)
@@ -59,10 +54,10 @@ def process_message(launcher_type: str, launcher_id: int, text_message: str, mes
         logging.info("根据忽略规则忽略消息: {}".format(text_message))
         return []
 
-    import config
+    config = context.get_config_manager().data
 
-    if not config.wait_last_done and session_name in processing:
-        return MessageChain([Plain(tips_custom.message_drop_tip)])
+    if not config['wait_last_done'] and session_name in processing:
+        return mirai.MessageChain([mirai.Plain(tips_custom.message_drop_tip)])
 
     # 检查是否被禁言
     if launcher_type == 'group':
@@ -71,12 +66,11 @@ def process_message(launcher_type: str, launcher_id: int, text_message: str, mes
             logging.info("机器人被禁言,跳过消息处理(group_{})".format(launcher_id))
             return reply
 
-    import config
-    if config.income_msg_check:
+    if config['income_msg_check']:
         if mgr.reply_filter.is_illegal(text_message):
-            return MessageChain(Plain("[bot] 消息中存在不合适的内容, 请更换措辞"))
+            return mirai.MessageChain(mirai.Plain("[bot] 消息中存在不合适的内容, 请更换措辞"))
 
-    pkg.openai.session.get_session(session_name).acquire_response_lock()
+    openai_session.get_session(session_name).acquire_response_lock()
 
     text_message = text_message.strip()
 
@@ -87,8 +81,6 @@ def process_message(launcher_type: str, launcher_id: int, text_message: str, mes
     # 处理消息
     try:
 
-        config = pkg.utils.context.get_config()
-
         processing.append(session_name)
         try:
             if text_message.startswith('!') or text_message.startswith("！"):  # 指令
@@ -114,17 +106,17 @@ def process_message(launcher_type: str, launcher_id: int, text_message: str, mes
                     reply = event.get_return_value("reply")
 
                 if not event.is_prevented_default():
-                    reply = pkg.qqbot.command.process_command(session_name, text_message,
+                    reply = command.process_command(session_name, text_message,
                                                               mgr, config, launcher_type, launcher_id, sender_id, is_admin(sender_id))
 
             else:  # 消息
                 # 限速丢弃检查
                 # print(ratelimit.__crt_minute_usage__[session_name])
-                if config.rate_limit_strategy == "drop":
+                if config['rate_limit_strategy'] == "drop":
                     if ratelimit.is_reach_limit(session_name):
                         logging.info("根据限速策略丢弃[{}]消息: {}".format(session_name, text_message))
 
-                        return MessageChain(["[bot]"+tips_custom.rate_limit_drop_tip]) if tips_custom.rate_limit_drop_tip != "" else []
+                        return mirai.MessageChain(["[bot]"+tips_custom.rate_limit_drop_tip]) if tips_custom.rate_limit_drop_tip != "" else []
 
                 before = time.time()
                 # 触发插件事件
@@ -146,11 +138,11 @@ def process_message(launcher_type: str, launcher_id: int, text_message: str, mes
                     reply = event.get_return_value("reply")
 
                 if not event.is_prevented_default():
-                    reply = pkg.qqbot.message.process_normal_message(text_message,
+                    reply = message.process_normal_message(text_message,
                                                                      mgr, config, launcher_type, launcher_id, sender_id)
 
                 # 限速等待时间
-                if config.rate_limit_strategy == "wait":
+                if config['rate_limit_strategy'] == "wait":
                     time.sleep(ratelimit.get_rest_wait_time(session_name, time.time() - before))
                 
                 ratelimit.add_usage(session_name)
@@ -170,16 +162,16 @@ def process_message(launcher_type: str, launcher_id: int, text_message: str, mes
         finally:
             processing.remove(session_name)
     finally:
-        pkg.openai.session.get_session(session_name).release_response_lock()
+        openai_session.get_session(session_name).release_response_lock()
 
     # 检查延迟时间
-    if config.force_delay_range[1] == 0:
+    if config['force_delay_range'][1] == 0:
         delay_time = 0
     else:
         import random
 
         # 从延迟范围中随机取一个值(浮点)
-        rdm = random.uniform(config.force_delay_range[0], config.force_delay_range[1])
+        rdm = random.uniform(config['force_delay_range'][0], config['force_delay_range'][1])
 
         spent = time.time() - start_time
 
@@ -191,4 +183,4 @@ def process_message(launcher_type: str, launcher_id: int, text_message: str, mes
         logging.info("[风控] 强制延迟{:.2f}秒(如需关闭，请到config.py修改force_delay_range字段)".format(delay_time))
         time.sleep(delay_time)
 
-    return MessageChain(reply)
+    return mirai.MessageChain(reply)

pkg/qqbot/ratelimit.py

@@ -3,6 +3,9 @@ import time
 import logging
 import threading
 
+from ..utils import context
+
+
 __crt_minute_usage__ = {}
 """当前分钟每个会话的对话次数"""
 
@@ -12,16 +15,16 @@ __timer_thr__: threading.Thread = None
 
 def get_limitation(session_name: str) -> int:
     """获取会话的限制次数"""
-    import config
+    config = context.get_config_manager().data
 
-    if type(config.rate_limitation) == dict:
+    if type(config['rate_limitation']) == dict:
         # 如果被指定了
-        if session_name in config.rate_limitation:
-            return config.rate_limitation[session_name]
+        if session_name in config['rate_limitation']:
+            return config['rate_limitation'][session_name]
         else:
-            return config.rate_limitation["default"]
-    elif type(config.rate_limitation) == int:
-        return config.rate_limitation
+            return config['rate_limitation']["default"]
+    elif type(config['rate_limitation']) == int:
+        return config['rate_limitation']
 
 
 def add_usage(session_name: str):

pkg/qqbot/sources/nakuru.py

@@ -1,19 +1,19 @@
-import mirai
-
-from ..adapter import MessageSourceAdapter, MessageConverter, EventConverter
-import nakuru
-import nakuru.entities.components as nkc
-
 import asyncio
 import typing
 import traceback
 import logging
-import json
 
-from pkg.qqbot.blob import Forward, ForwardMessageNode, ForwardMessageDiaplay
+import mirai
+
+import nakuru
+import nakuru.entities.components as nkc
+
+from .. import adapter as adapter_model
+from ...qqbot import blob
+from ...utils import context
 
 
-class NakuruProjectMessageConverter(MessageConverter):
+class NakuruProjectMessageConverter(adapter_model.MessageConverter):
     """消息转换器"""
     @staticmethod
     def yiri2target(message_chain: mirai.MessageChain) -> list:
@@ -49,7 +49,7 @@ class NakuruProjectMessageConverter(MessageConverter):
                     nakuru_msg_list.append(nkc.Record.fromURL(component.url))
                 elif component.path is not None:
                     nakuru_msg_list.append(nkc.Record.fromFileSystem(component.path))
-            elif type(component) is Forward:
+            elif type(component) is blob.Forward:
                 # 转发消息
                 yiri_forward_node_list = component.node_list
                 nakuru_forward_node_list = []
@@ -102,7 +102,7 @@ class NakuruProjectMessageConverter(MessageConverter):
         return chain
 
 
-class NakuruProjectEventConverter(EventConverter):
+class NakuruProjectEventConverter(adapter_model.EventConverter):
     """事件转换器"""
     @staticmethod
     def yiri2target(event: typing.Type[mirai.Event]):
@@ -157,7 +157,7 @@ class NakuruProjectEventConverter(EventConverter):
             raise Exception("未支持转换的事件类型: " + str(event))
 
 
-class NakuruProjectAdapter(MessageSourceAdapter):
+class NakuruProjectAdapter(adapter_model.MessageSourceAdapter):
     """nakuru-project适配器"""
     bot: nakuru.CQHTTP
     bot_account_id: int
@@ -173,19 +173,25 @@ class NakuruProjectAdapter(MessageSourceAdapter):
         self.listener_list = []
         # nakuru库有bug，这个接口没法带access_token，会失败
         # 所以目前自行发请求
-        import config
+
+        config = context.get_config_manager().data
+
         import requests
         resp = requests.get(
-            url="http://{}:{}/get_login_info".format(config.nakuru_config['host'], config.nakuru_config['http_port']),
+            url="http://{}:{}/get_login_info".format(config['nakuru_config']['host'], config['nakuru_config']['http_port']),
             headers={
-                'Authorization': "Bearer " + config.nakuru_config['token'] if 'token' in config.nakuru_config else ""
+                'Authorization': "Bearer " + config['nakuru_config']['token'] if 'token' in config['nakuru_config']else ""
             },
             timeout=5
         )
         if resp.status_code == 403:
             logging.error("go-cqhttp拒绝访问，请检查config.py中nakuru_config的token是否与go-cqhttp设置的access-token匹配")
             raise Exception("go-cqhttp拒绝访问，请检查config.py中nakuru_config的token是否与go-cqhttp设置的access-token匹配")
+        try:
             self.bot_account_id = int(resp.json()['data']['user_id'])
+        except Exception as e:
+            logging.error("获取go-cqhttp账号信息失败: {}, 请检查是否已启动go-cqhttp并配置正确".format(e))
+            raise Exception("获取go-cqhttp账号信息失败: {}, 请检查是否已启动go-cqhttp并配置正确".format(e))
 
     def send_message(
         self,
@@ -267,7 +273,7 @@ class NakuruProjectAdapter(MessageSourceAdapter):
             logging.debug("注册监听器: " + str(event_type) + " -> " + str(callback))
 
             # 包装函数
-            async def listener_wrapper(app: nakuru.CQHTTP, source: self.event_converter.yiri2target(event_type)):
+            async def listener_wrapper(app: nakuru.CQHTTP, source: NakuruProjectAdapter.event_converter.yiri2target(event_type)):
                 callback(self.event_converter.target2yiri(source))
 
             # 将包装函数和原函数的对应关系存入列表

pkg/qqbot/sources/yirimirai.py

@@ -1,12 +1,14 @@
-from ..adapter import MessageSourceAdapter
-import mirai
-import mirai.models.bus
-
 import asyncio
 import typing
 
+import mirai
+import mirai.models.bus
+from mirai.bot import MiraiRunner
 
-class YiriMiraiAdapter(MessageSourceAdapter):
+from .. import adapter as adapter_model
+
+
+class YiriMiraiAdapter(adapter_model.MessageSourceAdapter):
     """YiriMirai适配器"""
     bot: mirai.Mirai
 
@@ -110,7 +112,12 @@ class YiriMiraiAdapter(MessageSourceAdapter):
         bus.unsubscribe(event_type, callback)
 
     def run_sync(self):
-        self.bot.run()
+        """运行YiriMirai"""
+
+        # 创建新的
+        loop = asyncio.new_event_loop()
+
+        loop.run_until_complete(MiraiRunner(self.bot)._run())
 
     def kill(self) -> bool:
         return False

pkg/utils/context.py

@@ -1,5 +1,13 @@
+from __future__ import annotations
+
 import threading
-from pkg.utils import ThreadCtl
+from . import threadctl
+
+from ..database import manager as db_mgr
+from ..openai import manager as openai_mgr
+from ..qqbot import manager as qqbot_mgr
+from ..config import  manager as config_mgr
+from ..plugin import host as plugin_host
 
 
 context = {
@@ -7,6 +15,7 @@ context = {
         'database.manager.DatabaseManager': None,
         'openai.manager.OpenAIInteract': None,
         'qqbot.manager.QQBotManager': None,
+        'config.manager.ConfigManager': None,
     },
     'pool_ctl': None,
     'logger_handler': None,
@@ -29,66 +38,79 @@ def get_config():
     return t
 
 
-def set_database_manager(inst):
+def set_database_manager(inst: db_mgr.DatabaseManager):
     context_lock.acquire()
     context['inst']['database.manager.DatabaseManager'] = inst
     context_lock.release()
 
 
-def get_database_manager():
+def get_database_manager() -> db_mgr.DatabaseManager:
     context_lock.acquire()
     t = context['inst']['database.manager.DatabaseManager']
     context_lock.release()
     return t
 
 
-def set_openai_manager(inst):
+def set_openai_manager(inst: openai_mgr.OpenAIInteract):
     context_lock.acquire()
     context['inst']['openai.manager.OpenAIInteract'] = inst
     context_lock.release()
 
 
-def get_openai_manager():
+def get_openai_manager() -> openai_mgr.OpenAIInteract:
     context_lock.acquire()
     t = context['inst']['openai.manager.OpenAIInteract']
     context_lock.release()
     return t
 
 
-def set_qqbot_manager(inst):
+def set_qqbot_manager(inst: qqbot_mgr.QQBotManager):
     context_lock.acquire()
     context['inst']['qqbot.manager.QQBotManager'] = inst
     context_lock.release()
 
 
-def get_qqbot_manager():
+def get_qqbot_manager() -> qqbot_mgr.QQBotManager:
     context_lock.acquire()
     t = context['inst']['qqbot.manager.QQBotManager']
     context_lock.release()
     return t
 
 
-def set_plugin_host(inst):
+def set_config_manager(inst: config_mgr.ConfigManager):
+    context_lock.acquire()
+    context['inst']['config.manager.ConfigManager'] = inst
+    context_lock.release()
+
+
+def get_config_manager() -> config_mgr.ConfigManager:
+    context_lock.acquire()
+    t = context['inst']['config.manager.ConfigManager']
+    context_lock.release()
+    return t
+
+
+def set_plugin_host(inst: plugin_host.PluginHost):
     context_lock.acquire()
     context['plugin_host'] = inst
     context_lock.release()
 
 
-def get_plugin_host():
+def get_plugin_host() -> plugin_host.PluginHost:
     context_lock.acquire()
     t = context['plugin_host']
     context_lock.release()
     return t
 
 
-def set_thread_ctl(inst):
+def set_thread_ctl(inst: threadctl.ThreadCtl):
     context_lock.acquire()
     context['pool_ctl'] = inst
     context_lock.release()
 
 
-def get_thread_ctl() -> ThreadCtl:
+def get_thread_ctl() -> threadctl.ThreadCtl:
     context_lock.acquire()
-    t: ThreadCtl = context['pool_ctl']
+    t: threadctl.ThreadCtl = context['pool_ctl']
     context_lock.release()
     return t

pkg/utils/log.py

@@ -3,6 +3,8 @@ import time
 import logging
 import shutil
 
+from . import context
+
 
 log_file_name = "qchatgpt.log"
 
@@ -36,7 +38,6 @@ def init_runtime_log_file():
 def reset_logging():
     global log_file_name
 
-    import config
     import pkg.utils.context
     import colorlog
 
@@ -46,7 +47,11 @@ def reset_logging():
     for handler in logging.getLogger().handlers:
         logging.getLogger().removeHandler(handler)
 
-    logging.basicConfig(level=config.logging_level,  # 设置日志输出格式
+    config_mgr = context.get_config_manager()
+
+    logging_level = logging.INFO if config_mgr is None else config_mgr.data['logging_level']
+
+    logging.basicConfig(level=logging_level,  # 设置日志输出格式
                         filename=log_file_name,  # log日志输出的文件位置和文件名
                         format="[%(asctime)s.%(msecs)03d] %(pathname)s (%(lineno)d) - [%(levelname)s] :\n%(message)s",
                         # 日志输出的格式
@@ -54,7 +59,7 @@ def reset_logging():
                         datefmt="%Y-%m-%d %H:%M:%S"  # 时间输出的格式
                         )
     sh = logging.StreamHandler()
-    sh.setLevel(config.logging_level)
+    sh.setLevel(logging_level)
     sh.setFormatter(colorlog.ColoredFormatter(
         fmt="%(log_color)s[%(asctime)s.%(msecs)03d] %(filename)s (%(lineno)d) - [%(levelname)s] : "
             "%(message)s",

pkg/utils/network.py

@@ -1,9 +1,11 @@
+from . import context
+
 
 def wrapper_proxies() -> dict:
     """获取代理"""
-    import config
+    config = context.get_config_manager().data
 
     return {
-        "http": config.openai_config['proxy'],
-        "https": config.openai_config['proxy']
-    } if 'proxy' in config.openai_config and (config.openai_config['proxy'] is not None) else None
+        "http": config['openai_config']['proxy'],
+        "https": config['openai_config']['proxy']
+    } if 'proxy' in config['openai_config'] and (config['openai_config']['proxy'] is not None) else None

pkg/utils/pkgmgr.py

@@ -1,6 +1,6 @@
 from pip._internal import main as pipmain
 
-import pkg.utils.log as log
+from . import log
 
 
 def install(package):
@@ -8,7 +8,8 @@ def install(package):
     log.reset_logging()
 
 def install_upgrade(package):
-    pipmain(['install', '--upgrade', package])
+    pipmain(['install', '--upgrade', package, "-i", "https://pypi.tuna.tsinghua.edu.cn/simple",
+                    "--trusted-host", "pypi.tuna.tsinghua.edu.cn"])
     log.reset_logging()
 
 
@@ -18,7 +19,8 @@ def run_pip(params: list):
 
 
 def install_requirements(file):
-    pipmain(['install', '-r', file, "--upgrade"])
+    pipmain(['install', '-r', file, "-i", "https://pypi.tuna.tsinghua.edu.cn/simple",
+                    "--trusted-host", "pypi.tuna.tsinghua.edu.cn"])
     log.reset_logging()
 
 

pkg/utils/reloader.py

@@ -1,10 +1,10 @@
 import logging
-import threading
-
 import importlib
 import pkgutil
-import pkg.utils.context as context
-import pkg.plugin.host
+import asyncio
+
+from . import context
+from ..plugin import host as plugin_host
 
 
 def walk(module, prefix='', path_prefix=''):
@@ -15,7 +15,7 @@ def walk(module, prefix='', path_prefix=''):
             walk(__import__(module.__name__ + '.' + item.name, fromlist=['']), prefix + item.name + '.', path_prefix + item.name + '/')
         else:
             logging.info('reload module: {}, path: {}'.format(prefix + item.name, path_prefix + item.name + '.py'))
-            pkg.plugin.host.__current_module_path__ = "plugins/" + path_prefix + item.name + '.py'
+            plugin_host.__current_module_path__ = "plugins/" + path_prefix + item.name + '.py'
             importlib.reload(__import__(module.__name__ + '.' + item.name, fromlist=['']))
 
 
@@ -53,15 +53,17 @@ def reload_all(notify=True):
 
     # 执行启动流程
     logging.info("执行程序启动流程")
-    main.load_config()
-    main.complete_tips()
+
     context.get_thread_ctl().reload(
-        admin_pool_num=context.get_config().admin_pool_num,
-        user_pool_num=context.get_config().user_pool_num
+        admin_pool_num=4,
+        user_pool_num=8
     )
+
+    def run_wrapper():
+        asyncio.run(main.start_process(False))
+
     context.get_thread_ctl().submit_sys_task(
-        main.start,
-        False
+        run_wrapper
     )
 
     logging.info('程序启动完成')

pkg/utils/text2img.py

@@ -1,15 +1,20 @@
 import logging
-
-from PIL import Image, ImageDraw, ImageFont
 import re
 import os
-import config
 import traceback
 
+from PIL import Image, ImageDraw, ImageFont
+
+from ..utils import context
+
+
 text_render_font: ImageFont = None
 
-if config.blob_message_strategy == "image":  # 仅在启用了image时才加载字体
-    use_font = config.font_path
+def initialize():
+    config = context.get_config_manager().data
+
+    if config['blob_message_strategy'] == "image":  # 仅在启用了image时才加载字体
+        use_font = config['font_path']
         try:
 
             # 检查是否存在
@@ -19,19 +24,19 @@ if config.blob_message_strategy == "image":  # 仅在启用了image时才加载
                     use_font = "C:/Windows/Fonts/msyh.ttc"
                     if not os.path.exists(use_font):
                         logging.warn("未找到字体文件，且无法使用Windows自带字体，更换为转发消息组件以发送长消息，您可以在config.py中调整相关设置。")
-                    config.blob_message_strategy = "forward"
+                        config['blob_message_strategy'] = "forward"
                     else:
                         logging.info("使用Windows自带字体：" + use_font)
                         text_render_font = ImageFont.truetype(use_font, 32, encoding="utf-8")
                 else:
                     logging.warn("未找到字体文件，且无法使用Windows自带字体，更换为转发消息组件以发送长消息，您可以在config.py中调整相关设置。")
-                config.blob_message_strategy = "forward"
+                    config['blob_message_strategy'] = "forward"
             else:
                 text_render_font = ImageFont.truetype(use_font, 32, encoding="utf-8")
         except:
             traceback.print_exc()
             logging.error("加载字体文件失败({})，更换为转发消息组件以发送长消息，您可以在config.py中调整相关设置。".format(use_font))
-        config.blob_message_strategy = "forward"
+            config['blob_message_strategy'] = "forward"
 
 
 def indexNumber(path=''):

pkg/utils/updater.py

@@ -3,10 +3,9 @@ import logging
 import os.path
 
 import requests
-import json
 
-import pkg.utils.constants
-import pkg.utils.network as network
+from . import constants
+from . import network
 
 
 def check_dulwich_closure():
@@ -70,7 +69,7 @@ def get_release_list() -> list:
 
 def get_current_tag() -> str:
     """获取当前tag"""
-    current_tag = pkg.utils.constants.semantic_version
+    current_tag = constants.semantic_version
     if os.path.exists("current_tag"):
         with open("current_tag", "r") as f:
             current_tag = f.read()
@@ -78,6 +77,34 @@ def get_current_tag() -> str:
     return current_tag
 
 
+def compare_version_str(v0: str, v1: str) -> int:
+    """比较两个版本号"""
+
+    # 删除版本号前的v
+    if v0.startswith("v"):
+        v0 = v0[1:]
+    if v1.startswith("v"):
+        v1 = v1[1:]
+
+    v0:list = v0.split(".")
+    v1:list = v1.split(".")
+
+    # 如果两个版本号节数不同，把短的后面用0补齐
+    if len(v0) < len(v1):
+        v0.extend(["0"]*(len(v1)-len(v0)))
+    elif len(v0) > len(v1):
+        v1.extend(["0"]*(len(v0)-len(v1)))
+
+    # 从高位向低位比较
+    for i in range(len(v0)):
+        if int(v0[i]) > int(v1[i]):
+            return 1
+        elif int(v0[i]) < int(v1[i]):
+            return -1
+    
+    return 0
+
+
 def update_all(cli: bool = False) -> bool:
     """检查更新并下载源码"""
     current_tag = get_current_tag()
@@ -176,9 +203,9 @@ def update_all(cli: bool = False) -> bool:
     # 通知管理员
     if not cli:
         import pkg.utils.context
-        pkg.utils.context.get_qqbot_manager().notify_admin("已更新到最新版本: {}\n更新日志:\n{}\n完整的更新日志请前往 https://github.com/RockChinQ/QChatGPT/releases 查看".format(current_tag, "\n".join(rls_notes[:-1])))
+        pkg.utils.context.get_qqbot_manager().notify_admin("已更新到最新版本: {}\n更新日志:\n{}\n完整的更新日志请前往 https://github.com/RockChinQ/QChatGPT/releases 查看。\n请手动重启程序以使用新版本。".format(current_tag, "\n".join(rls_notes[:-1])))
     else:
-        print("已更新到最新版本: {}\n更新日志:\n{}\n完整的更新日志请前往 https://github.com/RockChinQ/QChatGPT/releases 查看".format(current_tag, "\n".join(rls_notes[:-1])))
+        print("已更新到最新版本: {}\n更新日志:\n{}\n完整的更新日志请前往 https://github.com/RockChinQ/QChatGPT/releases 查看。请手动重启程序以使用新版本。".format(current_tag, "\n".join(rls_notes[:-1])))
     return True
 
 

requirements.txt

@@ -1,10 +1,13 @@
-requests~=2.31.0
-openai~=0.27.7
-dulwich~=0.21.5
+requests
+openai
+dulwich~=0.21.6
 colorlog~=6.6.0
-yiri-mirai~=0.2.7
+yiri-mirai-rc
 websockets
-urllib3~=1.26.10
+urllib3
 func_timeout~=4.3.5
 Pillow
 nakuru-project-idk
+CallingGPT
+tiktoken
+PyYaml

res/announcement.json

@@ -1,14 +1,26 @@
 [
     {
-        "id": 0,
-        "time": "2023-04-24 16:05:20",
-        "timestamp": 1682323520,
-        "content": "现已支持使用go-cqhttp替换mirai作为QQ登录框架, 请更新并查看 https://github.com/RockChinQ/QChatGPT/wiki/go-cqhttp%E9%85%8D%E7%BD%AE"
+        "id": 2,
+        "time": "2023-08-01 10:49:26",
+        "timestamp": 1690858166,
+        "content": "现已支持GPT函数调用功能，欢迎了解：https://github.com/RockChinQ/QChatGPT/wiki/%E6%8F%92%E4%BB%B6%E4%BD%BF%E7%94%A8-%E5%86%85%E5%AE%B9%E5%87%BD%E6%95%B0"
     },
     {
-        "id": 1,
-        "time": "2023-05-21 17:33:18",
-        "timestamp": 1684661598,
-        "content": "NewBing不再需要鉴权，若您正在使用revLibs逆向库插件，请立即使用!plugin update revLibs命令更新插件到最新版。"
+        "id": 3,
+        "time": "2023-11-10 12:20:09",
+        "timestamp": 1699590009,
+        "content": "OpenAI 库1.0版本已发行，若出现 OpenAI 调用问题，请更新 QChatGPT 版本。详见项目主页：https://github.com/RockChinQ/QChatGPT"
+    },
+    {
+        "id": 4,
+        "time": "2023-11-13 18:02:39",
+        "timestamp": 1699869759,
+        "content": "近期 OpenAI 接口改动频繁，正在积极适配并添加新功能，请尽快更新到最新版本，更新方式：https://github.com/RockChinQ/QChatGPT/discussions/595"
+    },
+    {
+        "id": 5,
+        "time": "2023-12-07 9:20:00",
+        "timestamp": 1701912000,
+        "content": "QChatGPT 一周年啦！感谢大家的选择和支持，RockChinQ 在此衷心感谢素未谋面但又至关重要的你们每一个人，愿 AI 与我们同在！欢迎前往：https://github.com/RockChinQ/QChatGPT/discussions/627 参与讨论。"
     }
 ]

res/docs/docker_deploy.md

@@ -1,4 +1,6 @@
 
+> [!WARNING]
+> 此文档已过时，请查看[QChatGPT 容器化部署指南](docker_deployment.md)
 
 ## 操作步骤
 

res/docs/docker_deployment.md

@@ -0,0 +1,64 @@
+# QChatGPT 容器化部署指南
+
+> [!WARNING]  
+> 请您确保您**确实**需要 Docker 部署，您**必须**具有以下能力：  
+> - 了解 `Docker` 和 `Docker Compose` 的使用  
+> - 了解容器间网络通信配置方式  
+> - 了解容器文件挂载机制  
+> - 了解容器调试操作
+> - 动手能力强、资料查找能力强
+>
+> 若您不完全具有以上能力，请勿使用 Docker 部署，由于误操作导致的配置不正确，我们将不会解答您的问题并不负任何责任。  
+> **非常不建议**您在除 Linux 之外的系统上使用 Docker 进行部署。
+
+## 概览
+
+QChatGPT 主程序需要连接`QQ登录框架`以与QQ通信，您可以选择 [Mirai](https://github.com/mamoe/mirai)（还需要配置mirai-api-http，请查看此仓库README中手动部署部分） 或 [go-cqhttp](https://github.com/Mrs4s/go-cqhttp)，我们仅发布 QChatGPT主程序 的镜像，您需要自行配置QQ登录框架（可以参考[README.md](https://github.com/RockChinQ/QChatGPT#-%E9%85%8D%E7%BD%AEqq%E7%99%BB%E5%BD%95%E6%A1%86%E6%9E%B6)中的教程，或自行寻找其镜像）并在 QChatGPT 的配置文件中设置连接地址。
+
+> [!NOTE]
+> 请先确保 Docker 和 Docker Compose 已安装
+
+## 准备文件
+
+> QChatGPT 目前暂不可以在没有配置模板文件的情况下自动生成文件，您需要按照以下步骤手动创建需要挂载的文件。  
+> 如无特殊说明，模板文件均在此仓库中。  
+
+> 如果您不想挨个创建，也可以直接clone本仓库到本地，执行`python main.py`后即可自动根据模板生成所需文件。
+
+现在请在一个空目录创建以下文件或目录：
+
+### 📄`config.py`
+
+复制根目录的`config-template.py`所有内容，创建`config.py`并根据其中注释进行修改。
+
+### 📄`banlist.py`
+
+复制`res/templates/banlist-template.py`所有内容，创建`banlist.py`，这是黑名单配置文件，根据需要修改。
+
+### 📄`cmdpriv.json`
+
+复制`res/templates/cmdpriv-template.json`所有内容，创建`cmdpriv.json`，这是各命令的权限配置文件，根据需要修改。
+
+### 📄`sensitive.json`
+
+复制`res/templates/sensitive-template.json`所有内容，创建`sensitive.json`，这是敏感词配置，根据需要修改。
+
+### 📄`tips.py`
+
+复制`tips-custom-template.py`所有内容，创建`tips.py`，这是部分提示语的配置，根据需要修改。
+
+## 运行
+
+已预先准备好`docker-compose.yaml`，您需要根据您的网络配置进行适当修改，使容器内的 QChatGPT 程序可以正常与 Mirai 或 go-cqhttp 通信。
+
+将`docker-compose.yaml`复制到本目录，根据网络环境进行配置，并执行:
+
+```bash
+docker compose up
+```
+
+若无报错即配置完成，您可以Ctrl+C关闭后使用`docker compose up -d`将其置于后台运行
+
+## 注意
+
+- 安装的插件都会保存在`plugins`(映射到本目录`plugins`)，安装插件时可能会自动安装相应的依赖，此时若`重新创建`容器，已安装的插件将被加载，但所需的增量依赖并未安装，会导致引入问题。您可以删除插件目录后重启，再次安装插件，以便程序可以自动安装插件所需依赖。

res/templates/cmdpriv-template.json

@@ -1,7 +1,8 @@
 {
     "comment": "以下为命令权限，请设置到cmdpriv.json中。关于此功能的说明，请查看：https://github.com/RockChinQ/QChatGPT/wiki/%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8#%E5%91%BD%E4%BB%A4%E6%9D%83%E9%99%90%E6%8E%A7%E5%88%B6",
     "draw": 1,
-    "plugin": 2,
+    "func": 1,
+    "plugin": 1,
     "plugin.get": 2,
     "plugin.update": 2,
     "plugin.del": 2,

res/wiki/1-功能使用.md

@@ -48,12 +48,12 @@
 </details>
 
 <details>
-<summary>✅支持预设指令文字</summary>
+<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)
-  - 支持使用文件存储情景预设文字，并加载: 在`prompts/`目录新建文件写入预设文字，即可通过`!reset <文件名>`指令加载
+  - 支持设置多个预设情景，并通过!reset、!default等命令控制，详细请查看[wiki命令](https://github.com/RockChinQ/QChatGPT/wiki/1-%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8#%E6%9C%BA%E5%99%A8%E4%BA%BA%E5%91%BD%E4%BB%A4)
+  - 支持使用文件存储情景预设文字，并加载: 在`prompts/`目录新建文件写入预设文字，即可通过`!reset <文件名>`命令加载
 </details>
 
 <details>
@@ -61,25 +61,25 @@
 
   - 使用SQLite进行会话内容持久化
   - 最后一次对话一定时间后自动保存，请到`config.py`中修改`session_expire_time`的值以自定义时间
-  - 运行期间可使用`!reset` `!list` `!last` `!next` `!prompt`等指令管理会话
+  - 运行期间可使用`!reset` `!list` `!last` `!next` `!prompt`等命令管理会话
 </details>
 <details>
 <summary>✅支持对话、绘图等模型，可玩性更高</summary>
 
   - 现已支持OpenAI的对话`Completion API`和绘图`Image API`
-  - 向机器人发送指令`!draw <prompt>`即可使用绘图模型
+  - 向机器人发送命令`!draw <prompt>`即可使用绘图模型
 </details>
 <details>
-<summary>✅支持指令控制热重载、热更新</summary>
+<summary>✅支持命令控制热重载、热更新</summary>
 
-  - 允许在运行期间修改`config.py`或其他代码后，以管理员账号向机器人发送指令`!reload`进行热重载，无需重启
-  - 运行期间允许以管理员账号向机器人发送指令`!update`进行热更新，拉取远程最新代码并执行热重载
+  - 允许在运行期间修改`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)
+  - 详细查看[插件使用页](https://github.com/RockChinQ/QChatGPT/wiki/5-%E6%8F%92%E4%BB%B6%E4%BD%BF%E7%94%A8)
 </details>
 <details>
 <summary>✅私聊、群聊黑名单机制</summary>
@@ -153,14 +153,14 @@
 
 <img alt="绘图功能" src="https://github.com/RockChinQ/QChatGPT/blob/master/res/屏幕截图%202022-12-29%20194948.png" width="550" height="348"/>
 
-### 机器人指令
+### 机器人命令
 
-目前支持的指令  
+目前支持的命令  
 
 > `<>` 中的为必填参数，使用时请不要包含`<>`  
 > `[]` 中的为可选参数，使用时请不要包含`[]`
 
-#### 用户级别指令
+#### 用户级别命令
 
 > 可以使用`!help`命令来查看命令说明
 
@@ -174,7 +174,7 @@
 !del all          删除本会话对象的所有历史记录
 !last             切换到前一次会话
 !next             切换到后一次会话
-!reset [使用预设]  重置对象的当前会话，可指定使用的情景预设值(通过!default指令查看可用的)
+!reset [使用预设]  重置对象的当前会话，可指定使用的情景预设值(通过!default命令查看可用的)
 !prompt           查看对象当前会话的所有记录
 !usage            查看api-key的使用量
 !draw <提示语>     进行绘图
@@ -184,7 +184,7 @@
 !default          查看可用的情景预设值
 ```
 
-#### 管理员指令
+#### 管理员命令
 
 仅管理员私聊机器人时可使用，必须先在`config.py`中的`admin_qq`设置管理员QQ
 
@@ -197,9 +197,9 @@
 !delhst all                         删除所有会话的所有历史记录
 ```
 <details>
-<summary>⚙ !cfg 指令及其简化形式详解</summary>
+<summary>⚙ !cfg 命令及其简化形式详解</summary>
 
-此指令可以在运行期间由管理员通过QQ私聊窗口修改配置信息，**重启之后会失效**。  
+此命令可以在运行期间由管理员通过QQ私聊窗口修改配置信息，**重启之后会失效**。  
 
 用法：
 1. 查看所有配置项及其值
@@ -239,7 +239,7 @@
 
 格式:`!~<配置项名称>`  
 其中`!~`等价于`!cfg `  
-则前述三个指令分别可以简化为:  
+则前述三个命令分别可以简化为:  
 ```
 !~all
 !~default_prompt
@@ -290,11 +290,11 @@ sensitive_word_filter = True
 ### 预设文字(default模式)
 
 编辑`config.py`中的`default_prompt`字段，预设文字不宜过长(建议1000字以内)，目前所有会话都会射到预设文字的影响。  
-或将情景预设文字写入到`prompts/`目录下，运行期间即可使用`!reset <文件名>`指令加载，或使用`!default <文件名>`指令将其设为默认
+或将情景预设文字写入到`prompts/`目录下，运行期间即可使用`!reset <文件名>`命令加载，或使用`!default <文件名>`命令将其设为默认
 
 ### 预设文字(full_scenario模式)
 
-将JSON情景写入到`scenario/`目录下，运行期间即可使用`!reset <文件名>`指令加载，或使用`!default <文件名>`指令将其设为默认.
+将JSON情景写入到`scenario/`目录下，运行期间即可使用`!reset <文件名>`命令加载，或使用`!default <文件名>`命令将其设为默认.
 
 JSON情景模板参考`scenario/default_template.json`。
 
@@ -367,7 +367,7 @@ prompt_submit_length = <模型单次请求token数上限> - 情景预设中token
 
 在运行期间，使用管理员QQ账号私聊机器人，发送`!reload`加载修改后的`config.py`的值或编辑后的代码，无需重启  
 使用管理员账号私聊机器人，发送`!update`拉取最新代码并进行热更新，无需重启  
-详见前述`管理员指令`段落
+详见前述`管理员命令`段落
 
 ### 群内无需@响应规则
 

res/wiki/2-功能常见问题.md

@@ -4,7 +4,7 @@
 
 #### 自动更新
 
-由管理员QQ私聊机器人QQ发送`!update`指令
+由管理员QQ私聊机器人QQ发送`!update`命令
 
 #### 手动更新
 

res/wiki/5-插件使用.md

@@ -4,6 +4,9 @@ QChatGPT 插件使用Wiki
 
 `plugins`目录下的所有`.py`程序都将被加载，除了`__init__.py`之外的模块支持热加载
 
+> 插件分为`行为插件`和`内容插件`两种，行为插件由主程序运行中的事件驱动，内容插件由GPT生成的内容驱动，请查看内容插件页  
+> 已有插件列表：[QChatGPT 插件](https://github.com/stars/RockChinQ/lists/qchatgpt-%E6%8F%92%E4%BB%B6)
+
 ## 安装
 
 ### 储存库克隆(推荐)
@@ -33,6 +36,8 @@ QChatGPT 插件使用Wiki
 !plugin del <插件名>       删除插件(需要管理员权限)
 !plugin on <插件名>        启用插件(需要管理员权限)
 !plugin off <插件名>       禁用插件(需要管理员权限)
+
+!func                      列出所有内容函数
 ```
 
 ### 控制插件执行顺序
@@ -43,3 +48,8 @@ QChatGPT 插件使用Wiki
 
 无需卸载即可管理插件的开关  
 编辑`plugins`目录下的`switch.json`文件，将相应的插件的`enabled`字段设置为`true/false(开/关)`，之后重启程序或执行热重载即可控制插件开关
+
+### 控制全局内容函数开关
+
+内容函数是基于[GPT的Function Calling能力](https://platform.openai.com/docs/guides/gpt/function-calling)实现的，这是一种嵌入对话中，由GPT自动调用的函数。  
+每个插件可以自行注册内容函数，您可以在`plugins`目录下的`settings.json`中设置`functions`下的`enabled`为`true`或`false`控制这些内容函数的启用或禁用。

res/wiki/6-插件使用-内容函数.md

@@ -0,0 +1,31 @@
+> 说白了就是ChatGPT官方插件那种东西
+
+内容函数是基于[GPT的Function Calling能力](https://platform.openai.com/docs/guides/gpt/function-calling)实现的，这是一种嵌入对话中，由GPT自动调用的函数。  
+
+例如我们为GPT提供一个函数`access_the_web`，并提供其详细的描述以及其参数的描述，那么当我们在与GPT对话时涉及类似以下内容时：
+
+```
+Q: 请搜索一下github上有那些QQ机器人项目？
+Q: 请为我搜索一些不错的云服务商网站？
+Q：阅读并总结这篇文章：https://zhuanlan.zhihu.com/p/607570830
+Q：搜一下清远今天天气如何
+```
+
+GPT将会回复一个对`access_the_web`的函数调用请求，QChatGPT将自动处理执行该调用，并返回结果给GPT使其生成新的回复。
+
+当然，函数调用功能不止局限于网络访问，还可以实现图片处理、科学计算、行程规划等需要调用函数的功能，理论上我们可以通过内容函数实现与`ChatGPT Plugins`相同的功能。
+
+- 您需要使用`v2.5.0`以上的版本才能加载包含内容函数的插件
+- 您需要同时在`config.py`中的`completion_api_params`中设置`model`为支持函数调用的模型，推荐使用`gpt-3.5-turbo-16k`
+- 使用此功能可能会造成难以预期的账号余额消耗，请关注
+- [逆向库插件](https://github.com/RockChinQ/revLibs)现在也支持函数调用了..您可以在完全免费的情况下使用GPT-3.5进行函数调用，若您在主程序配置了内容函数并启用，逆向ChatGPT会自动使用这些函数
+
+### ？QChatGPT有什么类型的插件？区别是什么？
+
+QChatGPT具有`行为插件`和`内容函数`两种扩展方式，行为插件是完整的插件结构，是由运行期间的事件驱动的，内容函数被包含于一个完整的插件体中，由GPT接口驱动。
+
+> 还是不理解？可以尝试根据插件开发页的步骤自行编写插件
+
+## QChatGPT的一些不错的内容函数插件
+
+- [WebwlkrPlugin](https://github.com/RockChinQ/WebwlkrPlugin) - 让机器人能联网！！

res/wiki/7-插件开发.md

@@ -1,7 +1,7 @@
 QChatGPT 插件开发Wiki
 
-> 请先阅读[插件使用页](https://github.com/RockChinQ/QChatGPT/wiki/%E6%8F%92%E4%BB%B6%E4%BD%BF%E7%94%A8)  
-> 请先阅读[技术信息页](https://github.com/RockChinQ/QChatGPT/wiki/%E6%8A%80%E6%9C%AF%E4%BF%A1%E6%81%AF)  
+> 请先阅读[插件使用页](https://github.com/RockChinQ/QChatGPT/wiki/5-%E6%8F%92%E4%BB%B6%E4%BD%BF%E7%94%A8)  
+> 请先阅读[技术信息页](https://github.com/RockChinQ/QChatGPT/wiki/4-%E6%8A%80%E6%9C%AF%E4%BF%A1%E6%81%AF)  
 > 建议先阅读本项目源码，了解项目架构
 
 > 问题、需求请到仓库issue发起  
@@ -113,6 +113,199 @@ class HelloPlugin(Plugin):
 - 一个目录内可以存放多个Python程序文件，以独立出插件的各个功能，便于开发者管理，但不建议在一个目录内注册多个插件
 - 插件需要的依赖库请在插件目录下的`requirements.txt`中指定，程序从储存库获取此插件时将自动安装依赖
 
+## 🪝内容函数
+
+通过[GPT的Function Calling能力](https://platform.openai.com/docs/guides/gpt/function-calling)实现的`内容函数`，这是一种嵌入对话中，由GPT自动调用的函数。
+
+> 您的插件不一定必须包含内容函数，请先查看内容函数页了解此功能
+
+<details>
+<summary>示例：联网插件</summary>
+
+加载含有联网功能的内容函数的插件[WebwlkrPlugin](https://github.com/RockChinQ/WebwlkrPlugin)，向机器人询问在线内容
+
+```
+# 控制台输出
+[2023-07-29 17:37:18.698] message.py (26) - [INFO] : [person_1010553892]发送消息:介绍一下这个项目：https://git...
+[2023-07-29 17:37:21.292] util.py (67) - [INFO] : message='OpenAI API response' path=https://api.openai.com/v1/chat/completions processing_ms=1902 request_id=941afc13b2e1bba1e7877b92a970cdea response_code=200
+[2023-07-29 17:37:21.293] chat_completion.py (159) - [INFO] : 执行函数调用: name=Webwlkr-access_the_web, arguments={'url': 'https://github.com/RockChinQ/QChatGPT', 'brief_len': 512}
+[2023-07-29 17:37:21.848] chat_completion.py (164) - [INFO] : 函数执行完成。
+```
+
+![Webwlkr插件](https://github.com/RockChinQ/QChatGPT/blob/master/res/screenshots/webwlkr_plugin.png?raw=true)
+
+</details>
+
+### 内容函数编写步骤
+
+1️⃣ 请先按照上方步骤编写您的插件基础结构，现在请删除（当然你也可以不删，只是为了简洁）上述插件内容的诸个由`@on`装饰的类函数
+
+<details>
+<summary>删除后的结构</summary>
+
+```python
+from pkg.plugin.models import *
+from pkg.plugin.host import EventContext, PluginHost
+
+"""
+在收到私聊或群聊消息"hello"时，回复"hello, <发送者id>!"或"hello, everyone!"
+"""
+
+
+# 注册插件
+@register(name="Hello", description="hello world", version="0.1", author="RockChinQ")
+class HelloPlugin(Plugin):
+
+    # 插件加载时触发
+    # plugin_host (pkg.plugin.host.PluginHost) 提供了与主程序交互的一些方法，详细请查看其源码
+    def __init__(self, plugin_host: PluginHost):
+        pass
+
+    # 插件卸载时触发
+    def __del__(self):
+        pass
+```
+
+</details>
+
+2️⃣ 现在我们将以下函数添加到刚刚删除的函数的位置
+
+```Python
+
+# 要添加的函数
+
+@func(name="access_the_web")  # 设置函数名称
+def _(url: str):
+    """Call this function to search about the question before you answer any questions.
+    - Do not search through baidu.com at any time.
+    - If you need to search somthing, visit https://www.google.com/search?q=xxx.
+    - If user ask you to open a url (start with http:// or https://), visit it directly.
+    - Summary the plain content result by yourself, DO NOT directly output anything in the result you got.
+
+    Args:
+        url(str): url to visit
+
+    Returns:
+        str: plain text content of the web page
+    """
+    import requests
+    from bs4 import BeautifulSoup
+    # 你需要先使用
+    # pip install beautifulsoup4
+    # 安装依赖
+
+    r = requests.get(
+        url,
+        timeout=10,
+        headers={
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36 Edg/115.0.1901.183"
+        }
+    )
+    soup = BeautifulSoup(r.text, 'html.parser')
+
+    s = soup.get_text()
+
+    # 删除多余的空行或仅有\t和空格的行
+    s = re.sub(r'\n\s*\n', '\n', s)
+
+    if len(s) >= 512:  # 截取获取到的网页纯文本内容的前512个字
+        return s[:512]
+
+    return s
+
+```
+<details>
+<summary>现在这个文件内容应该是这样</summary>
+
+```python
+from pkg.plugin.models import *
+from pkg.plugin.host import EventContext, PluginHost
+
+"""
+在收到私聊或群聊消息"hello"时，回复"hello, <发送者id>!"或"hello, everyone!"
+"""
+
+
+# 注册插件
+@register(name="Hello", description="hello world", version="0.1", author="RockChinQ")
+class HelloPlugin(Plugin):
+
+    # 插件加载时触发
+    # plugin_host (pkg.plugin.host.PluginHost) 提供了与主程序交互的一些方法，详细请查看其源码
+    def __init__(self, plugin_host: PluginHost):
+        pass
+
+    @func(name="access_the_web")
+    def _(url: str):
+        """Call this function to search about the question before you answer any questions.
+        - Do not search through baidu.com at any time.
+        - If you need to search somthing, visit https://www.google.com/search?q=xxx.
+        - If user ask you to open a url (start with http:// or https://), visit it directly.
+        - Summary the plain content result by yourself, DO NOT directly output anything in the result you got.
+
+        Args:
+            url(str): url to visit
+
+        Returns:
+            str: plain text content of the web page
+        """
+        import requests
+        from bs4 import BeautifulSoup
+        # 你需要先使用
+        # pip install beautifulsoup4
+        # 安装依赖
+
+        r = requests.get(
+            url,
+            timeout=10,
+            headers={
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36 Edg/115.0.1901.183"
+            }
+        )
+        soup = BeautifulSoup(r.text, 'html.parser')
+
+        s = soup.get_text()
+
+        # 删除多余的空行或仅有\t和空格的行
+        s = re.sub(r'\n\s*\n', '\n', s)
+
+        if len(s) >= 512:  # 截取获取到的网页纯文本内容的前512个字
+            return s[:512]
+
+        return s
+
+    # 插件卸载时触发
+    def __del__(self):
+        pass
+```
+
+</details>
+
+#### 请注意：
+
+- 函数的注释必须严格按照要求的格式进行书写，具体格式请查看[此文档](https://github.com/RockChinQ/CallingGPT/wiki/1.-Function-Format#function-format)
+- 内容函数和`以@on装饰的行为函数`可以同时存在于同一个插件，并同时受到`switch.json`中的插件开关的控制
+- 务必确保您使用的模型支持函数调用功能，可以到`config.py`的`completion_api_params`中修改模型，推荐使用`gpt-3.5-turbo-16k`
+
+3️⃣ 现在您的程序已具备网络访问功能，重启程序，询问机器人有关在线的内容或直接发送文章链接请求其总结。
+
+- 这仅仅是一个示例，需要更高效的网络访问能力支持插件，请查看[WebwlkrPlugin](https://github.com/RockChinQ/WebwlkrPlugin)
+
+## 🔒版本要求
+
+若您的插件对主程序的版本有要求，可以使用以下函数进行断言，若不符合版本，此函数将报错并打断此函数所在的流程：
+
+```python
+require_ver("v2.5.1")  # 要求最低版本为 v2.5.1
+```
+
+```python
+require_ver("v2.5.1", "v2.6.0")  # 要求最低版本为 v2.5.1, 同时要求最高版本为 v2.6.0
+```
+
+- 此函数在主程序`v2.5.1`中加入
+- 此函数声明在`pkg.plugin.models`模块中，在插件示例代码最前方已引入此模块所有内容，故可直接使用
+
 ## 📄API参考
 
 ### 说明
@@ -161,18 +354,18 @@ PersonNormalMessageReceived = "person_normal_message_received"
 """
 
 PersonCommandSent = "person_command_sent"
-"""判断为应该处理的私聊指令时触发
+"""判断为应该处理的私聊命令时触发
     kwargs:
         launcher_type: str 发起对象类型(group/person)
         launcher_id: int 发起对象ID(群号/QQ号)
         sender_id: int 发送者ID(QQ号)
-        command: str 指令
+        command: str 命令
         params: list[str] 参数列表
-        text_message: str 完整指令文本
+        text_message: str 完整命令文本
         is_admin: bool 是否为管理员
     
     returns (optional):
-        alter: str 修改后的完整指令文本
+        alter: str 修改后的完整命令文本
         reply: list 回复消息组件列表，元素为YiriMirai支持的消息组件
 """
 
@@ -190,18 +383,18 @@ GroupNormalMessageReceived = "group_normal_message_received"
 """
 
 GroupCommandSent = "group_command_sent"
-"""判断为应该处理的群聊指令时触发
+"""判断为应该处理的群聊命令时触发
     kwargs:
         launcher_type: str 发起对象类型(group/person)
         launcher_id: int 发起对象ID(群号/QQ号)
         sender_id: int 发送者ID(QQ号)
-        command: str 指令
+        command: str 命令
         params: list[str] 参数列表
-        text_message: str 完整指令文本
+        text_message: str 完整命令文本
         is_admin: bool 是否为管理员
     
     returns (optional):
-        alter: str 修改后的完整指令文本
+        alter: str 修改后的完整命令文本
         reply: list 回复消息组件列表，元素为YiriMirai支持的消息组件
 """
 
@@ -214,10 +407,11 @@ NormalMessageResponded = "normal_message_responded"
         session: pkg.openai.session.Session 会话对象
         prefix: str 回复文字消息的前缀
         response_text: str 响应文本
+        finish_reason: str 响应结束原因
     
     returns (optional):
         prefix: str 修改后的回复文字消息的前缀
-        reply: list 替换回复消息组件列表，元素为YiriMirai支持的消息组件
+        reply: list 替换回复消息组件列表
 """
 
 SessionFirstMessageReceived = "session_first_message_received"
@@ -257,6 +451,20 @@ KeySwitched = "key_switched"
         key_name: str 切换成功的api-key名称
         key_list: list[str] api-key列表
 """
+
+PromptPreProcessing = "prompt_pre_processing"  # 于v2.5.1加入
+"""每回合调用接口前对prompt进行预处理时触发，此事件不支持阻止默认行为
+    kwargs:
+        session_name: str 会话名称(<launcher_type>_<launcher_id>)
+        default_prompt: list 此session使用的情景预设内容
+        prompt: list 此session现有的prompt内容
+        text_message: str 用户发送的消息文本
+    
+    returns (optional):
+        default_prompt: list 修改后的情景预设内容
+        prompt: list 修改后的prompt内容
+        text_message: str 修改后的消息文本
+"""
 ```
 
 ### host: PluginHost 详解

tests/bs_test/bs_test.py

@@ -0,0 +1,42 @@
+
+import requests
+from bs4 import BeautifulSoup
+import os
+import random
+import sys
+
+
+user_agents = [
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.131 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:88.0) Gecko/20100101 Firefox/88.0',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.131 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Version/14.1.2 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Version/14.1 Safari/537.36',
+    'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:89.0) Gecko/20100101 Firefox/89.0',
+    'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:88.0) Gecko/20100101 Firefox/88.0'
+]
+
+r = requests.get(
+    sys.argv[1],
+    headers={
+        "User-Agent": random.choice(user_agents)
+    }    
+)
+soup = BeautifulSoup(r.text, 'html.parser')
+# print(soup.get_text())
+
+raw = soup.get_text()
+
+import re
+
+# strip每一行
+# raw = '\n'.join([line.strip() for line in raw.split('\n')])
+
+# # 删除所有空行或只有空格的行
+# raw = re.sub(r'\n\s*\n', '\n', raw)
+
+
+print(raw)

tests/proxy_test/forward_proxy_test.py

@@ -0,0 +1,24 @@
+import os
+
+import openai
+
+client = openai.Client(
+    api_key=os.environ["OPENAI_API_KEY"],
+)
+
+openai.proxies = {
+    'http': 'http://127.0.0.1:7890',
+    'https': 'http://127.0.0.1:7890',
+}
+
+resp = client.chat.completions.create(
+    model="gpt-3.5-turbo",
+    messages=[
+        {
+            "role": "user",
+            "content": "Hello, how are you?",
+        }
+    ]
+)
+
+print(resp)

tests/repo_regexp_test.py

@@ -0,0 +1,7 @@
+import re
+
+repo_url = "git@github.com:RockChinQ/WebwlkrPlugin.git"
+
+repo =  re.findall(r'(?:https?://github\.com/|git@github\.com:)([^/]+/[^/]+?)(?:\.git|/|$)', repo_url)
+
+print(repo)

tests/ssh_client_test/ssh_client.py

@@ -0,0 +1,57 @@
+import os
+import sys
+import paramiko
+import time
+import select
+
+
+class sshClient:
+    #创建一个ssh客户端，和服务器连接上，准备发消息
+    def __init__(self,host,port,user,password):
+        self.trans = paramiko.Transport((host, port))
+        self.trans.start_client()
+        self.trans.auth_password(username=user, password=password)
+        self.channel = self.trans.open_session()
+        self.channel.get_pty()
+        self.channel.invoke_shell()
+
+    #给服务器发送一个命令
+    def sendCmd(self,cmd):
+        self.channel.sendall(cmd)
+        
+    #接收的时候，有时候服务器处理的比较慢，需要设置一个延时等待一下。
+    def recvResponse(self,timeout):
+        data=b''
+        while True:
+            try:
+                #使用select，不断的读取数据，直到没有多余的数据了，超时返回。
+                readable,w,e= select.select([self.channel],[],[],timeout)
+                if self.channel in readable:
+                    data = self.channel.recv(1024)
+                else:
+                    sys.stdout.write(data.decode())
+                    sys.stdout.flush()
+                    return data.decode()
+            except TimeoutError:
+                sys.stdout.write(data.decode())
+                sys.stdout.flush()
+                return data.decode
+    #关闭客户端
+    def close(self):
+        self.channel.close()
+        self.trans.close()
+
+host='host'
+port=22#your port
+user='root'
+pwd='pass'
+
+ssh = sshClient(host,port,user,pwd)
+response = ssh.recvResponse(1)
+response = ssh.sendCmd("ls\n")
+ssh.sendCmd("cd /home\n")
+response = ssh.recvResponse(1)
+ssh.sendCmd("ls\n")
+response = ssh.recvResponse(1)
+
+ssh.close()