chore: release v3.4.1.3

fix: 下载 QQ 图片时的400问题

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -1,61 +1,36 @@
 name: 漏洞反馈
-description: 报错或漏洞请使用这个模板创建，不使用此模板创建的异常、漏洞相关issue将被直接关闭
+description: 报错或漏洞请使用这个模板创建，不使用此模板创建的异常、漏洞相关issue将被直接关闭。由于自己操作不当/不甚了解所用技术栈引起的网络连接问题恕无法解决，请勿提 issue。容器间网络连接问题，参考文档 https://docs.langbot.app/deploy/network-details.html  
 title: "[Bug]: "
 labels: ["bug?"]
 body:
-  - type: dropdown
-    attributes:
-      label: 部署方式
-      description: "主程序使用的部署方式"
-      options:
-        - 手动部署
-        - 安装器部署
-        - 一键安装包部署
-        - Docker部署
-    validations:
-      required: true
   - type: dropdown
     attributes:
       label: 消息平台适配器
-      description: "连接QQ使用的框架"
+      description: "接入的消息平台类型"
       options:
-        - yiri-mirai（Mirai）
+        - 其他（或暂未使用）
         - Nakuru（go-cqhttp）
         - aiocqhttp（使用 OneBot 协议接入的）
         - qq-botpy（QQ官方API）
-    validations:
-      required: false
-  - type: input
-    attributes:
-      label: 系统环境
-      description: 操作系统、系统架构、**主机地理位置**，地理位置最好写清楚，涉及网络问题排查。
-      placeholder: 例如： CentOS x64 中国大陆、Windows11 美国
     validations:
       required: true
   - type: input
     attributes:
-      label: Python环境
-      description: 运行程序的Python版本
-      placeholder: 例如： Python 3.10
-    validations:
-      required: true
-  - type: input
-    attributes:
-      label: QChatGPT版本
-      description: QChatGPT版本号
-      placeholder: 例如： v2.6.0，可以使用`!version`命令查看
+      label: 运行环境
+      description: LangBot 版本、操作系统、系统架构、**Python版本**、**主机地理位置**
+      placeholder: 例如：v3.3.0、CentOS x64 Python 3.10.3、Docker 的系统直接写 Docker 就行
     validations:
       required: true
   - type: textarea
     attributes:
       label: 异常情况
-      description: 完整描述异常情况，什么时候发生的、发生了什么，尽可能详细
+      description: 完整描述异常情况，什么时候发生的、发生了什么。**请附带日志信息。** 
     validations:
       required: true
   - type: textarea
     attributes:
-      label: 日志信息
-      description: 请提供完整的 **登录框架 和 QChatGPT控制台**的相关日志信息（若有），不提供日志信息**无法**为您排查问题，请尽可能详细
+      label: 复现步骤
+      description: 如何重现这个问题，越详细越好
     validations:
       required: false
   - type: textarea

.github/dependabot.yml

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

.github/pull_request_template.md

@@ -2,24 +2,19 @@
 
 实现/解决/优化的内容: 
 
-### 事务
+## 检查清单
 
-- [ ] 已阅读仓库[贡献指引](https://github.com/RockChinQ/QChatGPT/blob/master/CONTRIBUTING.md)
-- [ ] 已与维护者在issues或其他平台沟通此PR大致内容
+### PR 作者完成
 
-## 以下内容可在起草PR后、合并PR前逐步完成
+*请在方括号间写`x`以打勾
 
-### 功能
+- [ ] 阅读仓库[贡献指引](https://github.com/RockChinQ/LangBot/blob/master/CONTRIBUTING.md)了吗？
+- [ ] 与项目所有者沟通过了吗？
+- [ ] 我确定已自行测试所作的更改，确保功能符合预期。
 
-- [ ] 已编写完善的配置文件字段说明（若有新增）
-- [ ] 已编写面向用户的新功能说明（若有必要）
-- [ ] 已测试新功能或更改
+### 项目所有者完成
 
-### 兼容性
-
-- [ ] 已处理版本兼容性
-- [ ] 已处理插件兼容问题
-
-### 风险
-
-可能导致或已知的问题: 
+- [ ] 相关 issues 链接了吗？
+- [ ] 配置项写好了吗？迁移写好了吗？生效了吗？
+- [ ] 依赖写到 requirements.txt 和 core/bootutils/deps.py 了吗
+- [ ] 文档编写了吗？

.github/workflows/build-dev-image.yaml

@@ -0,0 +1,24 @@
+name: Build Dev Image
+
+on:
+  push:
+  workflow_dispatch:
+
+jobs:
+  build-dev-image:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Generate Tag
+        id: generate_tag
+        run: |
+          # 获取分支名称，把/替换为-
+          echo ${{ github.ref }} | sed 's/refs\/heads\///g' | sed 's/\//-/g'
+          echo ::set-output name=tag::$(echo ${{ github.ref }} | sed 's/refs\/heads\///g' | sed 's/\//-/g')
+      - name: Login to Registry
+        run: docker login --username=${{ secrets.DOCKER_USERNAME }} --password ${{ secrets.DOCKER_PASSWORD }}
+      - name: Build Docker Image
+        run: |
+          docker buildx create --name mybuilder --use
+          docker build -t rockchin/langbot:${{ steps.generate_tag.outputs.tag }} . --push

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

@@ -19,12 +19,6 @@ jobs:
             export GITHUB_REF=${{ github.ref }}
             echo $GITHUB_REF
           fi
-      # - name: Check GITHUB_REF env
-      #   run: echo $GITHUB_REF
-      # - name: Get version  # 在 GitHub Actions 运行环境
-      #   id: get_version
-      #   if: (startsWith(env.GITHUB_REF, 'refs/tags/')||startsWith(github.ref, 'refs/tags/')) && startsWith(github.repository, 'RockChinQ/QChatGPT')
-      #   run: export GITHUB_REF=${GITHUB_REF/refs\/tags\//}
       - name: Check version
         id: check_version
         run: |
@@ -44,5 +38,5 @@ jobs:
         run: docker login --username=${{ secrets.DOCKER_USERNAME }} --password ${{ secrets.DOCKER_PASSWORD }}
       - name: Create Buildx
         run: docker buildx create --name mybuilder --use
-      - name: Build  # image name: rockchin/qchatgpt:<VERSION>
-        run: docker buildx build --platform linux/arm64,linux/amd64 -t rockchin/qchatgpt:${{ steps.check_version.outputs.version }} -t rockchin/qchatgpt:latest . --push
+      - name: Build  # image name: rockchin/langbot:<VERSION>
+        run: docker buildx build --platform linux/arm64,linux/amd64 -t rockchin/langbot:${{ steps.check_version.outputs.version }} -t rockchin/langbot:latest . --push

.github/workflows/build-release-artifacts.yaml

@@ -0,0 +1,52 @@
+name: Build Release Artifacts
+
+on:
+  workflow_dispatch:
+  ## 发布release的时候会自动构建
+  release:
+    types: [published]
+
+jobs:
+  build-artifacts:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Check version
+        id: check_version
+        run: |
+          echo $GITHUB_REF
+          # 如果是tag，则去掉refs/tags/前缀
+          if [[ $GITHUB_REF == refs/tags/* ]]; then
+            echo "It's a tag"
+            echo $GITHUB_REF
+            echo $GITHUB_REF | awk -F '/' '{print $3}'
+            echo ::set-output name=version::$(echo $GITHUB_REF | awk -F '/' '{print $3}')
+          else
+            echo "It's not a tag"
+            echo $GITHUB_REF
+            echo ::set-output name=version::${GITHUB_REF}
+          fi
+
+      - name: Make Temp Directory
+        run: |
+          mkdir -p /tmp/langbot_build_web
+          cp -r . /tmp/langbot_build_web
+      - name: Setup Node
+        uses: actions/setup-node@v2
+        with:
+          node-version: '22'
+      - name: Build Web
+        run: |
+          cd /tmp/langbot_build_web/web
+          npm install
+          npm run build
+      - name: Package Output
+        run: |
+          cp -r /tmp/langbot_build_web/web/dist ./web
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: langbot-${{ steps.check_version.outputs.version }}-all
+          path: .

.github/workflows/sync-wiki.yml

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

.gitignore

@@ -3,9 +3,10 @@
 __pycache__/
 database.db
 qchatgpt.log
+langbot.log
 /banlist.py
-plugins/
-!plugins/__init__.py
+/plugins/
+!/plugins/__init__.py
 /revcfg.py
 prompts/
 logs/
@@ -34,4 +35,5 @@ bard.json
 res/instance_id.json
 .DS_Store
 /data
-botpy.log*
+botpy.log*
+/poc

Dockerfile

@@ -1,8 +1,19 @@
+FROM node:22-alpine AS node
+
+WORKDIR /app
+
+COPY web ./web
+
+RUN cd web && npm install && npm run build
+
 FROM python:3.10.13-slim
+
 WORKDIR /app
 
 COPY . .
 
+COPY --from=node /app/web/dist ./web/dist
+
 RUN apt update \
     && apt install gcc -y \
     && python -m pip install -r requirements.txt \

README.md

@@ -1,46 +1,79 @@
 
 <p align="center">
-<img src="https://qchatgpt.rockchin.top/logo.png" alt="QChatGPT" width="180" />
-</p>
-<div align="center">
+<img src="https://docs.langbot.app/social.png" alt="LangBot"/>
 
-# QChatGPT
+<div align="center">
 
 <a href="https://trendshift.io/repositories/6187" target="_blank"><img src="https://trendshift.io/api/badge/repositories/6187" alt="RockChinQ%2FQChatGPT | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
 
-[![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>
- ![Dynamic JSON Badge](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.qchatgpt.rockchin.top%2Fapi%2Fv2%2Fview%2Frealtime%2Fcount_query%3Fminute%3D10080&query=%24.data.count&label=%E4%BD%BF%E7%94%A8%E9%87%8F%EF%BC%887%E6%97%A5%EF%BC%89)
-![Wakapi Count](https://wakapi.rockchin.top/api/badge/RockChinQ/interval:any/project:QChatGPT)
+<a href="https://docs.langbot.app">项目主页</a> ｜
+<a href="https://docs.langbot.app/insight/intro.htmll">功能介绍</a> ｜
+<a href="https://docs.langbot.app/insight/guide.html">部署文档</a> ｜
+<a href="https://docs.langbot.app/usage/faq.html">常见问题</a> ｜
+<a href="https://docs.langbot.app/plugin/plugin-intro.html">插件介绍</a> ｜
+<a href="https://github.com/RockChinQ/LangBot/issues/new?assignees=&labels=%E7%8B%AC%E7%AB%8B%E6%8F%92%E4%BB%B6&projects=&template=submit-plugin.yml&title=%5BPlugin%5D%3A+%E8%AF%B7%E6%B1%82%E7%99%BB%E8%AE%B0%E6%96%B0%E6%8F%92%E4%BB%B6">提交插件</a>
+
+
+<div align="center">
+😎高稳定、🧩支持扩展、🦄多模态 - 基于大语言模型的即时通讯机器人平台🤖  
+</div>
+
 <br/>
-<img src="https://img.shields.io/badge/python-3.10 | 3.11 | 3.12-blue.svg" alt="python">
+
 <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">
+<img alt="Static Badge" src="https://img.shields.io/badge/%E5%AE%98%E6%96%B9%E7%BE%A4-195992197-green">
 </a>
 <a href="https://qm.qq.com/q/PClALFK242">
-<img alt="Static Badge" src="https://img.shields.io/badge/%E7%A4%BE%E5%8C%BA%E7%BE%A4-619154800-purple">
+<img alt="Static Badge" src="https://img.shields.io/badge/%E7%A4%BE%E5%8C%BA%E7%BE%A4-619154800-green">
 </a>
-<a href="https://codecov.io/gh/RockChinQ/QChatGPT" > 
- <img src="https://codecov.io/gh/RockChinQ/QChatGPT/graph/badge.svg?token=pjxYIL2kbC"/> 
- </a>
- 
-## 使用文档
+<br/>
 
-<a href="https://qchatgpt.rockchin.top">项目主页</a> ｜
-<a href="https://qchatgpt.rockchin.top/posts/feature.html">功能介绍</a> ｜
-<a href="https://qchatgpt.rockchin.top/posts/deploy/">部署文档</a> ｜
-<a href="https://qchatgpt.rockchin.top/posts/error/">常见问题</a> ｜
-<a href="https://qchatgpt.rockchin.top/posts/plugin/intro.html">插件介绍</a> ｜
-<a href="https://github.com/RockChinQ/QChatGPT/issues/new?assignees=&labels=%E7%8B%AC%E7%AB%8B%E6%8F%92%E4%BB%B6&projects=&template=submit-plugin.yml&title=%5BPlugin%5D%3A+%E8%AF%B7%E6%B1%82%E7%99%BB%E8%AE%B0%E6%96%B0%E6%8F%92%E4%BB%B6">提交插件</a>
-
-## 相关链接
-
-<a href="https://github.com/RockChinQ/qcg-installer">安装器源码</a> ｜
-<a href="https://github.com/RockChinQ/qcg-tester">测试工程源码</a> ｜
-<a href="https://github.com/RockChinQ/qcg-center">遥测服务端源码</a> ｜
-<a href="https://github.com/the-lazy-me/QChatGPT-Wiki">官方文档储存库</a>
-
-<img alt="回复效果（带有联网插件）" src="https://qchatgpt.rockchin.top/assets/image/QChatGPT-0516.png" width="500px"/>
+[![GitHub release (latest by date)](https://img.shields.io/github/v/release/RockChinQ/LangBot)](https://github.com/RockChinQ/LangBot/releases/latest)
+ ![Dynamic JSON Badge](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.qchatgpt.rockchin.top%2Fapi%2Fv2%2Fview%2Frealtime%2Fcount_query%3Fminute%3D10080&query=%24.data.count&label=%E4%BD%BF%E7%94%A8%E9%87%8F%EF%BC%887%E6%97%A5%EF%BC%89)
+<img src="https://img.shields.io/badge/python-3.10 | 3.11 | 3.12-blue.svg" alt="python">
 </div>
+
+</p>
+
+## ✨ Features
+
+- 💬 大模型对话、Agent：支持多种大模型，适配群聊和私聊；具有多轮对话、工具调用、多模态能力，并深度适配 [Dify](https://dify.ai)。目前支持 QQ、QQ频道，后续还将支持微信、WhatsApp、Discord等平台。
+- 🛠️ 高稳定性、功能完备：原生支持访问控制、限速、敏感词过滤等机制；配置简单，支持多种部署方式。
+- 🧩 插件扩展、活跃社区：支持事件驱动、组件扩展等插件机制；丰富生态，目前已有数十个[插件](https://docs.langbot.app/plugin/plugin-intro.html)
+- 😻 [New] Web 管理面板：支持通过浏览器管理 LangBot 实例，具体支持功能，查看[文档](https://docs.langbot.app/webui/intro.html)
+
+## 📦 开始使用
+
+> [!IMPORTANT]
+>
+> 在您开始任何方式部署之前，请务必阅读[新手指引](https://docs.langbot.app/insight/guide.html)。
+
+#### Docker Compose 部署
+
+适合熟悉 Docker 的用户，查看文档[Docker 部署](https://docs.langbot.app/deploy/langbot/docker.html)。
+
+#### 宝塔面板部署
+
+已上架宝塔面板，若您已安装宝塔面板，可以根据[文档](https://docs.langbot.app/deploy/langbot/one-click/bt.html)使用。
+
+#### Zeabur 云部署
+
+社区贡献的 Zeabur 模板。
+
+[![Deploy on Zeabur](https://zeabur.com/button.svg)](https://zeabur.com/zh-CN/templates/ZKTBDH)
+
+#### Railway 云部署
+
+[![Deploy on Railway](https://railway.com/button.svg)](https://railway.app/template/yRrAyL?referralCode=vogKPF)
+
+#### 手动部署
+
+直接使用发行版运行，查看文档[手动部署](https://docs.langbot.app/deploy/langbot/manual.html)。
+
+## 📸 效果展示
+
+<img alt="回复效果（带有联网插件）" src="https://docs.langbot.app/QChatGPT-0516.png" width="500px"/>
+
+- WebUI Demo: https://demo.langbot.dev/
+    - 登录信息：邮箱：`demo@langbot.app` 密码：`langbot123456`
+    - 注意：仅展示webui效果，公开环境，请不要在其中填入您的任何敏感信息。

docker-compose.yaml

@@ -1,10 +1,14 @@
 version: "3"
 
 services:
-  qchatgpt:
-    image: rockchin/qchatgpt:latest
+  langbot:
+    image: rockchin/langbot:latest
+    container_name: langbot
     volumes:
       - ./data:/app/data
       - ./plugins:/app/plugins
     restart: on-failure
-    # 根据具体环境配置网络
+    ports:
+      - 5300:5300  # 供 WebUI 使用
+      - 2280-2290:2280-2290  # 供消息平台适配器方向连接
+    # 根据具体环境配置网络

libs/LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

libs/README.md

@@ -0,0 +1,4 @@
+# LangBot/libs
+
+LangBot 项目下的 libs 目录下的所有代码均遵循本目录下的许可证约束。  
+您在使用、修改、分发本目录下的代码时，需要遵守其中包含的条款。

libs/dify_service_api/README.md

@@ -0,0 +1,3 @@
+# Dify Service API Python SDK
+
+这个 SDK 尚不完全支持 Dify Service API 的所有功能。

libs/dify_service_api/__init__.py

@@ -0,0 +1,2 @@
+from .v1 import client
+from .v1 import errors

libs/dify_service_api/test.py

@@ -0,0 +1,44 @@
+from v1 import client
+
+import asyncio
+
+import os
+import json
+
+
+class TestDifyClient:
+    async def test_chat_messages(self):
+        cln = client.AsyncDifyServiceClient(api_key=os.getenv("DIFY_API_KEY"), base_url=os.getenv("DIFY_BASE_URL"))
+
+        async for chunk in cln.chat_messages(inputs={}, query="调用工具查看现在几点？", user="test"):
+            print(json.dumps(chunk, ensure_ascii=False, indent=4))
+
+    async def test_upload_file(self):
+        cln = client.AsyncDifyServiceClient(api_key=os.getenv("DIFY_API_KEY"), base_url=os.getenv("DIFY_BASE_URL"))
+
+        file_bytes = open("img.png", "rb").read()
+
+        print(type(file_bytes))
+
+        file = ("img2.png", file_bytes, "image/png")
+
+        resp = await cln.upload_file(file=file, user="test")
+        print(json.dumps(resp, ensure_ascii=False, indent=4))
+
+    async def test_workflow_run(self):
+        cln = client.AsyncDifyServiceClient(api_key=os.getenv("DIFY_API_KEY"), base_url=os.getenv("DIFY_BASE_URL"))
+
+        # resp = await cln.workflow_run(inputs={}, user="test")
+        # # print(json.dumps(resp, ensure_ascii=False, indent=4))
+        # print(resp)
+        chunks = []
+
+        ignored_events = ['text_chunk']
+        async for chunk in cln.workflow_run(inputs={}, user="test"):
+            if chunk['event'] in ignored_events:
+                continue
+            chunks.append(chunk)
+        print(json.dumps(chunks, ensure_ascii=False, indent=4))
+
+if __name__ == "__main__":
+    asyncio.run(TestDifyClient().test_chat_messages())

libs/dify_service_api/v1/client.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import httpx
+import typing
+import json
+
+from .errors import DifyAPIError
+
+
+class AsyncDifyServiceClient:
+    """Dify Service API 客户端"""
+
+    api_key: str
+    base_url: str
+    
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://api.dify.ai/v1",
+    ) -> None:
+        self.api_key = api_key
+        self.base_url = base_url
+
+    async def chat_messages(
+        self,
+        inputs: dict[str, typing.Any],
+        query: str,
+        user: str,
+        response_mode: str = "streaming",  # 当前不支持 blocking
+        conversation_id: str = "",
+        files: list[dict[str, typing.Any]] = [],
+        timeout: float = 30.0,
+    ) -> typing.AsyncGenerator[dict[str, typing.Any], None]:
+        """发送消息"""
+        if response_mode != "streaming":
+            raise DifyAPIError("当前仅支持 streaming 模式")
+        
+        async with httpx.AsyncClient(
+            base_url=self.base_url,
+            trust_env=True,
+            timeout=timeout,
+        ) as client:
+            async with client.stream(
+                "POST",
+                "/chat-messages",
+                headers={"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"},
+                json={
+                    "inputs": inputs,
+                    "query": query,
+                    "user": user,
+                    "response_mode": response_mode,
+                    "conversation_id": conversation_id,
+                    "files": files,
+                },
+            ) as r:
+                async for chunk in r.aiter_lines():
+                    if r.status_code != 200:
+                        raise DifyAPIError(f"{r.status_code} {chunk}")
+                    if chunk.strip() == "":
+                        continue
+                    if chunk.startswith("data:"):
+                        yield json.loads(chunk[5:])
+        
+    async def workflow_run(
+        self,
+        inputs: dict[str, typing.Any],
+        user: str,
+        response_mode: str = "streaming",  # 当前不支持 blocking
+        files: list[dict[str, typing.Any]] = [],
+        timeout: float = 30.0,
+    ) -> typing.AsyncGenerator[dict[str, typing.Any], None]:
+        """运行工作流"""
+        if response_mode != "streaming":
+            raise DifyAPIError("当前仅支持 streaming 模式")
+        
+        async with httpx.AsyncClient(
+            base_url=self.base_url,
+            trust_env=True,
+            timeout=timeout,
+        ) as client:
+
+            async with client.stream(
+                "POST",
+                "/workflows/run",
+                headers={"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"},
+                json={
+                    "inputs": inputs,
+                    "user": user,
+                    "response_mode": response_mode,
+                    "files": files,
+                },
+            ) as r:
+                async for chunk in r.aiter_lines():
+                    if r.status_code != 200:
+                        raise DifyAPIError(f"{r.status_code} {chunk}")
+                    if chunk.strip() == "":
+                        continue
+                    if chunk.startswith("data:"):
+                        yield json.loads(chunk[5:])
+
+    async def upload_file(
+        self,
+        file: httpx._types.FileTypes,
+        user: str,
+        timeout: float = 30.0,
+    ) -> str:
+        """上传文件"""
+        async with httpx.AsyncClient(
+            base_url=self.base_url,
+            trust_env=True,
+            timeout=timeout,
+        ) as client:
+            # multipart/form-data
+            response = await client.post(
+                "/files/upload",
+                headers={"Authorization": f"Bearer {self.api_key}"},
+                files={
+                    "file": file,
+                    "user": (None, user),
+                },
+            )
+
+            if response.status_code != 201:
+                raise DifyAPIError(f"{response.status_code} {response.text}")
+
+            return response.json()

libs/dify_service_api/v1/client_test.py

@@ -0,0 +1,17 @@
+from . import client
+
+import asyncio
+
+import os
+
+
+class TestDifyClient:
+    async def test_chat_messages(self):
+        cln = client.DifyClient(api_key=os.getenv("DIFY_API_KEY"))
+
+        resp = await cln.chat_messages(inputs={}, query="Who are you?", user_id="test")
+        print(resp)
+
+
+if __name__ == "__main__":
+    asyncio.run(TestDifyClient().test_chat_messages())

libs/dify_service_api/v1/errors.py

@@ -0,0 +1,6 @@
+class DifyAPIError(Exception):
+    """Dify API 请求失败"""
+
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(self.message)

main.py

@@ -1,19 +1,23 @@
-# QChatGPT 终端启动入口
+# LangBot 终端启动入口
 # 在此层级解决依赖项检查。
-# QChatGPT/main.py
+# LangBot/main.py
 
 asciiart = r"""
-  ___   ___ _         _    ___ ___ _____ 
- / _ \ / __| |_  __ _| |_ / __| _ \_   _|
-| (_) | (__| ' \/ _` |  _| (_ |  _/ | |  
- \__\_\\___|_||_\__,_|\__|\___|_|   |_|  
+ _                   ___      _   
+| |   __ _ _ _  __ _| _ ) ___| |_ 
+| |__/ _` | ' \/ _` | _ \/ _ \  _|
+|____\__,_|_||_\__, |___/\___/\__|
+               |___/              
 
-⭐️开源地址: https://github.com/RockChinQ/QChatGPT
-📖文档地址: https://q.rkcn.top
+⭐️开源地址: https://github.com/RockChinQ/LangBot
+📖文档地址: https://docs.langbot.app
 """
 
 
-async def main_entry():
+import asyncio
+
+
+async def main_entry(loop: asyncio.AbstractEventLoop):
     print(asciiart)
 
     import sys
@@ -32,6 +36,12 @@ async def main_entry():
         print("已自动安装缺失的依赖包，请重启程序。")
         sys.exit(0)
 
+    # 检查pydantic版本，如果没有 pydantic.v1，则把 pydantic 映射为 v1
+    import pydantic.version
+    if pydantic.version.VERSION < '2.0':
+        import pydantic
+        sys.modules['pydantic.v1'] = pydantic
+
     # 检查配置文件
 
     from pkg.core.bootutils import files
@@ -46,13 +56,20 @@ async def main_entry():
         sys.exit(0)
 
     from pkg.core import boot
-    await boot.main()
+    await boot.main(loop)
 
 
 if __name__ == '__main__':
     import os
+    import sys
 
-    # 检查本目录是否有main.py，且包含QChatGPT字符串
+    # 必须大于 3.10.1
+    if sys.version_info < (3, 10, 1):
+        print("需要 Python 3.10.1 及以上版本，当前 Python 版本为：", sys.version)
+        input("按任意键退出...")
+        exit(1)
+
+    # 检查本目录是否有main.py，且包含LangBot字符串
     invalid_pwd = False
 
     if not os.path.exists('main.py'):
@@ -60,13 +77,13 @@ if __name__ == '__main__':
     else:
         with open('main.py', 'r', encoding='utf-8') as f:
             content = f.read()
-            if "QChatGPT/main.py" not in content:
+            if "LangBot/main.py" not in content:
                 invalid_pwd = True
     if invalid_pwd:
-        print("请在QChatGPT项目根目录下以命令形式运行此程序。")
+        print("请在 LangBot 项目根目录下以命令形式运行此程序。")
         input("按任意键退出...")
-        exit(0)
+        exit(1)
 
-    import asyncio
+    loop = asyncio.new_event_loop()
 
-    asyncio.run(main_entry())
+    loop.run_until_complete(main_entry(loop))

pkg/api/http/controller/group.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import abc
+import typing
+import enum
+import quart
+from quart.typing import RouteCallable
+
+from ....core import app
+
+
+preregistered_groups: list[type[RouterGroup]] = []
+"""RouterGroup 的预注册列表"""
+
+def group_class(name: str, path: str) -> None:
+    """注册一个 RouterGroup"""
+
+    def decorator(cls: typing.Type[RouterGroup]) -> typing.Type[RouterGroup]:
+        cls.name = name
+        cls.path = path
+        preregistered_groups.append(cls)
+        return cls
+
+    return decorator
+
+
+class AuthType(enum.Enum):
+    """认证类型"""
+    NONE = 'none'
+    USER_TOKEN = 'user-token'
+
+
+class RouterGroup(abc.ABC):
+
+    name: str
+
+    path: str
+
+    ap: app.Application
+
+    quart_app: quart.Quart
+
+    def __init__(self, ap: app.Application, quart_app: quart.Quart) -> None:
+        self.ap = ap
+        self.quart_app = quart_app
+
+    @abc.abstractmethod
+    async def initialize(self) -> None:
+        pass
+
+    def route(self, rule: str, auth_type: AuthType = AuthType.USER_TOKEN, **options: typing.Any) -> typing.Callable[[RouteCallable], RouteCallable]:  # decorator
+        """注册一个路由"""
+        def decorator(f: RouteCallable) -> RouteCallable:
+            nonlocal rule
+            rule = self.path + rule
+
+            async def handler_error(*args, **kwargs):
+
+                if auth_type == AuthType.USER_TOKEN:
+                    # 从Authorization头中获取token
+                    token = quart.request.headers.get('Authorization', '').replace('Bearer ', '')
+
+                    if not token:
+                        return self.http_status(401, -1, '未提供有效的用户令牌')
+
+                    try:
+                        user_email = await self.ap.user_service.verify_jwt_token(token)
+
+                        # 检查f是否接受user_email参数
+                        if 'user_email' in f.__code__.co_varnames:
+                            kwargs['user_email'] = user_email
+                    except Exception as e:
+                        return self.http_status(401, -1, str(e))
+
+                try:
+                    return await f(*args, **kwargs)
+                except Exception as e:  # 自动 500
+                    return self.http_status(500, -2, str(e))
+                
+            new_f = handler_error
+            new_f.__name__ = (self.name + rule).replace('/', '__')
+            new_f.__doc__ = f.__doc__
+
+            self.quart_app.route(rule, **options)(new_f)
+            return f
+
+        return decorator
+
+    def success(self, data: typing.Any = None) -> quart.Response:
+        """返回一个 200 响应"""
+        return quart.jsonify({
+            'code': 0,
+            'msg': 'ok',
+            'data': data,
+        })
+    
+    def fail(self, code: int, msg: str) -> quart.Response:
+        """返回一个异常响应"""
+
+        return quart.jsonify({
+            'code': code,
+            'msg': msg,
+        })
+    
+    def http_status(self, status: int, code: int, msg: str) -> quart.Response:
+        """返回一个指定状态码的响应"""
+        return self.fail(code, msg), status

pkg/api/http/controller/groups/logs.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import traceback
+
+import quart
+
+from .....core import app
+from .. import group
+
+
+@group.group_class('logs', '/api/v1/logs')
+class LogsRouterGroup(group.RouterGroup):
+    
+    async def initialize(self) -> None:
+        @self.route('', methods=['GET'])
+        async def _() -> str:
+
+            start_page_number = int(quart.request.args.get('start_page_number', 0))
+            start_offset = int(quart.request.args.get('start_offset', 0))
+
+            logs_str, end_page_number, end_offset = self.ap.log_cache.get_log_by_pointer(
+                start_page_number=start_page_number,
+                start_offset=start_offset
+            )
+
+            return self.success(
+                data={
+                    "logs": logs_str,
+                    "end_page_number": end_page_number,
+                    "end_offset": end_offset
+                }
+            )

pkg/api/http/controller/groups/plugins.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+
+import traceback
+
+import quart
+
+from .....core import app, taskmgr
+from .. import group
+
+
+@group.group_class('plugins', '/api/v1/plugins')
+class PluginsRouterGroup(group.RouterGroup):
+
+    async def initialize(self) -> None:
+        @self.route('', methods=['GET'])
+        async def _() -> str:
+            plugins = self.ap.plugin_mgr.plugins()
+
+            plugins_data = [plugin.model_dump() for plugin in plugins]
+
+            return self.success(data={
+                'plugins': plugins_data
+            })
+        
+        @self.route('/<author>/<plugin_name>/toggle', methods=['PUT'])
+        async def _(author: str, plugin_name: str) -> str:
+            data = await quart.request.json
+            target_enabled = data.get('target_enabled')
+            await self.ap.plugin_mgr.update_plugin_switch(plugin_name, target_enabled)
+            return self.success()
+        
+        @self.route('/<author>/<plugin_name>/update', methods=['POST'])
+        async def _(author: str, plugin_name: str) -> str:
+            ctx = taskmgr.TaskContext.new()
+            wrapper = self.ap.task_mgr.create_user_task(
+                self.ap.plugin_mgr.update_plugin(plugin_name, task_context=ctx),
+                kind="plugin-operation",
+                name=f"plugin-update-{plugin_name}",
+                label=f"更新插件 {plugin_name}",
+                context=ctx
+            )
+            return self.success(data={
+                'task_id': wrapper.id
+            })
+        
+        @self.route('/<author>/<plugin_name>', methods=['DELETE'])
+        async def _(author: str, plugin_name: str) -> str:
+            ctx = taskmgr.TaskContext.new()
+            wrapper = self.ap.task_mgr.create_user_task(
+                self.ap.plugin_mgr.uninstall_plugin(plugin_name, task_context=ctx),
+                kind="plugin-operation",
+                name=f'plugin-remove-{plugin_name}',
+                label=f'删除插件 {plugin_name}',
+                context=ctx
+            )
+
+            return self.success(data={
+                'task_id': wrapper.id
+            })
+
+        @self.route('/reorder', methods=['PUT'])
+        async def _() -> str:
+            data = await quart.request.json
+            await self.ap.plugin_mgr.reorder_plugins(data.get('plugins'))
+            return self.success()
+        
+        @self.route('/install/github', methods=['POST'])
+        async def _() -> str:
+            data = await quart.request.json
+            
+            ctx = taskmgr.TaskContext.new()
+            short_source_str = data['source'][-8:]
+            wrapper = self.ap.task_mgr.create_user_task(
+                self.ap.plugin_mgr.install_plugin(data['source'], task_context=ctx),
+                kind="plugin-operation",
+                name=f'plugin-install-github',
+                label=f'安装插件 ...{short_source_str}',
+                context=ctx
+            )
+
+            return self.success(data={
+                'task_id': wrapper.id
+            })

pkg/api/http/controller/groups/settings.py

@@ -0,0 +1,62 @@
+import quart
+
+from .....core import app
+from .. import group
+
+
+@group.group_class('settings', '/api/v1/settings')
+class SettingsRouterGroup(group.RouterGroup):
+    
+    async def initialize(self) -> None:
+        
+        @self.route('', methods=['GET'])
+        async def _() -> str:
+            return self.success(
+                data={
+                    "managers": [
+                        {
+                            "name": m.name,
+                            "description": m.description,
+                        }
+                        for m in self.ap.settings_mgr.get_manager_list()
+                    ]
+                }
+            )
+        
+        @self.route('/<manager_name>', methods=['GET'])
+        async def _(manager_name: str) -> str:
+
+            manager = self.ap.settings_mgr.get_manager(manager_name)
+
+            if manager is None:
+                return self.fail(1, '配置管理器不存在')
+
+            return self.success(
+                data={
+                    "manager": {
+                        "name": manager.name,
+                        "description": manager.description,
+                        "schema": manager.schema,
+                        "file": manager.file.config_file_name,
+                        "data": manager.data,
+                        "doc_link": manager.doc_link
+                    }
+                }
+            )
+        
+        @self.route('/<manager_name>/data', methods=['PUT'])
+        async def _(manager_name: str) -> str:
+            data = await quart.request.json
+            manager = self.ap.settings_mgr.get_manager(manager_name)
+
+            if manager is None:
+                return self.fail(code=1, msg='配置管理器不存在')
+
+            # manager.data = data['data']
+            for k, v in data['data'].items():
+                manager.data[k] = v
+
+            await manager.dump_config()
+            return self.success(data={
+                "data": manager.data
+            })

pkg/api/http/controller/groups/stats.py

@@ -0,0 +1,23 @@
+import quart
+import asyncio
+
+from .....core import app, taskmgr
+from .. import group
+
+
+@group.group_class('stats', '/api/v1/stats')
+class StatsRouterGroup(group.RouterGroup):
+    
+    async def initialize(self) -> None:
+        @self.route('/basic', methods=['GET'])
+        async def _() -> str:
+
+            conv_count = 0
+            for session in self.ap.sess_mgr.session_list:
+                conv_count += len(session.conversations if session.conversations is not None else [])
+
+            return self.success(data={
+                'active_session_count': len(self.ap.sess_mgr.session_list),
+                'conversation_count': conv_count,
+                'query_count': self.ap.query_pool.query_id_counter,
+            })

pkg/api/http/controller/groups/system.py

@@ -0,0 +1,63 @@
+import quart
+import asyncio
+
+from .....core import app, taskmgr
+from .. import group
+from .....utils import constants
+
+
+@group.group_class('system', '/api/v1/system')
+class SystemRouterGroup(group.RouterGroup):
+    
+    async def initialize(self) -> None:
+        @self.route('/info', methods=['GET'], auth_type=group.AuthType.NONE)
+        async def _() -> str:
+            return self.success(
+                data={
+                    "version": constants.semantic_version,
+                    "debug": constants.debug_mode,
+                    "enabled_platform_count": len(self.ap.platform_mgr.adapters)
+                }
+            )
+
+        @self.route('/tasks', methods=['GET'])
+        async def _() -> str:
+            task_type = quart.request.args.get("type")
+
+            if task_type == '':
+                task_type = None
+
+            return self.success(
+                data=self.ap.task_mgr.get_tasks_dict(task_type)
+            )
+        
+        @self.route('/tasks/<task_id>', methods=['GET'])
+        async def _(task_id: str) -> str:
+            task = self.ap.task_mgr.get_task_by_id(int(task_id))
+
+            if task is None:
+                return self.http_status(404, 404, "Task not found")
+            
+            return self.success(data=task.to_dict())
+        
+        @self.route('/reload', methods=['POST'])
+        async def _() -> str:
+            json_data = await quart.request.json
+
+            scope = json_data.get("scope")
+
+            await self.ap.reload(
+                scope=scope
+            )
+            return self.success()
+
+        @self.route('/_debug/exec', methods=['POST'])
+        async def _() -> str:
+            if not constants.debug_mode:
+                return self.http_status(403, 403, "Forbidden")
+            
+            py_code = await quart.request.data
+
+            ap = self.ap
+
+            return self.success(data=exec(py_code, {"ap": ap}))

pkg/api/http/controller/groups/user.py

@@ -0,0 +1,47 @@
+import quart
+import sqlalchemy
+import argon2
+
+from .. import group
+from .....persistence.entities import user
+
+
+@group.group_class('user', '/api/v1/user')
+class UserRouterGroup(group.RouterGroup):
+    
+    async def initialize(self) -> None:
+        @self.route('/init', methods=['GET', 'POST'], auth_type=group.AuthType.NONE)
+        async def _() -> str:
+            if quart.request.method == 'GET':
+                return self.success(data={
+                    'initialized': await self.ap.user_service.is_initialized()
+                })
+            
+            if await self.ap.user_service.is_initialized():
+                return self.fail(1, '系统已初始化')
+
+            json_data = await quart.request.json
+
+            user_email = json_data['user']
+            password = json_data['password']
+
+            await self.ap.user_service.create_user(user_email, password)
+
+            return self.success()
+        
+        @self.route('/auth', methods=['POST'], auth_type=group.AuthType.NONE)
+        async def _() -> str:
+            json_data = await quart.request.json
+
+            try:
+                token = await self.ap.user_service.authenticate(json_data['user'], json_data['password'])
+            except argon2.exceptions.VerifyMismatchError:
+                return self.fail(1, '用户名或密码错误')
+
+            return self.success(data={
+                'token': token
+            })
+
+        @self.route('/check-token', methods=['GET'])
+        async def _() -> str:
+            return self.success()

pkg/api/http/controller/main.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import asyncio
+import os
+
+import quart
+import quart_cors
+
+from ....core import app, entities as core_entities
+from .groups import logs, system, settings, plugins, stats, user
+from . import group
+
+
+class HTTPController:
+
+    ap: app.Application
+
+    quart_app: quart.Quart
+
+    def __init__(self, ap: app.Application) -> None:
+        self.ap = ap
+        self.quart_app = quart.Quart(__name__)
+        quart_cors.cors(self.quart_app, allow_origin="*")
+
+    async def initialize(self) -> None:
+        await self.register_routes()
+
+    async def run(self) -> None:
+        if self.ap.system_cfg.data["http-api"]["enable"]:
+
+            async def shutdown_trigger_placeholder():
+                while True:
+                    await asyncio.sleep(1)
+
+            async def exception_handler(*args, **kwargs):
+                try:
+                    await self.quart_app.run_task(
+                        *args, **kwargs
+                    )
+                except Exception as e:
+                    self.ap.logger.error(f"启动 HTTP 服务失败： {e}")
+
+            self.ap.task_mgr.create_task(
+                exception_handler(
+                    host=self.ap.system_cfg.data["http-api"]["host"],
+                    port=self.ap.system_cfg.data["http-api"]["port"],
+                    shutdown_trigger=shutdown_trigger_placeholder,
+                ),
+                name="http-api-quart",
+                scopes=[core_entities.LifecycleControlScope.APPLICATION],
+            )
+
+            # await asyncio.sleep(5)
+
+    async def register_routes(self) -> None:
+
+        @self.quart_app.route("/healthz")
+        async def healthz():
+            return {"code": 0, "msg": "ok"}
+
+        for g in group.preregistered_groups:
+            ginst = g(self.ap, self.quart_app)
+            await ginst.initialize()
+
+        frontend_path = "web/dist"
+
+        @self.quart_app.route("/")
+        async def index():
+            return await quart.send_from_directory(frontend_path, "index.html")
+
+        @self.quart_app.route("/<path:path>")
+        async def static_file(path: str):
+            return await quart.send_from_directory(frontend_path, path)

pkg/api/http/service/user.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import sqlalchemy
+import argon2
+import jwt
+import datetime
+
+from ....core import app
+from ....persistence.entities import user
+from ....utils import constants
+
+
+class UserService:
+
+    ap: app.Application
+
+    def __init__(self, ap: app.Application) -> None:
+        self.ap = ap
+
+    async def is_initialized(self) -> bool:
+        result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.select(user.User).limit(1)
+        )
+
+        result_list = result.all()
+        return result_list is not None and len(result_list) > 0
+    
+    async def create_user(self, user_email: str, password: str) -> None:
+        ph = argon2.PasswordHasher()
+
+        hashed_password = ph.hash(password)
+
+        await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.insert(user.User).values(
+                user=user_email,
+                password=hashed_password
+            )
+        )
+
+    async def authenticate(self, user_email: str, password: str) -> str | None:
+        result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.select(user.User).where(user.User.user == user_email)
+        )
+
+        result_list = result.all()
+
+        if result_list is None or len(result_list) == 0:
+            raise ValueError('用户不存在')
+
+        user_obj = result_list[0]
+
+        ph = argon2.PasswordHasher()
+
+        ph.verify(user_obj.password, password)
+
+        return await self.generate_jwt_token(user_email)
+
+    async def generate_jwt_token(self, user_email: str) -> str:
+        jwt_secret = self.ap.instance_secret_meta.data['jwt_secret']
+        jwt_expire = self.ap.system_cfg.data['http-api']['jwt-expire']
+
+        payload = {
+            'user': user_email,
+            'iss': 'LangBot-'+constants.edition,
+            'exp': datetime.datetime.now() + datetime.timedelta(seconds=jwt_expire)
+        }
+
+        return jwt.encode(payload, jwt_secret, algorithm='HS256')
+    
+    async def verify_jwt_token(self, token: str) -> str:
+        jwt_secret = self.ap.instance_secret_meta.data['jwt_secret']
+
+        return jwt.decode(token, jwt_secret, algorithms=['HS256'])['user']

pkg/audit/center/apigroup.py

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

pkg/command/entities.py

@@ -2,11 +2,11 @@ from __future__ import annotations
 
 import typing
 
-import pydantic
-import mirai
+import pydantic.v1 as pydantic
 
 from ..core import app, entities as core_entities
 from . import errors, operator
+from ..platform.types import message as platform_message
 
 
 class CommandReturn(pydantic.BaseModel):
@@ -17,7 +17,7 @@ class CommandReturn(pydantic.BaseModel):
     """文本
     """
 
-    image: typing.Optional[mirai.Image] = None
+    image: typing.Optional[platform_message.Image] = None
     """弃用"""
 
     image_url: typing.Optional[str] = None

pkg/command/operators/func.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 from typing import AsyncGenerator
 
 from .. import operator, entities, cmdmgr
+from ...plugin import context as plugin_context
 
 
 @operator.operator_class(name="func", help="查看所有已注册的内容函数", usage='!func')
@@ -9,16 +10,18 @@ class FuncOperator(operator.CommandOperator):
     async def execute(
         self, context: entities.ExecuteContext
     ) -> AsyncGenerator[entities.CommandReturn, None]:
-        reply_str = "当前已加载的内容函数: \n\n"
+        reply_str = "当前已启用的内容函数: \n\n"
 
         index = 1
 
-        all_functions = await self.ap.tool_mgr.get_all_functions()
+        all_functions = await self.ap.tool_mgr.get_all_functions(
+            plugin_enabled=True,
+            plugin_status=plugin_context.RuntimeContainerStatus.INITIALIZED,
+        )
 
         for func in all_functions:
-            reply_str += "{}. {}{}:\n{}\n\n".format(
+            reply_str += "{}. {}:\n{}\n\n".format(
                 index,
-                ("(已禁用) " if not func.enable else ""),
                 func.name,
                 func.description,
             )

pkg/command/operators/plugin.py

@@ -18,7 +18,7 @@ class PluginOperator(operator.CommandOperator):
         context: entities.ExecuteContext
     ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
         
-        plugin_list = self.ap.plugin_mgr.plugins
+        plugin_list = self.ap.plugin_mgr.plugins()
         reply_str = "所有插件({}):\n".format(len(plugin_list))
         idx = 0
         for plugin in plugin_list:
@@ -110,7 +110,7 @@ class PluginUpdateAllOperator(operator.CommandOperator):
         try:
             plugins = [
                 p.plugin_name
-                for p in self.ap.plugin_mgr.plugins
+                for p in self.ap.plugin_mgr.plugins()
             ]
 
             if plugins:
@@ -163,24 +163,6 @@ class PluginDelOperator(operator.CommandOperator):
                 yield entities.CommandReturn(error=errors.CommandError("插件删除失败: "+str(e)))
 
 
-async def update_plugin_status(plugin_name: str, new_status: bool, ap: app.Application):
-    if ap.plugin_mgr.get_plugin_by_name(plugin_name) is not None:
-        for plugin in ap.plugin_mgr.plugins:
-            if plugin.plugin_name == plugin_name:
-                plugin.enabled = new_status
-
-                for func in plugin.content_functions:
-                    func.enable = new_status
-                
-                await ap.plugin_mgr.setting.dump_container_setting(ap.plugin_mgr.plugins)
-
-                break
-
-        return True
-    else:
-        return False
-
-
 @operator.operator_class(
     name="on",
     help="启用插件",
@@ -200,7 +182,7 @@ class PluginEnableOperator(operator.CommandOperator):
             plugin_name = context.crt_params[0]
 
             try:
-                if await update_plugin_status(plugin_name, True, self.ap):
+                if await self.ap.plugin_mgr.update_plugin_switch(plugin_name, True):
                     yield entities.CommandReturn(text="已启用插件: {}".format(plugin_name))
                 else:
                     yield entities.CommandReturn(error=errors.CommandError("插件状态修改失败: 未找到插件 {}".format(plugin_name)))
@@ -228,7 +210,7 @@ class PluginDisableOperator(operator.CommandOperator):
             plugin_name = context.crt_params[0]
 
             try:
-                if await update_plugin_status(plugin_name, False, self.ap):
+                if await self.ap.plugin_mgr.update_plugin_switch(plugin_name, False):
                     yield entities.CommandReturn(text="已禁用插件: {}".format(plugin_name))
                 else:
                     yield entities.CommandReturn(error=errors.CommandError("插件状态修改失败: 未找到插件 {}".format(plugin_name)))

pkg/config/impls/yaml.py

@@ -0,0 +1,59 @@
+import os
+import shutil
+import yaml
+
+from .. import model as file_model
+
+
+class YAMLConfigFile(file_model.ConfigFile):
+    """YAML配置文件"""
+
+    def __init__(
+        self, config_file_name: str, template_file_name: str = None, template_data: dict = None
+    ) -> None:
+        self.config_file_name = config_file_name
+        self.template_file_name = template_file_name
+        self.template_data = template_data
+
+    def exists(self) -> bool:
+        return os.path.exists(self.config_file_name)
+
+    async def create(self):
+        if self.template_file_name is not None:
+            shutil.copyfile(self.template_file_name, self.config_file_name)
+        elif self.template_data is not None:
+            with open(self.config_file_name, "w", encoding="utf-8") as f:
+                yaml.dump(self.template_data, f, indent=4, allow_unicode=True)
+        else:
+            raise ValueError("template_file_name or template_data must be provided")
+
+    async def load(self, completion: bool=True) -> dict:
+
+        if not self.exists():
+            await self.create()
+
+        if self.template_file_name is not None:
+            with open(self.template_file_name, "r", encoding="utf-8") as f:
+                self.template_data = yaml.load(f, Loader=yaml.FullLoader)
+
+        with open(self.config_file_name, "r", encoding="utf-8") as f:
+            try:
+                cfg = yaml.load(f, Loader=yaml.FullLoader)
+            except yaml.YAMLError as e:
+                raise Exception(f"配置文件 {self.config_file_name} 语法错误: {e}")
+
+        if completion:
+
+            for key in self.template_data:
+                if key not in cfg:
+                    cfg[key] = self.template_data[key]
+
+        return cfg
+
+    async def save(self, cfg: dict):
+        with open(self.config_file_name, "w", encoding="utf-8") as f:
+            yaml.dump(cfg, f, indent=4, allow_unicode=True)
+
+    def save_sync(self, cfg: dict):
+        with open(self.config_file_name, "w", encoding="utf-8") as f:
+            yaml.dump(cfg, f, indent=4, allow_unicode=True)

pkg/config/manager.py

@@ -1,14 +1,22 @@
 from __future__ import annotations
 
 from . import model as file_model
-from .impls import pymodule, json as json_file
-
-
-managers: ConfigManager = []
+from .impls import pymodule, json as json_file, yaml as yaml_file
 
 
 class ConfigManager:
     """配置文件管理器"""
+    
+    name: str = None
+    """配置管理器名"""
+
+    description: str = None
+    """配置管理器描述"""
+
+    schema: dict = None
+    """配置文件 schema
+    需要符合 JSON Schema Draft 7 规范
+    """
 
     file: file_model.ConfigFile = None
     """配置文件实例"""
@@ -16,6 +24,9 @@ class ConfigManager:
     data: dict = None
     """配置数据"""
 
+    doc_link: str = None
+    """配置文件文档链接"""
+
     def __init__(self, cfg_file: file_model.ConfigFile) -> None:
         self.file = cfg_file
         self.data = {}
@@ -31,7 +42,16 @@ class ConfigManager:
 
 
 async def load_python_module_config(config_name: str, template_name: str, completion: bool=True) -> ConfigManager:
-    """加载Python模块配置文件"""
+    """加载Python模块配置文件
+    
+    Args:
+        config_name (str): 配置文件名
+        template_name (str): 模板文件名
+        completion (bool): 是否自动补全内存中的配置文件
+
+    Returns:
+        ConfigManager: 配置文件管理器
+    """
     cfg_inst = pymodule.PythonModuleConfigFile(
         config_name,
         template_name
@@ -44,7 +64,14 @@ async def load_python_module_config(config_name: str, template_name: str, comple
 
 
 async def load_json_config(config_name: str, template_name: str=None, template_data: dict=None, completion: bool=True) -> ConfigManager:
-    """加载JSON配置文件"""
+    """加载JSON配置文件
+    
+    Args:
+        config_name (str): 配置文件名
+        template_name (str): 模板文件名
+        template_data (dict): 模板数据
+        completion (bool): 是否自动补全内存中的配置文件
+    """
     cfg_inst = json_file.JSONConfigFile(
         config_name,
         template_name,
@@ -54,4 +81,28 @@ async def load_json_config(config_name: str, template_name: str=None, template_d
     cfg_mgr = ConfigManager(cfg_inst)
     await cfg_mgr.load_config(completion=completion)
 
-    return cfg_mgr
+    return cfg_mgr
+
+
+async def load_yaml_config(config_name: str, template_name: str=None, template_data: dict=None, completion: bool=True) -> ConfigManager:
+    """加载YAML配置文件
+    
+    Args:
+        config_name (str): 配置文件名
+        template_name (str): 模板文件名
+        template_data (dict): 模板数据
+        completion (bool): 是否自动补全内存中的配置文件
+
+    Returns:
+        ConfigManager: 配置文件管理器
+    """
+    cfg_inst = yaml_file.YAMLConfigFile(
+        config_name,
+        template_name,
+        template_data
+    )
+
+    cfg_mgr = ConfigManager(cfg_inst)
+    await cfg_mgr.load_config(completion=completion)
+
+    return cfg_mgr

pkg/config/settings.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from . import manager as config_manager
+from ..core import app
+
+
+class SettingsManager:
+    """设置管理器
+    保存、管理多个配置文件管理器
+    """
+
+    ap: app.Application
+
+    managers: list[config_manager.ConfigManager] = []
+    """配置文件管理器列表"""
+
+    def __init__(self, ap: app.Application) -> None:
+        self.ap = ap
+        self.managers = []
+
+    async def initialize(self) -> None:
+        pass
+
+    def register_manager(
+        self,
+        name: str,
+        description: str,
+        manager: config_manager.ConfigManager,
+        schema: dict=None,
+        doc_link: str=None,
+    ) -> None:
+        """注册配置管理器
+        
+        Args:
+            name (str): 配置管理器名
+            description (str): 配置管理器描述
+            manager (ConfigManager): 配置管理器
+            schema (dict): 配置文件 schema，符合 JSON Schema Draft 7 规范
+        """
+
+        for m in self.managers:
+            if m.name == name:
+                raise ValueError(f'配置管理器名 {name} 已存在')
+
+        manager.name = name
+        manager.description = description
+        manager.schema = schema
+        manager.doc_link = doc_link
+        self.managers.append(manager)
+
+    def get_manager(self, name: str) -> config_manager.ConfigManager | None:
+        """获取配置管理器
+        
+        Args:
+            name (str): 配置管理器名
+        
+        Returns:
+            ConfigManager: 配置管理器
+        """
+
+        for m in self.managers:
+            if m.name == name:
+                return m
+
+        return None
+    
+    def get_manager_list(self) -> list[config_manager.ConfigManager]:
+        """获取配置管理器列表
+        
+        Returns:
+            list[ConfigManager]: 配置管理器列表
+        """
+
+        return self.managers
+    

pkg/core/app.py

@@ -2,7 +2,11 @@ from __future__ import annotations
 
 import logging
 import asyncio
+import threading
 import traceback
+import enum
+import sys
+import os
 
 from ..platform import manager as im_mgr
 from ..provider.session import sessionmgr as llm_session_mgr
@@ -11,17 +15,29 @@ from ..provider.sysprompt import sysprompt as llm_prompt_mgr
 from ..provider.tools import toolmgr as llm_tool_mgr
 from ..provider import runnermgr
 from ..config import manager as config_mgr
+from ..config import settings as settings_mgr
 from ..audit.center import v2 as center_mgr
 from ..command import cmdmgr
 from ..plugin import manager as plugin_mgr
 from ..pipeline import pool
 from ..pipeline import controller, stagemgr
 from ..utils import version as version_mgr, proxy as proxy_mgr, announce as announce_mgr
+from ..persistence import mgr as persistencemgr
+from ..api.http.controller import main as http_controller
+from ..api.http.service import user as user_service
+from ..utils import logcache, ip
+from . import taskmgr
+from . import entities as core_entities
 
 
 class Application:
     """运行时应用对象和上下文"""
 
+    event_loop: asyncio.AbstractEventLoop = None
+
+    # asyncio_tasks: list[asyncio.Task] = []
+    task_mgr: taskmgr.AsyncTaskManager = None
+
     platform_mgr: im_mgr.PlatformManager = None
 
     cmd_mgr: cmdmgr.CommandManager = None
@@ -36,6 +52,8 @@ class Application:
 
     runner_mgr: runnermgr.RunnerManager = None
 
+    settings_mgr: settings_mgr.SettingsManager = None
+
     # ======= 配置管理器 =======
 
     command_cfg: config_mgr.ConfigManager = None
@@ -58,6 +76,8 @@ class Application:
 
     llm_models_meta: config_mgr.ConfigManager = None
 
+    instance_secret_meta: config_mgr.ConfigManager = None
+
     # =========================
 
     ctr_mgr: center_mgr.V2CenterAPI = None
@@ -78,6 +98,16 @@ class Application:
 
     logger: logging.Logger = None
 
+    persistence_mgr: persistencemgr.PersistenceManager = None
+
+    http_ctrl: http_controller.HTTPController = None
+
+    log_cache: logcache.LogCache = None
+
+    # ========= HTTP Services =========
+
+    user_service: user_service.UserService = None
+
     def __init__(self):
         pass
 
@@ -85,34 +115,87 @@ class Application:
         pass
 
     async def run(self):
-        await self.plugin_mgr.initialize_plugins()
-
-        tasks = []
-
         try:
-   
-            tasks = [
-                asyncio.create_task(self.platform_mgr.run()),
-                asyncio.create_task(self.ctrl.run())
-            ]
+            await self.plugin_mgr.initialize_plugins()
+            # 后续可能会允许动态重启其他任务
+            # 故为了防止程序在非 Ctrl-C 情况下退出，这里创建一个不会结束的协程
+            async def never_ending():
+                while True:
+                    await asyncio.sleep(1)
 
-            # 挂信号处理
-
-            import signal
-
-            def signal_handler(sig, frame):
-                for task in tasks:
-                    task.cancel()
-                self.logger.info("程序退出.")
-                exit(0)
-
-            signal.signal(signal.SIGINT, signal_handler)
-
-            await asyncio.gather(*tasks, return_exceptions=True)
+            self.task_mgr.create_task(self.platform_mgr.run(), name="platform-manager", scopes=[core_entities.LifecycleControlScope.APPLICATION, core_entities.LifecycleControlScope.PLATFORM])
+            self.task_mgr.create_task(self.ctrl.run(), name="query-controller", scopes=[core_entities.LifecycleControlScope.APPLICATION])
+            self.task_mgr.create_task(self.http_ctrl.run(), name="http-api-controller", scopes=[core_entities.LifecycleControlScope.APPLICATION])
+            self.task_mgr.create_task(never_ending(), name="never-ending-task", scopes=[core_entities.LifecycleControlScope.APPLICATION])
 
+            await self.print_web_access_info()
+            await self.task_mgr.wait_all()
         except asyncio.CancelledError:
             pass
         except Exception as e:
             self.logger.error(f"应用运行致命异常: {e}")
             self.logger.debug(f"Traceback: {traceback.format_exc()}")
 
+    async def print_web_access_info(self):
+        """打印访问 webui 的提示"""
+
+        if not os.path.exists(os.path.join(".", "web/dist")):
+            self.logger.warning("WebUI 文件缺失，请根据文档获取：https://docs.langbot.app/webui/intro.html")
+            return
+
+        host_ip = "127.0.0.1"
+
+        public_ip = await ip.get_myip()
+
+        port = self.system_cfg.data['http-api']['port']
+
+        tips = f"""
+=======================================
+✨ 您可通过以下方式访问管理面板
+
+🏠 本地地址：http://{host_ip}:{port}/
+🌐 公网地址：http://{public_ip}:{port}/
+
+📌 如果您在容器中运行此程序，请确保容器的 {port} 端口已对外暴露
+🔗 若要使用公网地址访问，请阅读以下须知
+   1. 公网地址仅供参考，请以您的主机公网 IP 为准；
+   2. 要使用公网地址访问，请确保您的主机具有公网 IP，并且系统防火墙已放行 {port} 端口；
+
+🤯 WebUI 仍处于 Beta 测试阶段，如有问题或建议请反馈到 https://github.com/RockChinQ/LangBot/issues
+=======================================
+""".strip()
+        for line in tips.split("\n"):
+            self.logger.info(line)
+
+    async def reload(
+        self,
+        scope: core_entities.LifecycleControlScope,
+    ):
+        match scope:
+            case core_entities.LifecycleControlScope.PLATFORM.value:
+                self.logger.info("执行热重载 scope="+scope)
+                await self.platform_mgr.shutdown()
+
+                self.platform_mgr = im_mgr.PlatformManager(self)
+
+                await self.platform_mgr.initialize()
+
+                self.task_mgr.create_task(self.platform_mgr.run(), name="platform-manager", scopes=[core_entities.LifecycleControlScope.APPLICATION, core_entities.LifecycleControlScope.PLATFORM])
+            case core_entities.LifecycleControlScope.PLUGIN.value:
+                self.logger.info("执行热重载 scope="+scope)
+                await self.plugin_mgr.destroy_plugins()
+
+                # 删除 sys.module 中所有的 plugins/* 下的模块
+                for mod in list(sys.modules.keys()):
+                    if mod.startswith("plugins."):
+                        del sys.modules[mod]
+
+                self.plugin_mgr = plugin_mgr.PluginManager(self)
+                await self.plugin_mgr.initialize()
+
+                await self.plugin_mgr.initialize_plugins()
+
+                await self.plugin_mgr.load_plugins()
+                await self.plugin_mgr.initialize_plugins()
+            case _:
+                pass

pkg/core/boot.py

@@ -1,10 +1,13 @@
 from __future__ import print_function
 
 import traceback
+import asyncio
+import os
 
 from . import app
 from ..audit import identifier
 from . import stage
+from ..utils import constants
 
 # 引入启动阶段实现以便注册
 from .stages import load_config, setup_logger, build_app, migrate, show_notes
@@ -19,13 +22,19 @@ stage_order = [
 ]
 
 
-async def make_app() -> app.Application:
+async def make_app(loop: asyncio.AbstractEventLoop) -> app.Application:
 
     # 生成标识符
     identifier.init()
 
+    # 确定是否为调试模式
+    if "DEBUG" in os.environ and os.environ["DEBUG"] in ["true", "1"]:
+        constants.debug_mode = True
+
     ap = app.Application()
 
+    ap.event_loop = loop
+
     # 执行启动阶段
     for stage_name in stage_order:
         stage_cls = stage.preregistered_stages[stage_name]
@@ -38,9 +47,23 @@ async def make_app() -> app.Application:
     return ap
 
 
-async def main():
+async def main(loop: asyncio.AbstractEventLoop):
     try:
-        app_inst = await make_app()
+
+        # 挂系统信号处理
+        import signal
+
+        ap: app.Application
+
+        def signal_handler(sig, frame):
+            print("[Signal] 程序退出.")
+            # ap.shutdown()
+            os._exit(0)
+
+        signal.signal(signal.SIGINT, signal_handler)
+
+        app_inst = await make_app(loop)
+        ap = app_inst
         await app_inst.run()
     except Exception as e:
         traceback.print_exc()

pkg/core/bootutils/deps.py

@@ -5,9 +5,8 @@ required_deps = {
     "openai": "openai",
     "anthropic": "anthropic",
     "colorlog": "colorlog",
-    "mirai": "yiri-mirai-rc",
     "aiocqhttp": "aiocqhttp",
-    "botpy": "qq-botpy",
+    "botpy": "qq-botpy-rc",
     "PIL": "pillow",
     "nakuru": "nakuru-project-idk",
     "tiktoken": "tiktoken",
@@ -15,6 +14,15 @@ required_deps = {
     "aiohttp": "aiohttp",
     "psutil": "psutil",
     "async_lru": "async-lru",
+    "ollama": "ollama",
+    "quart": "quart",
+    "quart_cors": "quart-cors",
+    "sqlalchemy": "sqlalchemy[asyncio]",
+    "aiosqlite": "aiosqlite",
+    "aiofiles": "aiofiles",
+    "aioshutil": "aioshutil",
+    "argon2": "argon2-cffi",
+    "jwt": "pyjwt",
 }
 
 

pkg/core/bootutils/log.py

@@ -5,6 +5,8 @@ import time
 
 import colorlog
 
+from ...utils import constants
+
 
 log_colors_config = {
     "DEBUG": "green",  # cyan white
@@ -15,18 +17,18 @@ log_colors_config = {
 }
 
 
-async def init_logging() -> logging.Logger:
+async def init_logging(extra_handlers: list[logging.Handler] = None) -> logging.Logger:
     # 删除所有现有的logger
     for handler in logging.root.handlers[:]:
         logging.root.removeHandler(handler)
 
     level = logging.INFO
 
-    if "DEBUG" in os.environ and os.environ["DEBUG"] in ["true", "1"]:
+    if constants.debug_mode:
         level = logging.DEBUG
 
-    log_file_name = "data/logs/qcg-%s.log" % time.strftime(
-        "%Y-%m-%d-%H-%M-%S", time.localtime()
+    log_file_name = "data/logs/langbot-%s.log" % time.strftime(
+        "%Y-%m-%d", time.localtime()
     )
 
     qcg_logger = logging.getLogger("qcg")
@@ -34,14 +36,18 @@ async def init_logging() -> logging.Logger:
     qcg_logger.setLevel(level)
 
     color_formatter = colorlog.ColoredFormatter(
-        fmt="%(log_color)s[%(asctime)s.%(msecs)03d] %(pathname)s (%(lineno)d) - [%(levelname)s] :\n    %(message)s",
-        datefmt="%Y-%m-%d %H:%M:%S",
+        fmt="%(log_color)s[%(asctime)s.%(msecs)03d] %(filename)s (%(lineno)d) - [%(levelname)s] : %(message)s",
+        datefmt="%m-%d %H:%M:%S",
         log_colors=log_colors_config,
     )
 
     stream_handler = logging.StreamHandler(sys.stdout)
+    # stream_handler.setLevel(level)
+    # stream_handler.setFormatter(color_formatter)
+    stream_handler.stream = open(sys.stdout.fileno(), mode='w', encoding='utf-8', buffering=1)
 
-    log_handlers: logging.Handler = [stream_handler, logging.FileHandler(log_file_name)]
+    log_handlers: list[logging.Handler] = [stream_handler, logging.FileHandler(log_file_name, encoding='utf-8')]
+    log_handlers += extra_handlers if extra_handlers is not None else []
 
     for handler in log_handlers:
         handler.setLevel(level)

pkg/core/entities.py

@@ -5,14 +5,24 @@ import typing
 import datetime
 import asyncio
 
-import pydantic
-import mirai
+import pydantic.v1 as pydantic
 
 from ..provider import entities as llm_entities
 from ..provider.modelmgr import entities
 from ..provider.sysprompt import entities as sysprompt_entities
 from ..provider.tools import entities as tools_entities
 from ..platform import adapter as msadapter
+from ..platform.types import message as platform_message
+from ..platform.types import events as platform_events
+from ..platform.types import entities as platform_entities
+
+
+
+class LifecycleControlScope(enum.Enum):
+
+    APPLICATION = "application"
+    PLATFORM = "platform"
+    PLUGIN = "plugin"
 
 
 class LauncherTypes(enum.Enum):
@@ -40,10 +50,10 @@ class Query(pydantic.BaseModel):
     sender_id: int
     """发送者ID，platform处理阶段设置"""
 
-    message_event: mirai.MessageEvent
+    message_event: platform_events.MessageEvent
     """事件，platform收到的原始事件"""
 
-    message_chain: mirai.MessageChain
+    message_chain: platform_message.MessageChain
     """消息链，platform收到的原始消息链"""
 
     adapter: msadapter.MessageSourceAdapter
@@ -67,10 +77,10 @@ class Query(pydantic.BaseModel):
     use_funcs: typing.Optional[list[tools_entities.LLMFunction]] = None
     """使用的函数，由前置处理器阶段设置"""
 
-    resp_messages: typing.Optional[list[llm_entities.Message]] | typing.Optional[list[mirai.MessageChain]] = []
+    resp_messages: typing.Optional[list[llm_entities.Message]] | typing.Optional[list[platform_message.MessageChain]] = []
     """由Process阶段生成的回复消息对象列表"""
 
-    resp_message_chain: typing.Optional[list[mirai.MessageChain]] = None
+    resp_message_chain: typing.Optional[list[platform_message.MessageChain]] = None
     """回复消息链，从resp_messages包装而得"""
 
     # ======= 内部保留 =======
@@ -81,7 +91,7 @@ class Query(pydantic.BaseModel):
 
 
 class Conversation(pydantic.BaseModel):
-    """对话，包含于 Session 中，一个 Session 可以有多个历史 Conversation，但只有一个当前使用的 Conversation""" 
+    """对话，包含于 Session 中，一个 Session 可以有多个历史 Conversation，但只有一个当前使用的 Conversation"""
 
     prompt: sysprompt_entities.Prompt
 
@@ -95,6 +105,9 @@ class Conversation(pydantic.BaseModel):
 
     use_funcs: typing.Optional[list[tools_entities.LLMFunction]]
 
+    uuid: typing.Optional[str] = None
+    """该对话的 uuid，在创建时不会自动生成。而是当使用 Dify API 等由外部管理对话信息的服务时，用于绑定外部的会话。具体如何使用，取决于 Runner。"""
+
 
 class Session(pydantic.BaseModel):
     """会话，一个 Session 对应一个 {launcher_type.value}_{launcher_id}"""
@@ -108,7 +121,7 @@ class Session(pydantic.BaseModel):
 
     using_conversation: typing.Optional[Conversation] = None
 
-    conversations: typing.Optional[list[Conversation]] = []
+    conversations: typing.Optional[list[Conversation]] = pydantic.Field(default_factory=list)
 
     create_time: typing.Optional[datetime.datetime] = pydantic.Field(default_factory=datetime.datetime.now)
 

pkg/core/migrations/m013_http_api_config.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("http-api-config", 13)
+class HttpApiConfigMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        return 'http-api' not in self.ap.system_cfg.data or "persistence" not in self.ap.system_cfg.data
+
+    async def run(self):
+        """执行迁移"""
+        
+        self.ap.system_cfg.data['http-api'] = {
+            "enable": True,
+            "host": "0.0.0.0",
+            "port": 5300,
+            "jwt-expire": 604800
+        }
+
+        self.ap.system_cfg.data['persistence'] = {
+            "sqlite": {
+                "path": "data/persistence.db"
+            },
+            "use": "sqlite"
+        }
+
+        await self.ap.system_cfg.dump_config()

pkg/core/migrations/m014_force_delay_config.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("force-delay-config", 14)
+class ForceDelayConfigMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        return type(self.ap.platform_cfg.data['force-delay']) == list
+
+    async def run(self):
+        """执行迁移"""
+
+        self.ap.platform_cfg.data['force-delay'] = {
+            "min": self.ap.platform_cfg.data['force-delay'][0],
+            "max": self.ap.platform_cfg.data['force-delay'][1]
+        }
+
+        await self.ap.platform_cfg.dump_config()

pkg/core/migrations/m015_gitee_ai_config.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("gitee-ai-config", 15)
+class GiteeAIConfigMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        return 'gitee-ai-chat-completions' not in self.ap.provider_cfg.data['requester'] or 'gitee-ai' not in self.ap.provider_cfg.data['keys']
+
+    async def run(self):
+        """执行迁移"""
+        self.ap.provider_cfg.data['requester']['gitee-ai-chat-completions'] = {
+            "base-url": "https://ai.gitee.com/v1",
+            "args": {},
+            "timeout": 120
+        }
+
+        self.ap.provider_cfg.data['keys']['gitee-ai'] = [
+            "XXXXX"
+        ]
+
+        await self.ap.provider_cfg.dump_config()

pkg/core/migrations/m016_dify_service_api.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("dify-service-api-config", 16)
+class DifyServiceAPICfgMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        return 'dify-service-api' not in self.ap.provider_cfg.data
+
+    async def run(self):
+        """执行迁移"""
+        self.ap.provider_cfg.data['dify-service-api'] = {
+            "base-url": "https://api.dify.ai/v1",
+            "app-type": "chat",
+            "chat": {
+                "api-key": "app-1234567890"
+            },
+            "workflow": {
+                "api-key": "app-1234567890",
+                "output-key": "summary"
+            }
+        }
+
+        await self.ap.provider_cfg.dump_config()

pkg/core/migrations/m017_dify_api_timeout_params.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("dify-api-timeout-params", 17)
+class DifyAPITimeoutParamsMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        return 'timeout' not in self.ap.provider_cfg.data['dify-service-api']['chat'] or 'timeout' not in self.ap.provider_cfg.data['dify-service-api']['workflow'] \
+            or 'agent' not in self.ap.provider_cfg.data['dify-service-api']
+
+    async def run(self):
+        """执行迁移"""
+        self.ap.provider_cfg.data['dify-service-api']['chat']['timeout'] = 120
+        self.ap.provider_cfg.data['dify-service-api']['workflow']['timeout'] = 120
+        self.ap.provider_cfg.data['dify-service-api']['agent'] = {
+            "api-key": "app-1234567890",
+            "timeout": 120
+        }
+
+        await self.ap.provider_cfg.dump_config()

pkg/core/stages/build_app.py

@@ -15,6 +15,12 @@ from ...provider.sysprompt import sysprompt as llm_prompt_mgr
 from ...provider.tools import toolmgr as llm_tool_mgr
 from ...provider import runnermgr
 from ...platform import manager as im_mgr
+from ...persistence import mgr as persistencemgr
+from ...api.http.controller import main as http_controller
+from ...api.http.service import user as user_service
+from ...utils import logcache
+from .. import taskmgr
+
 
 @stage.stage_class("BuildAppStage")
 class BuildAppStage(stage.BootingStage):
@@ -24,6 +30,7 @@ class BuildAppStage(stage.BootingStage):
     async def run(self, ap: app.Application):
         """构建app对象的各个组件对象并初始化
         """
+        ap.task_mgr = taskmgr.AsyncTaskManager(ap)
 
         proxy_mgr = proxy.ProxyManager(ap)
         await proxy_mgr.initialize()
@@ -58,6 +65,13 @@ class BuildAppStage(stage.BootingStage):
 
         ap.query_pool = pool.QueryPool()
 
+        log_cache = logcache.LogCache()
+        ap.log_cache = log_cache
+
+        persistence_mgr_inst = persistencemgr.PersistenceManager(ap)
+        await persistence_mgr_inst.initialize()
+        ap.persistence_mgr = persistence_mgr_inst
+
         plugin_mgr_inst = plugin_mgr.PluginManager(ap)
         await plugin_mgr_inst.initialize()
         ap.plugin_mgr = plugin_mgr_inst
@@ -95,6 +109,12 @@ class BuildAppStage(stage.BootingStage):
         await stage_mgr.initialize()
         ap.stage_mgr = stage_mgr
 
+        http_ctrl = http_controller.HTTPController(ap)
+        await http_ctrl.initialize()
+        ap.http_ctrl = http_ctrl
+
+        user_service_inst = user_service.UserService(ap)
+        ap.user_service = user_service_inst
 
         ctrl = controller.Controller(ap)
         ap.ctrl = ctrl

pkg/core/stages/load_config.py

@@ -1,7 +1,11 @@
 from __future__ import annotations
 
+import secrets
+
 from .. import stage, app
 from ..bootutils import config
+from ...config import settings as settings_mgr
+from ...utils import schema
 
 
 @stage.stage_class("LoadConfigStage")
@@ -12,12 +16,56 @@ class LoadConfigStage(stage.BootingStage):
     async def run(self, ap: app.Application):
         """启动
         """
+        
+        ap.settings_mgr = settings_mgr.SettingsManager(ap)
+        await ap.settings_mgr.initialize()
+
         ap.command_cfg = await config.load_json_config("data/config/command.json", "templates/command.json", completion=False)
         ap.pipeline_cfg = await config.load_json_config("data/config/pipeline.json", "templates/pipeline.json", completion=False)
         ap.platform_cfg = await config.load_json_config("data/config/platform.json", "templates/platform.json", completion=False)
         ap.provider_cfg = await config.load_json_config("data/config/provider.json", "templates/provider.json", completion=False)
         ap.system_cfg = await config.load_json_config("data/config/system.json", "templates/system.json", completion=False)
 
+        ap.settings_mgr.register_manager(
+            name="command.json",
+            description="命令配置",
+            manager=ap.command_cfg,
+            schema=schema.CONFIG_COMMAND_SCHEMA,
+            doc_link="https://docs.langbot.app/config/function/command.html"
+        )
+
+        ap.settings_mgr.register_manager(
+            name="pipeline.json",
+            description="消息处理流水线配置",
+            manager=ap.pipeline_cfg,
+            schema=schema.CONFIG_PIPELINE_SCHEMA,
+            doc_link="https://docs.langbot.app/config/function/pipeline.html"
+        )
+
+        ap.settings_mgr.register_manager(
+            name="platform.json",
+            description="消息平台配置",
+            manager=ap.platform_cfg,
+            schema=schema.CONFIG_PLATFORM_SCHEMA,
+            doc_link="https://docs.langbot.app/config/function/platform.html"
+        )
+
+        ap.settings_mgr.register_manager(
+            name="provider.json",
+            description="大模型能力配置",
+            manager=ap.provider_cfg,
+            schema=schema.CONFIG_PROVIDER_SCHEMA,
+            doc_link="https://docs.langbot.app/config/function/provider.html"
+        )
+
+        ap.settings_mgr.register_manager(
+            name="system.json",
+            description="系统配置",
+            manager=ap.system_cfg,
+            schema=schema.CONFIG_SYSTEM_SCHEMA,
+            doc_link="https://docs.langbot.app/config/function/system.html"
+        )
+
         ap.plugin_setting_meta = await config.load_json_config("plugins/plugins.json", "templates/plugin-settings.json")
         await ap.plugin_setting_meta.dump_config()
 
@@ -29,3 +77,8 @@ class LoadConfigStage(stage.BootingStage):
 
         ap.llm_models_meta = await config.load_json_config("data/metadata/llm-models.json", "templates/metadata/llm-models.json")
         await ap.llm_models_meta.dump_config()
+
+        ap.instance_secret_meta = await config.load_json_config("data/metadata/instance-secret.json", template_data={
+            'jwt_secret': secrets.token_hex(16)
+        })
+        await ap.instance_secret_meta.dump_config()

pkg/core/stages/migrate.py

@@ -6,7 +6,8 @@ from .. import stage, app
 from .. import migration
 from ..migrations import m001_sensitive_word_migration, m002_openai_config_migration, m003_anthropic_requester_cfg_completion, m004_moonshot_cfg_completion
 from ..migrations import m005_deepseek_cfg_completion, m006_vision_config, m007_qcg_center_url, m008_ad_fixwin_config_migrate, m009_msg_truncator_cfg
-from ..migrations import m010_ollama_requester_config, m011_command_prefix_config, m012_runner_config
+from ..migrations import m010_ollama_requester_config, m011_command_prefix_config, m012_runner_config, m013_http_api_config, m014_force_delay_config
+from ..migrations import m015_gitee_ai_config, m016_dify_service_api, m017_dify_api_timeout_params
 
 
 @stage.stage_class("MigrationStage")
@@ -28,3 +29,4 @@ class MigrationStage(stage.BootingStage):
 
             if await migration_instance.need_migrate():
                 await migration_instance.run()
+                print(f'已执行迁移 {migration_instance.name}')

pkg/core/stages/setup_logger.py

@@ -1,9 +1,38 @@
 from __future__ import annotations
 
+import logging
+import asyncio
+from datetime import datetime
+
 from .. import stage, app
 from ..bootutils import log
 
 
+class PersistenceHandler(logging.Handler, object):
+    """
+    保存日志到数据库
+    """
+    ap: app.Application
+
+    def __init__(self, name, ap: app.Application):
+        logging.Handler.__init__(self)
+        self.ap = ap
+
+    def emit(self, record):
+        """
+        emit函数为自定义handler类时必重写的函数，这里可以根据需要对日志消息做一些处理，比如发送日志到服务器
+
+        发出记录(Emit a record)
+        """
+        try:
+            msg = self.format(record)
+            if self.ap.log_cache is not None:
+                self.ap.log_cache.add_log(msg)
+                
+        except Exception:
+            self.handleError(record)
+
+
 @stage.stage_class("SetupLoggerStage")
 class SetupLoggerStage(stage.BootingStage):
     """设置日志器阶段
@@ -12,4 +41,9 @@ class SetupLoggerStage(stage.BootingStage):
     async def run(self, ap: app.Application):
         """启动
         """
-        ap.logger = await log.init_logging()
+        persistence_handler = PersistenceHandler('LoggerHandler', ap)
+
+        extra_handlers = []
+        extra_handlers = [persistence_handler]
+
+        ap.logger = await log.init_logging(extra_handlers)

pkg/core/taskmgr.py

@@ -0,0 +1,235 @@
+from __future__ import annotations
+
+import asyncio
+import typing
+import datetime
+import traceback
+
+from . import app
+from . import entities as core_entities
+
+
+class TaskContext:
+    """任务跟踪上下文"""
+
+    current_action: str
+    """当前正在执行的动作"""
+
+    log: str
+    """记录日志"""
+
+    def __init__(self):
+        self.current_action = "default"
+        self.log = ""
+
+    def _log(self, msg: str):
+        self.log += msg + "\n"
+
+    def set_current_action(self, action: str):
+        self.current_action = action
+
+    def trace(
+        self,
+        msg: str,
+        action: str = None,
+    ):
+        if action is not None:
+            self.set_current_action(action)
+
+        self._log(
+            f"{datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')} | {self.current_action} | {msg}"
+        )
+
+    def to_dict(self) -> dict:
+        return {"current_action": self.current_action, "log": self.log}
+    
+    @staticmethod
+    def new() -> TaskContext:
+        return TaskContext()
+    
+    @staticmethod
+    def placeholder() -> TaskContext:
+        global placeholder_context
+
+        if placeholder_context is None:
+            placeholder_context = TaskContext()
+
+        return placeholder_context
+
+
+placeholder_context: TaskContext | None = None
+
+
+class TaskWrapper:
+    """任务包装器"""
+
+    _id_index: int = 0
+    """任务ID索引"""
+
+    id: int
+    """任务ID"""
+
+    task_type: str = "system"  # 任务类型: system 或 user
+    """任务类型"""
+
+    kind: str = "system_task"  # 由发起者确定任务种类，通常同质化的任务种类相同
+    """任务种类"""
+
+    name: str = ""
+    """任务唯一名称"""
+
+    label: str = ""
+    """任务显示名称"""
+
+    task_context: TaskContext
+    """任务上下文"""
+
+    task: asyncio.Task
+    """任务"""
+
+    task_stack: list = None
+    """任务堆栈"""
+
+    ap: app.Application
+    """应用实例"""
+
+    scopes: list[core_entities.LifecycleControlScope]
+    """任务所属生命周期控制范围"""
+
+    def __init__(
+        self,
+        ap: app.Application,
+        coro: typing.Coroutine,
+        task_type: str = "system",
+        kind: str = "system_task",
+        name: str = "",
+        label: str = "",
+        context: TaskContext = None,
+        scopes: list[core_entities.LifecycleControlScope] = [core_entities.LifecycleControlScope.APPLICATION],
+    ):
+        self.id = TaskWrapper._id_index
+        TaskWrapper._id_index += 1
+        self.ap = ap
+        self.task_context = context or TaskContext()
+        self.task = self.ap.event_loop.create_task(coro)
+        self.task_type = task_type
+        self.kind = kind
+        self.name = name
+        self.label = label if label != "" else name
+        self.task.set_name(name)
+        self.scopes = scopes
+
+    def assume_exception(self):
+        try:
+            exception = self.task.exception()
+            if self.task_stack is None:
+                self.task_stack = self.task.get_stack()
+            return exception
+        except:
+            return None
+
+    def assume_result(self):
+        try:
+            return self.task.result()
+        except:
+            return None
+
+    def to_dict(self) -> dict:
+
+        exception_traceback = None
+        if self.assume_exception() is not None:
+            exception_traceback = 'Traceback (most recent call last):\n'
+
+            for frame in self.task_stack:
+                exception_traceback += f"  File \"{frame.f_code.co_filename}\", line {frame.f_lineno}, in {frame.f_code.co_name}\n"
+
+            exception_traceback += f"    {self.assume_exception().__str__()}\n"
+
+        return {
+            "id": self.id,
+            "task_type": self.task_type,
+            "kind": self.kind,
+            "name": self.name,
+            "label": self.label,
+            "scopes": [scope.value for scope in self.scopes],
+            "task_context": self.task_context.to_dict(),
+            "runtime": {
+                "done": self.task.done(),
+                "state": self.task._state,
+                "exception": self.assume_exception().__str__() if self.assume_exception() is not None else None,
+                "exception_traceback": exception_traceback,
+                "result": self.assume_result().__str__() if self.assume_result() is not None else None,
+            },
+        }
+    
+    def cancel(self):
+        self.task.cancel()
+
+
+class AsyncTaskManager:
+    """保存app中的所有异步任务
+    包含系统级的和用户级（插件安装、更新等由用户直接发起的）的"""
+
+    ap: app.Application
+
+    tasks: list[TaskWrapper]
+    """所有任务"""
+
+    def __init__(self, ap: app.Application):
+        self.ap = ap
+        self.tasks = []
+
+    def create_task(
+        self,
+        coro: typing.Coroutine,
+        task_type: str = "system",
+        kind: str = "system-task",
+        name: str = "",
+        label: str = "",
+        context: TaskContext = None,
+        scopes: list[core_entities.LifecycleControlScope] = [core_entities.LifecycleControlScope.APPLICATION],
+    ) -> TaskWrapper:
+        wrapper = TaskWrapper(self.ap, coro, task_type, kind, name, label, context, scopes)
+        self.tasks.append(wrapper)
+        return wrapper
+
+    def create_user_task(
+        self,
+        coro: typing.Coroutine,
+        kind: str = "user-task",
+        name: str = "",
+        label: str = "",
+        context: TaskContext = None,
+        scopes: list[core_entities.LifecycleControlScope] = [core_entities.LifecycleControlScope.APPLICATION],
+    ) -> TaskWrapper:
+        return self.create_task(coro, "user", kind, name, label, context, scopes)
+
+    async def wait_all(self):
+        await asyncio.gather(*[t.task for t in self.tasks], return_exceptions=True)
+
+    def get_all_tasks(self) -> list[TaskWrapper]:
+        return self.tasks
+
+    def get_tasks_dict(
+        self,
+        type: str = None,
+    ) -> dict:
+        return {
+            "tasks": [
+                t.to_dict() for t in self.tasks if type is None or t.task_type == type
+            ],
+            "id_index": TaskWrapper._id_index,
+        }
+    
+    def get_task_by_id(self, id: int) -> TaskWrapper | None:
+        for t in self.tasks:
+            if t.id == id:
+                return t
+        return None
+
+    def cancel_by_scope(self, scope: core_entities.LifecycleControlScope):
+        for wrapper in self.tasks:
+            
+            if not wrapper.task.done() and scope in wrapper.scopes:
+
+                wrapper.task.cancel()

pkg/persistence/database.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import abc
+
+import sqlalchemy.ext.asyncio as sqlalchemy_asyncio
+
+from ..core import app
+
+
+preregistered_managers: list[type[BaseDatabaseManager]] = []
+
+def manager_class(name: str) -> None:
+    """注册一个数据库管理类"""
+
+    def decorator(cls: type[BaseDatabaseManager]) -> type[BaseDatabaseManager]:
+        cls.name = name
+        preregistered_managers.append(cls)
+        return cls
+
+    return decorator
+
+
+class BaseDatabaseManager(abc.ABC):
+    """基础数据库管理类"""
+
+    name: str
+
+    ap: app.Application
+
+    engine: sqlalchemy_asyncio.AsyncEngine
+
+    def __init__(self, ap: app.Application) -> None:
+        self.ap = ap
+
+    @abc.abstractmethod
+    async def initialize(self) -> None:
+        pass
+
+    def get_engine(self) -> sqlalchemy_asyncio.AsyncEngine:
+        return self.engine

pkg/persistence/databases/sqlite.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+import sqlalchemy.ext.asyncio as sqlalchemy_asyncio
+
+from .. import database
+
+
+@database.manager_class("sqlite")
+class SQLiteDatabaseManager(database.BaseDatabaseManager):
+    """SQLite 数据库管理类"""
+    
+    async def initialize(self) -> None:
+        self.engine = sqlalchemy_asyncio.create_async_engine(f"sqlite+aiosqlite:///{self.ap.system_cfg.data['persistence']['sqlite']['path']}")

pkg/persistence/entities/base.py

@@ -0,0 +1,5 @@
+import sqlalchemy.orm
+
+
+class Base(sqlalchemy.orm.DeclarativeBase):
+    pass

pkg/persistence/entities/user.py

@@ -0,0 +1,11 @@
+import sqlalchemy
+
+from .base import Base
+
+
+class User(Base):
+    __tablename__ = 'users'
+
+    id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
+    user = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)
+    password = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)

pkg/persistence/mgr.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import asyncio
+import datetime
+
+import sqlalchemy.ext.asyncio as sqlalchemy_asyncio
+import sqlalchemy
+
+from . import database
+from .entities import user, base
+from ..core import app
+from .databases import sqlite
+
+
+class PersistenceManager:
+    """持久化模块管理器"""
+
+    ap: app.Application
+
+    db: database.BaseDatabaseManager
+    """数据库管理器"""
+
+    meta: sqlalchemy.MetaData
+
+    def __init__(self, ap: app.Application):
+        self.ap = ap
+        self.meta = base.Base.metadata
+
+    async def initialize(self):
+        
+        for manager in database.preregistered_managers:
+            self.db = manager(self.ap)
+            await self.db.initialize()
+
+        await self.create_tables()
+
+    async def create_tables(self):
+        # TODO: 对扩展友好
+        
+        # 日志
+        async with self.get_db_engine().connect() as conn:
+            await conn.run_sync(self.meta.create_all)
+
+            await conn.commit()
+
+    async def execute_async(
+        self,
+        *args,
+        **kwargs
+    ) -> sqlalchemy.engine.cursor.CursorResult:
+        async with self.get_db_engine().connect() as conn:
+            result = await conn.execute(*args, **kwargs)
+            await conn.commit()
+            return result
+
+    def get_db_engine(self) -> sqlalchemy_asyncio.AsyncEngine:
+        return self.db.get_engine()

pkg/pipeline/cntfilter/cntfilter.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-import mirai
-
 from ...core import app
 
 from .. import stage, entities, stagemgr
@@ -10,6 +8,9 @@ from ...config import manager as cfg_mgr
 from . import filter as filter_model, entities as filter_entities
 from .filters import cntignore, banwords, baiduexamine
 from ...provider import entities as llm_entities
+from ...platform.types import message as platform_message
+from ...platform.types import events as platform_events
+from ...platform.types import entities as platform_entities
 
 
 @stage.stage_class('PostContentFilterStage')
@@ -63,6 +64,7 @@ class ContentFilterStage(stage.PipelineStage):
         """请求llm前处理消息
         只要有一个不通过就不放行，只放行 PASS 的消息
         """
+
         if not self.ap.pipeline_cfg.data['income-msg-check']:
             return entities.StageProcessResult(
                 result_type=entities.ResultType.CONTINUE,
@@ -86,8 +88,8 @@ class ContentFilterStage(stage.PipelineStage):
                     elif result.level == filter_entities.ResultLevel.PASS:  # 传到下一个
                         message = result.replacement
             
-            query.message_chain = mirai.MessageChain(
-                mirai.Plain(message)
+            query.message_chain = platform_message.MessageChain(
+                platform_message.Plain(message)
             )
 
             return entities.StageProcessResult(
@@ -145,11 +147,13 @@ class ContentFilterStage(stage.PipelineStage):
             
             contain_non_text = False
 
+            text_components = [platform_message.Plain, platform_message.Source]
+
             for me in query.message_chain:
-                if not isinstance(me, mirai.Plain):
+                if type(me) not in text_components:
                     contain_non_text = True
                     break
-            
+
             if contain_non_text:
                 self.ap.logger.debug(f"消息中包含非文本消息，跳过内容过滤器检查。")
                 return entities.StageProcessResult(

pkg/pipeline/cntfilter/entities.py

@@ -2,7 +2,7 @@
 import typing
 import enum
 
-import pydantic
+import pydantic.v1 as pydantic
 
 from ...provider import entities as llm_entities
 

pkg/pipeline/controller.py

@@ -4,11 +4,10 @@ import asyncio
 import typing
 import traceback
 
-import mirai
-
 from ..core import app, entities
 from . import entities as pipeline_entities
 from ..plugin import events
+from ..platform.types import message as platform_message
 
 
 class Controller:
@@ -59,8 +58,13 @@ class Controller:
                             (await self.ap.sess_mgr.get_session(selected_query)).semaphore.release()
                             # 通知其他协程，有新的请求可以处理了
                             self.ap.query_pool.condition.notify_all()
-                    
-                    asyncio.create_task(_process_query(selected_query))
+                    self.ap.task_mgr.create_task(
+                        _process_query(selected_query),
+                        kind="query",
+                        name=f"query-{selected_query.query_id}",
+                        scopes=[entities.LifecycleControlScope.APPLICATION, entities.LifecycleControlScope.PLATFORM],
+                    )
+
         except Exception as e:
             # traceback.print_exc()
             self.ap.logger.error(f"控制器循环出错: {e}")
@@ -73,11 +77,11 @@ class Controller:
             # 处理str类型
 
             if isinstance(result.user_notice, str):
-                result.user_notice = mirai.MessageChain(
-                    mirai.Plain(result.user_notice)
+                result.user_notice = platform_message.MessageChain(
+                    platform_message.Plain(result.user_notice)
                 )
             elif isinstance(result.user_notice, list):
-                result.user_notice = mirai.MessageChain(
+                result.user_notice = platform_message.MessageChain(
                     *result.user_notice
                 )
 
@@ -159,6 +163,23 @@ class Controller:
     async def process_query(self, query: entities.Query):
         """处理请求
         """
+
+        # ======== 触发 MessageReceived 事件 ========
+        event_type = events.PersonMessageReceived if query.launcher_type == entities.LauncherTypes.PERSON else events.GroupMessageReceived
+
+        event_ctx = await self.ap.plugin_mgr.emit_event(
+            event=event_type(
+                launcher_type=query.launcher_type.value,
+                launcher_id=query.launcher_id,
+                sender_id=query.sender_id,
+                message_chain=query.message_chain,
+                query=query
+            )
+        )
+
+        if event_ctx.is_prevented_default():
+            return
+        
         self.ap.logger.debug(f"Processing query {query}")
 
         try:
@@ -166,7 +187,6 @@ class Controller:
         except Exception as e:
             self.ap.logger.error(f"处理请求时出错 query_id={query.query_id} stage={query.current_stage.inst_name} : {e}")
             self.ap.logger.debug(f"Traceback: {traceback.format_exc()}")
-            # traceback.print_exc()
         finally:
             self.ap.logger.debug(f"Query {query} processed")
 

pkg/pipeline/entities.py

@@ -3,9 +3,8 @@ from __future__ import annotations
 import enum
 import typing
 
-import pydantic
-import mirai
-import mirai.models.message as mirai_message
+import pydantic.v1 as pydantic
+from ..platform.types import message as platform_message
 
 from ..core import entities
 
@@ -25,13 +24,9 @@ class StageProcessResult(pydantic.BaseModel):
 
     new_query: entities.Query
 
-    user_notice: typing.Optional[typing.Union[str, list[mirai_message.MessageComponent], mirai.MessageChain, None]] = []
+    user_notice: typing.Optional[typing.Union[str, list[platform_message.MessageComponent], platform_message.MessageChain, None]] = []
     """只要设置了就会发送给用户"""
 
-    # TODO delete
-    # admin_notice: typing.Optional[typing.Union[str, list[mirai_message.MessageComponent], mirai.MessageChain, None]] = []
-    """只要设置了就会发送给管理员"""
-
     console_notice: typing.Optional[str] = ''
     """只要设置了就会输出到控制台"""
 

pkg/pipeline/longtext/longtext.py

@@ -3,7 +3,6 @@ import os
 import traceback
 
 from PIL import Image, ImageDraw, ImageFont
-from mirai.models.message import MessageComponent, Plain, MessageChain
 
 from ...core import app
 from . import strategy
@@ -11,6 +10,7 @@ from .strategies import image, forward
 from .. import stage, entities, stagemgr
 from ...core import entities as core_entities
 from ...config import manager as cfg_mgr
+from ...platform.types import message as platform_message
 
 
 @stage.stage_class("LongTextProcessStage")
@@ -63,14 +63,14 @@ class LongTextProcessStage(stage.PipelineStage):
         contains_non_plain = False
 
         for msg in query.resp_message_chain[-1]:
-            if not isinstance(msg, Plain):
+            if not isinstance(msg, platform_message.Plain):
                 contains_non_plain = True
                 break
         
         if contains_non_plain:
             self.ap.logger.debug("消息中包含非 Plain 组件，跳过长消息处理。")
         elif len(str(query.resp_message_chain[-1])) > self.ap.platform_cfg.data['long-text-process']['threshold']:
-            query.resp_message_chain[-1] = MessageChain(await self.strategy_impl.process(str(query.resp_message_chain[-1]), query))
+            query.resp_message_chain[-1] = platform_message.MessageChain(await self.strategy_impl.process(str(query.resp_message_chain[-1]), query))
 
         return entities.StageProcessResult(
             result_type=entities.ResultType.CONTINUE,

pkg/pipeline/longtext/strategies/forward.py

@@ -2,15 +2,14 @@
 from __future__ import annotations
 import typing
 
-from mirai.models import MessageChain
-from mirai.models.message import MessageComponent, ForwardMessageNode
-from mirai.models.base import MiraiBaseModel
+import pydantic.v1 as pydantic
 
 from .. import strategy as strategy_model
 from ....core import entities as core_entities
+from ....platform.types import message as platform_message
 
 
-class ForwardMessageDiaplay(MiraiBaseModel):
+class ForwardMessageDiaplay(pydantic.BaseModel):
     title: str = "群聊的聊天记录"
     brief: str = "[聊天记录]"
     source: str = "聊天记录"
@@ -18,13 +17,13 @@ class ForwardMessageDiaplay(MiraiBaseModel):
     summary: str = "查看x条转发消息"
 
 
-class Forward(MessageComponent):
+class Forward(platform_message.MessageComponent):
     """合并转发。"""
     type: str = "Forward"
     """消息组件类型。"""
     display: ForwardMessageDiaplay
     """显示信息"""
-    node_list: typing.List[ForwardMessageNode]
+    node_list: typing.List[platform_message.ForwardMessageNode]
     """转发消息节点列表。"""
     def __init__(self, *args, **kwargs):
         if len(args) == 1:
@@ -39,7 +38,7 @@ class Forward(MessageComponent):
 @strategy_model.strategy_class("forward")
 class ForwardComponentStrategy(strategy_model.LongTextStrategy):
 
-    async def process(self, message: str, query: core_entities.Query) -> list[MessageComponent]:
+    async def process(self, message: str, query: core_entities.Query) -> list[platform_message.MessageComponent]:
         display = ForwardMessageDiaplay(
             title="群聊的聊天记录",
             brief="[聊天记录]",
@@ -49,10 +48,10 @@ class ForwardComponentStrategy(strategy_model.LongTextStrategy):
         )
 
         node_list = [
-            ForwardMessageNode(
+            platform_message.ForwardMessageNode(
                 sender_id=query.adapter.bot_account_id,
                 sender_name='QQ用户',
-                message_chain=MessageChain([message])
+                message_chain=platform_message.MessageChain([message])
             )
         ]
 

pkg/pipeline/longtext/strategies/image.py

@@ -8,8 +8,7 @@ import re
 
 from PIL import Image, ImageDraw, ImageFont
 
-from mirai.models import MessageChain, Image as ImageComponent
-from mirai.models.message import MessageComponent
+from ....platform.types import message as platform_message
 
 from .. import strategy as strategy_model
 from ....core import entities as core_entities
@@ -23,7 +22,7 @@ class Text2ImageStrategy(strategy_model.LongTextStrategy):
     async def initialize(self):
         self.text_render_font = ImageFont.truetype(self.ap.platform_cfg.data['long-text-process']['font-path'], 32, encoding="utf-8")
     
-    async def process(self, message: str, query: core_entities.Query) -> list[MessageComponent]:
+    async def process(self, message: str, query: core_entities.Query) -> list[platform_message.MessageComponent]:
         img_path = self.text_to_image(
             text_str=message,
             save_as='temp/{}.png'.format(int(time.time()))
@@ -46,7 +45,7 @@ class Text2ImageStrategy(strategy_model.LongTextStrategy):
             os.remove(compressed_path)
 
         return [
-            ImageComponent(
+            platform_message.Image(
                 base64=b64.decode('utf-8'),
             )
         ]
@@ -59,7 +58,7 @@ class Text2ImageStrategy(strategy_model.LongTextStrategy):
         """
         kv = []
         nums = []
-        beforeDatas = re.findall('[\d]+', path)
+        beforeDatas = re.findall('[\\d]+', path)
         for num in beforeDatas:
             indexV = []
             times = path.count(num)

pkg/pipeline/longtext/strategy.py

@@ -2,11 +2,10 @@ from __future__ import annotations
 import abc
 import typing
 
-import mirai
-from mirai.models.message import MessageComponent
 
 from ...core import app
 from ...core import entities as core_entities
+from ...platform.types import message as platform_message
 
 
 preregistered_strategies: list[typing.Type[LongTextStrategy]] = []
@@ -51,7 +50,7 @@ class LongTextStrategy(metaclass=abc.ABCMeta):
         pass
     
     @abc.abstractmethod
-    async def process(self, message: str, query: core_entities.Query) -> list[MessageComponent]:
+    async def process(self, message: str, query: core_entities.Query) -> list[platform_message.MessageComponent]:
         """处理长文本
 
         在 platform.json 中配置 long-text-process 字段，只要 文本长度超过了 threshold 就会调用此方法
@@ -61,6 +60,6 @@ class LongTextStrategy(metaclass=abc.ABCMeta):
             query (core_entities.Query): 此次请求的上下文对象
 
         Returns:
-            list[mirai.models.messages.MessageComponent]: 转换后的 YiriMirai 消息组件列表
+            list[platform_message.MessageComponent]: 转换后的 平台 消息组件列表
         """
         return []

pkg/pipeline/pool.py

@@ -2,10 +2,11 @@ from __future__ import annotations
 
 import asyncio
 
-import mirai
 
 from ..core import entities
 from ..platform import adapter as msadapter
+from ..platform.types import message as platform_message
+from ..platform.types import events as platform_events
 
 
 class QueryPool:
@@ -30,8 +31,8 @@ class QueryPool:
         launcher_type: entities.LauncherTypes,
         launcher_id: int,
         sender_id: int,
-        message_event: mirai.MessageEvent,
-        message_chain: mirai.MessageChain,
+        message_event: platform_events.MessageEvent,
+        message_chain: platform_message.MessageChain,
         adapter: msadapter.MessageSourceAdapter
     ) -> entities.Query:
         async with self.condition:

pkg/pipeline/preproc/preproc.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
-import mirai
 
 from .. import stage, entities, stagemgr
 from ...core import entities as core_entities
 from ...provider import entities as llm_entities
 from ...plugin import events
+from ...platform.types import message as platform_message
 
 
 @stage.stage_class("PreProcessor")
@@ -45,7 +45,7 @@ class PreProcessor(stage.PipelineStage):
 
 
         # 检查vision是否启用，没启用就删除所有图片
-        if not self.ap.provider_cfg.data['enable-vision'] or not query.use_model.vision_supported:
+        if not self.ap.provider_cfg.data['enable-vision'] or (self.ap.provider_cfg.data['runner'] == 'local-agent' and not query.use_model.vision_supported):
             for msg in query.messages:
                 if isinstance(msg.content, list):
                     for me in msg.content:
@@ -55,18 +55,18 @@ class PreProcessor(stage.PipelineStage):
         content_list = []
 
         for me in query.message_chain:
-            if isinstance(me, mirai.Plain):
+            if isinstance(me, platform_message.Plain):
                 content_list.append(
                     llm_entities.ContentElement.from_text(me.text)
                 )
-            elif isinstance(me, mirai.Image):
-                if self.ap.provider_cfg.data['enable-vision'] and query.use_model.vision_supported:
-                    if me.url is not None:
+            elif isinstance(me, platform_message.Image):
+                if self.ap.provider_cfg.data['enable-vision'] and (self.ap.provider_cfg.data['runner'] != 'local-agent' or query.use_model.vision_supported):
+                    if me.base64 is not None:
                         content_list.append(
-                            llm_entities.ContentElement.from_image_url(str(me.url))
+                            llm_entities.ContentElement.from_image_base64(me.base64)
                         )
 
-        query.user_message = llm_entities.Message(  # TODO 适配多模态输入
+        query.user_message = llm_entities.Message(
             role='user',
             content=content_list
         )

pkg/pipeline/process/handlers/chat.py

@@ -5,7 +5,6 @@ import time
 import traceback
 import json
 
-import mirai
 
 from .. import handler
 from ... import entities
@@ -13,6 +12,8 @@ from ....core import entities as core_entities
 from ....provider import entities as llm_entities, runnermgr
 from ....plugin import events
 
+from ....platform.types import message as platform_message
+
 
 class ChatMessageHandler(handler.MessageHandler):
 
@@ -40,7 +41,7 @@ class ChatMessageHandler(handler.MessageHandler):
 
         if event_ctx.is_prevented_default():
             if event_ctx.event.reply is not None:
-                mc = mirai.MessageChain(event_ctx.event.reply)
+                mc = platform_message.MessageChain(event_ctx.event.reply)
 
                 query.resp_messages.append(mc)
 
@@ -90,7 +91,7 @@ class ChatMessageHandler(handler.MessageHandler):
                 query.session.using_conversation.messages.extend(query.resp_messages)
             except Exception as e:
                 
-                self.ap.logger.error(f'对话({query.query_id})请求失败: {str(e)}')
+                self.ap.logger.error(f'对话({query.query_id})请求失败: {type(e).__name__} {str(e)}')
 
                 yield entities.StageProcessResult(
                     result_type=entities.ResultType.INTERRUPT,

pkg/pipeline/process/handlers/command.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 import typing
 
-import mirai
 
 from .. import handler
 from ... import entities
 from ....core import entities as core_entities
 from ....provider import entities as llm_entities
 from ....plugin import events
+from ....platform.types import message as platform_message
 
 
 class CommandHandler(handler.MessageHandler):
@@ -46,7 +46,7 @@ class CommandHandler(handler.MessageHandler):
         if event_ctx.is_prevented_default():
 
             if event_ctx.event.reply is not None:
-                mc = mirai.MessageChain(event_ctx.event.reply)
+                mc = platform_message.MessageChain(event_ctx.event.reply)
 
                 query.resp_messages.append(mc)
 
@@ -63,8 +63,8 @@ class CommandHandler(handler.MessageHandler):
         else:
 
             if event_ctx.event.alter is not None:
-                query.message_chain = mirai.MessageChain([
-                    mirai.Plain(event_ctx.event.alter)
+                query.message_chain = platform_message.MessageChain([
+                    platform_message.Plain(event_ctx.event.alter)
                 ])
 
             session = await self.ap.sess_mgr.get_session(query)

pkg/pipeline/respback/respback.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import random
 import asyncio
 
-import mirai
 
 from ...core import app
 
@@ -20,7 +19,10 @@ class SendResponseBackStage(stage.PipelineStage):
     async def process(self, query: core_entities.Query, stage_inst_name: str) -> entities.StageProcessResult:
         """处理
         """
-        random_delay = random.uniform(*self.ap.platform_cfg.data['force-delay'])
+        
+        random_range = (self.ap.platform_cfg.data['force-delay']['min'], self.ap.platform_cfg.data['force-delay']['max'])
+
+        random_delay = random.uniform(*random_range)
 
         self.ap.logger.debug(
             "根据规则强制延迟回复: %s s",

pkg/pipeline/resprule/entities.py

@@ -1,9 +1,10 @@
-import pydantic
-import mirai
+import pydantic.v1 as pydantic
+
+from ...platform.types import message as platform_message
 
 
 class RuleJudgeResult(pydantic.BaseModel):
 
     matching: bool = False
 
-    replacement: mirai.MessageChain = None
+    replacement: platform_message.MessageChain = None

pkg/pipeline/resprule/resprule.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import mirai
 
 from ...core import app
 from . import entities as rule_entities, rule

pkg/pipeline/resprule/rule.py

@@ -2,11 +2,11 @@ from __future__ import annotations
 import abc
 import typing
 
-import mirai
-
 from ...core import app, entities as core_entities
 from . import entities
 
+from ...platform.types import message as platform_message
+
 
 preregisetered_rules: list[typing.Type[GroupRespondRule]] = []
 
@@ -35,7 +35,7 @@ class GroupRespondRule(metaclass=abc.ABCMeta):
     async def match(
         self,
         message_text: str,
-        message_chain: mirai.MessageChain,
+        message_chain: platform_message.MessageChain,
         rule_dict: dict,
         query: core_entities.Query
     ) -> entities.RuleJudgeResult:

pkg/pipeline/resprule/rules/atbot.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
-import mirai
 
 from .. import rule as rule_model
 from .. import entities
 from ....core import entities as core_entities
+from ....platform.types import message as platform_message
 
 
 @rule_model.rule_class("at-bot")
@@ -13,16 +13,16 @@ class AtBotRule(rule_model.GroupRespondRule):
     async def match(
         self,
         message_text: str,
-        message_chain: mirai.MessageChain,
+        message_chain: platform_message.MessageChain,
         rule_dict: dict,
         query: core_entities.Query
     ) -> entities.RuleJudgeResult:
         
-        if message_chain.has(mirai.At(query.adapter.bot_account_id)) and rule_dict['at']:
-            message_chain.remove(mirai.At(query.adapter.bot_account_id))
+        if message_chain.has(platform_message.At(query.adapter.bot_account_id)) and rule_dict['at']:
+            message_chain.remove(platform_message.At(query.adapter.bot_account_id))
 
-            if message_chain.has(mirai.At(query.adapter.bot_account_id)):  # 回复消息时会at两次，检查并删除重复的
-                message_chain.remove(mirai.At(query.adapter.bot_account_id))
+            if message_chain.has(platform_message.At(query.adapter.bot_account_id)):  # 回复消息时会at两次，检查并删除重复的
+                message_chain.remove(platform_message.At(query.adapter.bot_account_id))
 
             return entities.RuleJudgeResult(
                 matching=True,

pkg/pipeline/resprule/rules/prefix.py

@@ -1,8 +1,8 @@
-import mirai
 
 from .. import rule as rule_model
 from .. import entities
 from ....core import entities as core_entities
+from ....platform.types import message as platform_message
 
 
 @rule_model.rule_class("prefix")
@@ -11,7 +11,7 @@ class PrefixRule(rule_model.GroupRespondRule):
     async def match(
         self,
         message_text: str,
-        message_chain: mirai.MessageChain,
+        message_chain: platform_message.MessageChain,
         rule_dict: dict,
         query: core_entities.Query
     ) -> entities.RuleJudgeResult:
@@ -22,7 +22,7 @@ class PrefixRule(rule_model.GroupRespondRule):
 
                 # 查找第一个plain元素
                 for me in message_chain:
-                    if isinstance(me, mirai.Plain):
+                    if isinstance(me, platform_message.Plain):
                         me.text = me.text[len(prefix):]
 
                 return entities.RuleJudgeResult(

pkg/pipeline/resprule/rules/random.py

@@ -1,10 +1,10 @@
 import random
 
-import mirai
 
 from .. import rule as rule_model
 from .. import entities
 from ....core import entities as core_entities
+from ....platform.types import message as platform_message
 
 
 @rule_model.rule_class("random")
@@ -13,7 +13,7 @@ class RandomRespRule(rule_model.GroupRespondRule):
     async def match(
         self,
         message_text: str,
-        message_chain: mirai.MessageChain,
+        message_chain: platform_message.MessageChain,
         rule_dict: dict,
         query: core_entities.Query
     ) -> entities.RuleJudgeResult:

pkg/pipeline/resprule/rules/regexp.py

@@ -1,10 +1,10 @@
 import re
 
-import mirai
 
 from .. import rule as rule_model
 from .. import entities
 from ....core import entities as core_entities
+from ....platform.types import message as platform_message
 
 
 @rule_model.rule_class("regexp")
@@ -13,7 +13,7 @@ class RegExpRule(rule_model.GroupRespondRule):
     async def match(
         self,
         message_text: str,
-        message_chain: mirai.MessageChain,
+        message_chain: platform_message.MessageChain,
         rule_dict: dict,
         query: core_entities.Query
     ) -> entities.RuleJudgeResult:

pkg/pipeline/stagemgr.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-import pydantic
-
 from ..core import app
 from . import stage
 from .resprule import resprule

pkg/pipeline/wrapper/wrapper.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import typing
 
-import mirai
 
 from ...core import app, entities as core_entities
 from .. import entities
@@ -10,6 +9,7 @@ from .. import stage, entities, stagemgr
 from ...core import entities as core_entities
 from ...config import manager as cfg_mgr
 from ...plugin import events
+from ...platform.types import message as platform_message
 
 
 @stage.stage_class("ResponseWrapper")
@@ -34,7 +34,7 @@ class ResponseWrapper(stage.PipelineStage):
         """
 
         # 如果 resp_messages[-1] 已经是 MessageChain 了
-        if isinstance(query.resp_messages[-1], mirai.MessageChain):
+        if isinstance(query.resp_messages[-1], platform_message.MessageChain):
             query.resp_message_chain.append(query.resp_messages[-1])
 
             yield entities.StageProcessResult(
@@ -45,19 +45,14 @@ class ResponseWrapper(stage.PipelineStage):
         else:
         
             if query.resp_messages[-1].role == 'command':
-                # query.resp_message_chain.append(mirai.MessageChain("[bot] "+query.resp_messages[-1].content))
-                query.resp_message_chain.append(query.resp_messages[-1].get_content_mirai_message_chain(prefix_text='[bot] '))
+                query.resp_message_chain.append(query.resp_messages[-1].get_content_platform_message_chain(prefix_text='[bot] '))
 
                 yield entities.StageProcessResult(
                     result_type=entities.ResultType.CONTINUE,
                     new_query=query
                 )
             elif query.resp_messages[-1].role == 'plugin':
-                # if not isinstance(query.resp_messages[-1].content, mirai.MessageChain):
-                #     query.resp_message_chain.append(mirai.MessageChain(query.resp_messages[-1].content))
-                # else:
-                #     query.resp_message_chain.append(query.resp_messages[-1].content)
-                query.resp_message_chain.append(query.resp_messages[-1].get_content_mirai_message_chain())
+                query.resp_message_chain.append(query.resp_messages[-1].get_content_platform_message_chain())
 
                 yield entities.StageProcessResult(
                     result_type=entities.ResultType.CONTINUE,
@@ -72,7 +67,7 @@ class ResponseWrapper(stage.PipelineStage):
                     reply_text = ''
 
                     if result.content:  # 有内容
-                        reply_text = str(result.get_content_mirai_message_chain())
+                        reply_text = str(result.get_content_platform_message_chain())
 
                         # ============= 触发插件事件 ===============
                         event_ctx = await self.ap.plugin_mgr.emit_event(
@@ -96,11 +91,11 @@ class ResponseWrapper(stage.PipelineStage):
                         else:
                             if event_ctx.event.reply is not None:
                                 
-                                query.resp_message_chain.append(mirai.MessageChain(event_ctx.event.reply))
+                                query.resp_message_chain.append(platform_message.MessageChain(event_ctx.event.reply))
 
                             else:
 
-                                query.resp_message_chain.append(result.get_content_mirai_message_chain())
+                                query.resp_message_chain.append(result.get_content_platform_message_chain())
 
                             yield entities.StageProcessResult(
                                 result_type=entities.ResultType.CONTINUE,
@@ -113,7 +108,7 @@ class ResponseWrapper(stage.PipelineStage):
 
                         reply_text = f'调用函数 {".".join(function_names)}...'
 
-                        query.resp_message_chain.append(mirai.MessageChain([mirai.Plain(reply_text)]))
+                        query.resp_message_chain.append(platform_message.MessageChain([platform_message.Plain(reply_text)]))
 
                         if self.ap.platform_cfg.data['track-function-calls']:
                             
@@ -139,11 +134,11 @@ class ResponseWrapper(stage.PipelineStage):
                             else:
                                 if event_ctx.event.reply is not None:
                                     
-                                    query.resp_message_chain.append(mirai.MessageChain(event_ctx.event.reply))
+                                    query.resp_message_chain.append(platform_message.MessageChain(event_ctx.event.reply))
 
                                 else:
 
-                                    query.resp_message_chain.append(mirai.MessageChain([mirai.Plain(reply_text)]))
+                                    query.resp_message_chain.append(platform_message.MessageChain([platform_message.Plain(reply_text)]))
 
                                 yield entities.StageProcessResult(
                                     result_type=entities.ResultType.CONTINUE,

pkg/platform/adapter.py

@@ -4,9 +4,10 @@ from __future__ import annotations
 import typing
 import abc
 
-import mirai
 
 from ..core import app
+from .types import message as platform_message
+from .types import events as platform_events
 
 
 preregistered_adapters: list[typing.Type[MessageSourceAdapter]] = []
@@ -55,28 +56,28 @@ class MessageSourceAdapter(metaclass=abc.ABCMeta):
         self,
         target_type: str,
         target_id: str,
-        message: mirai.MessageChain
+        message: platform_message.MessageChain
     ):
         """主动发送消息
         
         Args:
             target_type (str): 目标类型，`person`或`group`
             target_id (str): 目标ID
-            message (mirai.MessageChain): YiriMirai库的消息链
+            message (platform.types.MessageChain): 消息链
         """
         raise NotImplementedError
 
     async def reply_message(
         self,
-        message_source: mirai.MessageEvent,
-        message: mirai.MessageChain,
+        message_source: platform_events.MessageEvent,
+        message: platform_message.MessageChain,
         quote_origin: bool = False
     ):
         """回复消息
 
         Args:
-            message_source (mirai.MessageEvent): YiriMirai消息源事件
-            message (mirai.MessageChain): YiriMirai库的消息链
+            message_source (platform.types.MessageEvent): 消息源事件
+            message (platform.types.MessageChain): 消息链
             quote_origin (bool, optional): 是否引用原消息. Defaults to False.
         """
         raise NotImplementedError
@@ -87,27 +88,27 @@ class MessageSourceAdapter(metaclass=abc.ABCMeta):
 
     def register_listener(
         self,
-        event_type: typing.Type[mirai.Event],
-        callback: typing.Callable[[mirai.Event, MessageSourceAdapter], None]
+        event_type: typing.Type[platform_message.Event],
+        callback: typing.Callable[[platform_message.Event, MessageSourceAdapter], None]
     ):
         """注册事件监听器
         
         Args:
-            event_type (typing.Type[mirai.Event]): YiriMirai事件类型
-            callback (typing.Callable[[mirai.Event], None]): 回调函数，接收一个参数，为YiriMirai事件
+            event_type (typing.Type[platform.types.Event]): 事件类型
+            callback (typing.Callable[[platform.types.Event], None]): 回调函数，接收一个参数，为事件
         """
         raise NotImplementedError
     
     def unregister_listener(
         self,
-        event_type: typing.Type[mirai.Event],
-        callback: typing.Callable[[mirai.Event, MessageSourceAdapter], None]
+        event_type: typing.Type[platform_message.Event],
+        callback: typing.Callable[[platform_message.Event, MessageSourceAdapter], None]
     ):
         """注销事件监听器
         
         Args:
-            event_type (typing.Type[mirai.Event]): YiriMirai事件类型
-            callback (typing.Callable[[mirai.Event], None]): 回调函数，接收一个参数，为YiriMirai事件
+            event_type (typing.Type[platform.types.Event]): 事件类型
+            callback (typing.Callable[[platform.types.Event], None]): 回调函数，接收一个参数，为事件
         """
         raise NotImplementedError
 
@@ -127,26 +128,26 @@ class MessageSourceAdapter(metaclass=abc.ABCMeta):
 class MessageConverter:
     """消息链转换器基类"""
     @staticmethod
-    def yiri2target(message_chain: mirai.MessageChain):
-        """将YiriMirai消息链转换为目标消息链
+    def yiri2target(message_chain: platform_message.MessageChain):
+        """将源平台消息链转换为目标平台消息链
 
         Args:
-            message_chain (mirai.MessageChain): YiriMirai消息链
+            message_chain (platform.types.MessageChain): 源平台消息链
 
         Returns:
-            typing.Any: 目标消息链
+            typing.Any: 目标平台消息链
         """
         raise NotImplementedError
 
     @staticmethod
-    def target2yiri(message_chain: typing.Any) -> mirai.MessageChain:
-        """将目标消息链转换为YiriMirai消息链
+    def target2yiri(message_chain: typing.Any) -> platform_message.MessageChain:
+        """将目标平台消息链转换为源平台消息链
 
         Args:
-            message_chain (typing.Any): 目标消息链
+            message_chain (typing.Any): 目标平台消息链
 
         Returns:
-            mirai.MessageChain: YiriMirai消息链
+            platform.types.MessageChain: 源平台消息链
         """
         raise NotImplementedError
 
@@ -155,25 +156,25 @@ class EventConverter:
     """事件转换器基类"""
 
     @staticmethod
-    def yiri2target(event: typing.Type[mirai.Event]):
-        """将YiriMirai事件转换为目标事件
+    def yiri2target(event: typing.Type[platform_message.Event]):
+        """将源平台事件转换为目标平台事件
 
         Args:
-            event (typing.Type[mirai.Event]): YiriMirai事件
+            event (typing.Type[platform.types.Event]): 源平台事件
 
         Returns:
-            typing.Any: 目标事件
+            typing.Any: 目标平台事件
         """
         raise NotImplementedError
 
     @staticmethod
-    def target2yiri(event: typing.Any) -> mirai.Event:
-        """将目标事件的调用参数转换为YiriMirai的事件参数对象
+    def target2yiri(event: typing.Any) -> platform_message.Event:
+        """将目标平台事件的调用参数转换为源平台的事件参数对象
 
         Args:
-            event (typing.Any): 目标事件
+            event (typing.Any): 目标平台事件
 
         Returns:
-            typing.Type[mirai.Event]: YiriMirai事件
+            typing.Type[platform.types.Event]: 源平台事件
         """
         raise NotImplementedError

pkg/platform/manager.py

@@ -2,17 +2,24 @@ from __future__ import annotations
 
 import json
 import os
+import sys
 import logging
 import asyncio
 import traceback
 
-from mirai import At, GroupMessage, MessageEvent, StrangerMessage, \
-    FriendMessage, Image, MessageChain, Plain
-import mirai
+#     FriendMessage, Image, MessageChain, Plain
 from ..platform import adapter as msadapter
 
 from ..core import app, entities as core_entities
 from ..plugin import events
+from .types import message as platform_message
+from .types import events as platform_events
+from .types import entities as platform_entities
+
+# 处理 3.4 移除了 YiriMirai 之后，插件的兼容性问题
+from . import types as mirai
+sys.modules['mirai'] = mirai
+
 
 # 控制QQ消息输入输出的类
 class PlatformManager:
@@ -30,76 +37,40 @@ class PlatformManager:
     
     async def initialize(self):
 
-        from .sources import yirimirai, nakuru, aiocqhttp, qqbotpy
+        from .sources import nakuru, aiocqhttp, qqbotpy
 
-        async def on_friend_message(event: FriendMessage, adapter: msadapter.MessageSourceAdapter):
+        async def on_friend_message(event: platform_events.FriendMessage, adapter: msadapter.MessageSourceAdapter):
 
-            event_ctx = await self.ap.plugin_mgr.emit_event(
-                event=events.PersonMessageReceived(
-                    launcher_type='person',
-                    launcher_id=event.sender.id,
-                    sender_id=event.sender.id,
-                    message_chain=event.message_chain,
-                    query=None
-                )
+            await self.ap.query_pool.add_query(
+                launcher_type=core_entities.LauncherTypes.PERSON,
+                launcher_id=event.sender.id,
+                sender_id=event.sender.id,
+                message_event=event,
+                message_chain=event.message_chain,
+                adapter=adapter
             )
 
-            if not event_ctx.is_prevented_default():
-
-                await self.ap.query_pool.add_query(
-                    launcher_type=core_entities.LauncherTypes.PERSON,
-                    launcher_id=event.sender.id,
-                    sender_id=event.sender.id,
-                    message_event=event,
-                    message_chain=event.message_chain,
-                    adapter=adapter
-                )
-
-        async def on_stranger_message(event: StrangerMessage, adapter: msadapter.MessageSourceAdapter):
+        async def on_stranger_message(event: platform_events.StrangerMessage, adapter: msadapter.MessageSourceAdapter):
             
-            event_ctx = await self.ap.plugin_mgr.emit_event(
-                event=events.PersonMessageReceived(
-                    launcher_type='person',
-                    launcher_id=event.sender.id,
-                    sender_id=event.sender.id,
-                    message_chain=event.message_chain,
-                    query=None
-                )
+            await self.ap.query_pool.add_query(
+                launcher_type=core_entities.LauncherTypes.PERSON,
+                launcher_id=event.sender.id,
+                sender_id=event.sender.id,
+                message_event=event,
+                message_chain=event.message_chain,
+                adapter=adapter
             )
 
-            if not event_ctx.is_prevented_default():
+        async def on_group_message(event: platform_events.GroupMessage, adapter: msadapter.MessageSourceAdapter):
 
-                await self.ap.query_pool.add_query(
-                    launcher_type=core_entities.LauncherTypes.PERSON,
-                    launcher_id=event.sender.id,
-                    sender_id=event.sender.id,
-                    message_event=event,
-                    message_chain=event.message_chain,
-                    adapter=adapter
-                )
-
-        async def on_group_message(event: GroupMessage, adapter: msadapter.MessageSourceAdapter):
-
-            event_ctx = await self.ap.plugin_mgr.emit_event(
-                event=events.GroupMessageReceived(
-                    launcher_type='group',
-                    launcher_id=event.group.id,
-                    sender_id=event.sender.id,
-                    message_chain=event.message_chain,
-                    query=None
-                )
+            await self.ap.query_pool.add_query(
+                launcher_type=core_entities.LauncherTypes.GROUP,
+                launcher_id=event.group.id,
+                sender_id=event.sender.id,
+                message_event=event,
+                message_chain=event.message_chain,
+                adapter=adapter
             )
-
-            if not event_ctx.is_prevented_default():
-
-                await self.ap.query_pool.add_query(
-                    launcher_type=core_entities.LauncherTypes.GROUP,
-                    launcher_id=event.group.id,
-                    sender_id=event.sender.id,
-                    message_event=event,
-                    message_chain=event.message_chain,
-                    adapter=adapter
-                )
         
         index = 0
 
@@ -127,16 +98,16 @@ class PlatformManager:
 
                         if adapter_name == 'yiri-mirai':
                             adapter_inst.register_listener(
-                                StrangerMessage,
+                                platform_events.StrangerMessage,
                                 on_stranger_message
                             )
 
                         adapter_inst.register_listener(
-                            FriendMessage,
+                            platform_events.FriendMessage,
                             on_friend_message
                         )
                         adapter_inst.register_listener(
-                            GroupMessage,
+                            platform_events.GroupMessage,
                             on_group_message
                         )
                 
@@ -146,13 +117,13 @@ class PlatformManager:
         if len(self.adapters) == 0:
             self.ap.logger.warning('未运行平台适配器，请根据文档配置并启用平台适配器。')
 
-    async def send(self, event: mirai.MessageEvent, msg: mirai.MessageChain, adapter: msadapter.MessageSourceAdapter):
+    async def send(self, event: platform_events.MessageEvent, msg: platform_message.MessageChain, adapter: msadapter.MessageSourceAdapter):
         
-        if self.ap.platform_cfg.data['at-sender'] and isinstance(event, GroupMessage):
+        if self.ap.platform_cfg.data['at-sender'] and isinstance(event, platform_events.GroupMessage):
 
             msg.insert(
                 0,
-                At(
+                platform_message.At(
                     event.sender.id
                 )
             )
@@ -167,19 +138,30 @@ class PlatformManager:
         try:
             tasks = []
             for adapter in self.adapters:
-                async def exception_wrapper(adapter):
+                async def exception_wrapper(adapter: msadapter.MessageSourceAdapter):
                     try:
                         await adapter.run_async()
                     except Exception as e:
+                        if isinstance(e, asyncio.CancelledError):
+                            return
                         self.ap.logger.error('平台适配器运行出错: ' + str(e))
                         self.ap.logger.debug(f"Traceback: {traceback.format_exc()}")
 
                 tasks.append(exception_wrapper(adapter))
             
             for task in tasks:
-                asyncio.create_task(task)
+                self.ap.task_mgr.create_task(
+                    task,
+                    kind="platform-adapter",
+                    name=f"platform-adapter-{adapter.name}",
+                    scopes=[core_entities.LifecycleControlScope.APPLICATION, core_entities.LifecycleControlScope.PLATFORM],
+                )
 
         except Exception as e:
             self.ap.logger.error('平台适配器运行出错: ' + str(e))
             self.ap.logger.debug(f"Traceback: {traceback.format_exc()}")
-
+    
+    async def shutdown(self):
+        for adapter in self.adapters:
+            await adapter.kill()
+        self.ap.task_mgr.cancel_by_scope(core_entities.LifecycleControlScope.PLATFORM)

pkg/platform/sources/aiocqhttp.py

@@ -5,31 +5,33 @@ import traceback
 import time
 import datetime
 
-import mirai
-import mirai.models.message as yiri_message
 import aiocqhttp
+import aiohttp
 
 from .. import adapter
 from ...pipeline.longtext.strategies import forward
 from ...core import app
-
+from ..types import message as platform_message
+from ..types import events as platform_events
+from ..types import entities as platform_entities
+from ...utils import image
 
 class AiocqhttpMessageConverter(adapter.MessageConverter):
 
     @staticmethod
-    def yiri2target(message_chain: mirai.MessageChain) -> typing.Tuple[list, int, datetime.datetime]:
+    async def yiri2target(message_chain: platform_message.MessageChain) -> typing.Tuple[list, int, datetime.datetime]:
         msg_list = aiocqhttp.Message()
 
         msg_id = 0
         msg_time = None
 
         for msg in message_chain:
-            if type(msg) is mirai.Plain:
+            if type(msg) is platform_message.Plain:
                 msg_list.append(aiocqhttp.MessageSegment.text(msg.text))
-            elif type(msg) is yiri_message.Source:
+            elif type(msg) is platform_message.Source:
                 msg_id = msg.id
                 msg_time = msg.time
-            elif type(msg) is mirai.Image:
+            elif type(msg) is platform_message.Image:
                 arg = ''
                 if msg.base64:
                     arg = msg.base64
@@ -40,13 +42,11 @@ class AiocqhttpMessageConverter(adapter.MessageConverter):
                 elif msg.path:
                     arg = msg.path
                     msg_list.append(aiocqhttp.MessageSegment.image(arg))
-            elif type(msg) is mirai.At:
+            elif type(msg) is platform_message.At:
                 msg_list.append(aiocqhttp.MessageSegment.at(msg.target))
-            elif type(msg) is mirai.AtAll:
+            elif type(msg) is platform_message.AtAll:
                 msg_list.append(aiocqhttp.MessageSegment.at("all"))
-            elif type(msg) is mirai.Face:
-                msg_list.append(aiocqhttp.MessageSegment.face(msg.face_id))
-            elif type(msg) is mirai.Voice:
+            elif type(msg) is platform_message.Voice:
                 arg = ''
                 if msg.base64:
                     arg = msg.base64
@@ -60,7 +60,7 @@ class AiocqhttpMessageConverter(adapter.MessageConverter):
             elif type(msg) is forward.Forward:
 
                 for node in msg.node_list:
-                    msg_list.extend(AiocqhttpMessageConverter.yiri2target(node.message_chain)[0])
+                    msg_list.extend(await AiocqhttpMessageConverter.yiri2target(node.message_chain)[0])
                 
             else:
                 msg_list.append(aiocqhttp.MessageSegment.text(str(msg)))
@@ -68,31 +68,32 @@ class AiocqhttpMessageConverter(adapter.MessageConverter):
         return msg_list, msg_id, msg_time
 
     @staticmethod
-    def target2yiri(message: str, message_id: int = -1):
+    async def target2yiri(message: str, message_id: int = -1):
         message = aiocqhttp.Message(message)
 
         yiri_msg_list = []
 
         yiri_msg_list.append(
-            yiri_message.Source(id=message_id, time=datetime.datetime.now())
+            platform_message.Source(id=message_id, time=datetime.datetime.now())
         )
 
         for msg in message:
             if msg.type == "at":
                 if msg.data["qq"] == "all":
-                    yiri_msg_list.append(yiri_message.AtAll())
+                    yiri_msg_list.append(platform_message.AtAll())
                 else:
                     yiri_msg_list.append(
-                        yiri_message.At(
+                        platform_message.At(
                             target=msg.data["qq"],
                         )
                     )
             elif msg.type == "text":
-                yiri_msg_list.append(yiri_message.Plain(text=msg.data["text"]))
+                yiri_msg_list.append(platform_message.Plain(text=msg.data["text"]))
             elif msg.type == "image":
-                yiri_msg_list.append(yiri_message.Image(url=msg.data["url"]))
+                image_base64, image_format = await image.qq_image_url_to_base64(msg.data['url'])
+                yiri_msg_list.append(platform_message.Image(base64=f"data:image/{image_format};base64,{image_base64}"))
 
-        chain = mirai.MessageChain(yiri_msg_list)
+        chain = platform_message.MessageChain(yiri_msg_list)
 
         return chain
 
@@ -100,11 +101,11 @@ class AiocqhttpMessageConverter(adapter.MessageConverter):
 class AiocqhttpEventConverter(adapter.EventConverter):
 
     @staticmethod
-    def yiri2target(event: mirai.Event, bot_account_id: int):
+    async def yiri2target(event: platform_events.Event, bot_account_id: int):
 
-        msg, msg_id, msg_time = AiocqhttpMessageConverter.yiri2target(event.message_chain)
+        msg, msg_id, msg_time = await AiocqhttpMessageConverter.yiri2target(event.message_chain)
 
-        if type(event) is mirai.GroupMessage:
+        if type(event) is platform_events.GroupMessage:
             role = "member"
 
             if event.sender.permission == "ADMINISTRATOR":
@@ -140,7 +141,7 @@ class AiocqhttpEventConverter(adapter.EventConverter):
             }
 
             return aiocqhttp.Event.from_payload(payload)
-        elif type(event) is mirai.FriendMessage:
+        elif type(event) is platform_events.FriendMessage:
 
             payload = {
                 "post_type": "message",
@@ -165,27 +166,28 @@ class AiocqhttpEventConverter(adapter.EventConverter):
             return aiocqhttp.Event.from_payload(payload)
 
     @staticmethod
-    def target2yiri(event: aiocqhttp.Event):
-        yiri_chain = AiocqhttpMessageConverter.target2yiri(
+    async def target2yiri(event: aiocqhttp.Event):
+        yiri_chain = await AiocqhttpMessageConverter.target2yiri(
             event.message, event.message_id
         )
 
         if event.message_type == "group":
             permission = "MEMBER"
 
-            if event.sender["role"] == "admin":
-                permission = "ADMINISTRATOR"
-            elif event.sender["role"] == "owner":
-                permission = "OWNER"
-            converted_event = mirai.GroupMessage(
-                sender=mirai.models.entities.GroupMember(
+            if "role" in event.sender:
+                if event.sender["role"] == "admin":
+                    permission = "ADMINISTRATOR"
+                elif event.sender["role"] == "owner":
+                    permission = "OWNER"
+            converted_event = platform_events.GroupMessage(
+                sender=platform_entities.GroupMember(
                     id=event.sender["user_id"],  # message_seq 放哪？
                     member_name=event.sender["nickname"],
                     permission=permission,
-                    group=mirai.models.entities.Group(
+                    group=platform_entities.Group(
                         id=event.group_id,
                         name=event.sender["nickname"],
-                        permission=mirai.models.entities.Permission.Member,
+                        permission=platform_entities.Permission.Member,
                     ),
                     special_title=event.sender["title"] if "title" in event.sender else "",
                     join_timestamp=0,
@@ -197,8 +199,8 @@ class AiocqhttpEventConverter(adapter.EventConverter):
             )
             return converted_event
         elif event.message_type == "private":
-            return mirai.FriendMessage(
-                sender=mirai.models.entities.Friend(
+            return platform_events.FriendMessage(
+                sender=platform_entities.Friend(
                     id=event.sender["user_id"],
                     nickname=event.sender["nickname"],
                     remark="",
@@ -240,9 +242,9 @@ class AiocqhttpAdapter(adapter.MessageSourceAdapter):
             self.bot = aiocqhttp.CQHttp()
 
     async def send_message(
-        self, target_type: str, target_id: str, message: mirai.MessageChain
+        self, target_type: str, target_id: str, message: platform_message.MessageChain
     ):
-        aiocq_msg = AiocqhttpMessageConverter.yiri2target(message)[0]
+        aiocq_msg = await AiocqhttpMessageConverter.yiri2target(message)[0]
 
         if target_type == "group":
             await self.bot.send_group_msg(group_id=int(target_id), message=aiocq_msg)
@@ -251,12 +253,12 @@ class AiocqhttpAdapter(adapter.MessageSourceAdapter):
 
     async def reply_message(
         self,
-        message_source: mirai.MessageEvent,
-        message: mirai.MessageChain,
+        message_source: platform_events.MessageEvent,
+        message: platform_message.MessageChain,
         quote_origin: bool = False,
     ):  
-        aiocq_event = AiocqhttpEventConverter.yiri2target(message_source, self.bot_account_id)
-        aiocq_msg = AiocqhttpMessageConverter.yiri2target(message)[0]
+        aiocq_event = await AiocqhttpEventConverter.yiri2target(message_source, self.bot_account_id)
+        aiocq_msg = (await AiocqhttpMessageConverter.yiri2target(message))[0]
         if quote_origin:
             aiocq_msg = aiocqhttp.MessageSegment.reply(aiocq_event.message_id) + aiocq_msg
 
@@ -270,25 +272,25 @@ class AiocqhttpAdapter(adapter.MessageSourceAdapter):
 
     def register_listener(
         self,
-        event_type: typing.Type[mirai.Event],
-        callback: typing.Callable[[mirai.Event, adapter.MessageSourceAdapter], None],
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[[platform_events.Event, adapter.MessageSourceAdapter], None],
     ):
         async def on_message(event: aiocqhttp.Event):
             self.bot_account_id = event.self_id
             try:
-                return await callback(self.event_converter.target2yiri(event), self)
+                return await callback(await self.event_converter.target2yiri(event), self)
             except:
                 traceback.print_exc()
 
-        if event_type == mirai.GroupMessage:
+        if event_type == platform_events.GroupMessage:
             self.bot.on_message("group")(on_message)
-        elif event_type == mirai.FriendMessage:
+        elif event_type == platform_events.FriendMessage:
             self.bot.on_message("private")(on_message)
 
     def unregister_listener(
         self,
-        event_type: typing.Type[mirai.Event],
-        callback: typing.Callable[[mirai.Event, adapter.MessageSourceAdapter], None],
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[[platform_events.Event, adapter.MessageSourceAdapter], None],
     ):
         return super().unregister_listener(event_type, callback)
 

pkg/platform/sources/nakuru.py

@@ -6,26 +6,28 @@ import typing
 import traceback
 import logging
 
-import mirai
 
 import nakuru
 import nakuru.entities.components as nkc
 
 from .. import adapter as adapter_model
 from ...pipeline.longtext.strategies import forward
+from ...platform.types import message as platform_message
+from ...platform.types import entities as platform_entities
+from ...platform.types import events as platform_events
 
 
 class NakuruProjectMessageConverter(adapter_model.MessageConverter):
     """消息转换器"""
     @staticmethod
-    def yiri2target(message_chain: mirai.MessageChain) -> list:
+    def yiri2target(message_chain: platform_message.MessageChain) -> list:
         msg_list = []
-        if type(message_chain) is mirai.MessageChain:
+        if type(message_chain) is platform_message.MessageChain:
             msg_list = message_chain.__root__
         elif type(message_chain) is list:
             msg_list = message_chain
         elif type(message_chain) is str:
-            msg_list = [mirai.Plain(message_chain)]
+            msg_list = [platform_message.Plain(message_chain)]
         else:
             raise Exception("Unknown message type: " + str(message_chain) + str(type(message_chain)))
         
@@ -33,22 +35,20 @@ class NakuruProjectMessageConverter(adapter_model.MessageConverter):
         
         # 遍历并转换
         for component in msg_list:
-            if type(component) is mirai.Plain:
+            if type(component) is platform_message.Plain:
                 nakuru_msg_list.append(nkc.Plain(component.text, False))
-            elif type(component) is mirai.Image:
+            elif type(component) is platform_message.Image:
                 if component.url is not None:
                     nakuru_msg_list.append(nkc.Image.fromURL(component.url))
                 elif component.base64 is not None:
                     nakuru_msg_list.append(nkc.Image.fromBase64(component.base64))
                 elif component.path is not None:
                     nakuru_msg_list.append(nkc.Image.fromFileSystem(component.path))
-            elif type(component) is mirai.Face:
-                nakuru_msg_list.append(nkc.Face(id=component.face_id))
-            elif type(component) is mirai.At:
+            elif type(component) is platform_message.At:
                 nakuru_msg_list.append(nkc.At(qq=component.target))
-            elif type(component) is mirai.AtAll:
+            elif type(component) is platform_message.AtAll:
                 nakuru_msg_list.append(nkc.AtAll())
-            elif type(component) is mirai.Voice:
+            elif type(component) is platform_message.Voice:
                 if component.url is not None:
                     nakuru_msg_list.append(nkc.Record.fromURL(component.url))
                 elif component.path is not None:
@@ -80,49 +80,47 @@ class NakuruProjectMessageConverter(adapter_model.MessageConverter):
         return nakuru_msg_list
 
     @staticmethod
-    def target2yiri(message_chain: typing.Any, message_id: int = -1) -> mirai.MessageChain:
+    def target2yiri(message_chain: typing.Any, message_id: int = -1) -> platform_message.MessageChain:
         """将Yiri的消息链转换为YiriMirai的消息链"""
         assert type(message_chain) is list
 
         yiri_msg_list = []
         import datetime
         # 添加Source组件以标记message_id等信息
-        yiri_msg_list.append(mirai.models.message.Source(id=message_id, time=datetime.datetime.now()))
+        yiri_msg_list.append(platform_message.Source(id=message_id, time=datetime.datetime.now()))
         for component in message_chain:
             if type(component) is nkc.Plain:
-                yiri_msg_list.append(mirai.Plain(text=component.text))
+                yiri_msg_list.append(platform_message.Plain(text=component.text))
             elif type(component) is nkc.Image:
-                yiri_msg_list.append(mirai.Image(url=component.url))
-            elif type(component) is nkc.Face:
-                yiri_msg_list.append(mirai.Face(face_id=component.id))
+                yiri_msg_list.append(platform_message.Image(url=component.url))
             elif type(component) is nkc.At:
-                yiri_msg_list.append(mirai.At(target=component.qq))
+                yiri_msg_list.append(platform_message.At(target=component.qq))
             elif type(component) is nkc.AtAll:
-                yiri_msg_list.append(mirai.AtAll())
+                yiri_msg_list.append(platform_message.AtAll())
             else:
                 pass
         # logging.debug("转换后的消息链: " + str(yiri_msg_list))
-        chain = mirai.MessageChain(yiri_msg_list)
+        chain = platform_message.MessageChain(yiri_msg_list)
         return chain
 
 
 class NakuruProjectEventConverter(adapter_model.EventConverter):
     """事件转换器"""
     @staticmethod
-    def yiri2target(event: typing.Type[mirai.Event]):
-        if event is mirai.GroupMessage:
+    def yiri2target(event: typing.Type[platform_events.Event]):
+        if event is platform_events.GroupMessage:
             return nakuru.GroupMessage
-        elif event is mirai.FriendMessage:
+        elif event is platform_events.FriendMessage:
             return nakuru.FriendMessage
         else:
             raise Exception("未支持转换的事件类型: " + str(event))
 
     @staticmethod
-    def target2yiri(event: typing.Any) -> mirai.Event:
+    def target2yiri(event: typing.Any) -> platform_events.Event:
         yiri_chain = NakuruProjectMessageConverter.target2yiri(event.message, event.message_id)
         if type(event) is nakuru.FriendMessage:  # 私聊消息事件
-            return mirai.FriendMessage(
-                sender=mirai.models.entities.Friend(
+            return platform_events.FriendMessage(
+                sender=platform_entities.Friend(
                     id=event.sender.user_id,
                     nickname=event.sender.nickname,
                     remark=event.sender.nickname
@@ -138,16 +136,15 @@ class NakuruProjectEventConverter(adapter_model.EventConverter):
             elif event.sender.role == "owner":
                 permission = "OWNER"
 
-            import mirai.models.entities as entities
-            return mirai.GroupMessage(
-                sender=mirai.models.entities.GroupMember(
+            return platform_events.GroupMessage(
+                sender=platform_entities.GroupMember(
                     id=event.sender.user_id,
                     member_name=event.sender.nickname,
                     permission=permission,
-                    group=mirai.models.entities.Group(
+                    group=platform_entities.Group(
                         id=event.group_id,
                         name=event.sender.nickname,
-                        permission=entities.Permission.Member
+                        permission=platform_entities.Permission.Member
                     ),
                     special_title=event.sender.title,
                     join_timestamp=0,
@@ -189,7 +186,7 @@ class NakuruProjectAdapter(adapter_model.MessageSourceAdapter):
         self,
         target_type: str,
         target_id: str,
-        message: typing.Union[mirai.MessageChain, list],
+        message: typing.Union[platform_message.MessageChain, list],
         converted: bool = False
     ):
         task = None
@@ -222,8 +219,8 @@ class NakuruProjectAdapter(adapter_model.MessageSourceAdapter):
 
     async def reply_message(
         self,
-        message_source: mirai.MessageEvent,
-        message: mirai.MessageChain,
+        message_source: platform_events.MessageEvent,
+        message: platform_message.MessageChain,
         quote_origin: bool = False
     ):
         message = self.message_converter.yiri2target(message)
@@ -233,14 +230,14 @@ class NakuruProjectAdapter(adapter_model.MessageSourceAdapter):
                     id=message_source.message_chain.message_id,
                 )
             )
-        if type(message_source) is mirai.GroupMessage:
+        if type(message_source) is platform_events.GroupMessage:
             await self.send_message(
                 "group",
                 message_source.sender.group.id,
                 message,
                 converted=True
             )
-        elif type(message_source) is mirai.FriendMessage:
+        elif type(message_source) is platform_events.FriendMessage:
             await self.send_message(
                 "person",
                 message_source.sender.id,
@@ -258,8 +255,8 @@ class NakuruProjectAdapter(adapter_model.MessageSourceAdapter):
 
     def register_listener(
         self,
-        event_type: typing.Type[mirai.Event],
-        callback: typing.Callable[[mirai.Event, adapter_model.MessageSourceAdapter], None]
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[[platform_events.Event, adapter_model.MessageSourceAdapter], None]
     ):
         try:
 
@@ -286,8 +283,8 @@ class NakuruProjectAdapter(adapter_model.MessageSourceAdapter):
 
     def unregister_listener(
         self,
-        event_type: typing.Type[mirai.Event],
-        callback: typing.Callable[[mirai.Event, adapter_model.MessageSourceAdapter], None]
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[[platform_events.Event, adapter_model.MessageSourceAdapter], None]
     ):
         nakuru_event_name = self.event_converter.yiri2target(event_type).__name__
 
@@ -331,5 +328,5 @@ class NakuruProjectAdapter(adapter_model.MessageSourceAdapter):
         while True:
             await asyncio.sleep(1)
 
-    def kill(self) -> bool:
+    async def kill(self) -> bool:
         return False

pkg/platform/sources/qqbotpy.py

@@ -3,13 +3,9 @@ from __future__ import annotations
 import logging
 import typing
 import datetime
-import asyncio
 import re
 import traceback
-import json
-import threading
 
-import mirai
 import botpy
 import botpy.message as botpy_message
 import botpy.types.message as botpy_message_type
@@ -18,15 +14,20 @@ from .. import adapter as adapter_model
 from ...pipeline.longtext.strategies import forward
 from ...core import app
 from ...config import manager as cfg_mgr
+from ...platform.types import entities as platform_entities
+from ...platform.types import events as platform_events
+from ...platform.types import message as platform_message
 
 
-class OfficialGroupMessage(mirai.GroupMessage):
+class OfficialGroupMessage(platform_events.GroupMessage):
     pass
 
+class OfficialFriendMessage(platform_events.FriendMessage):
+    pass
 
 event_handler_mapping = {
-    mirai.GroupMessage: ["on_at_message_create", "on_group_at_message_create"],
-    mirai.FriendMessage: ["on_direct_message_create"],
+    platform_events.GroupMessage: ["on_at_message_create", "on_group_at_message_create"],
+    platform_events.FriendMessage: ["on_direct_message_create", "on_c2c_message_create"],
 }
 
 
@@ -122,16 +123,16 @@ class OfficialMessageConverter(adapter_model.MessageConverter):
     """QQ 官方消息转换器"""
 
     @staticmethod
-    def yiri2target(message_chain: mirai.MessageChain):
+    def yiri2target(message_chain: platform_message.MessageChain):
         """将 YiriMirai 的消息链转换为 QQ 官方消息"""
 
         msg_list = []
-        if type(message_chain) is mirai.MessageChain:
+        if type(message_chain) is platform_message.MessageChain:
             msg_list = message_chain.__root__
         elif type(message_chain) is list:
             msg_list = message_chain
         elif type(message_chain) is str:
-            msg_list = [mirai.Plain(text=message_chain)]
+            msg_list = [platform_message.Plain(text=message_chain)]
         else:
             raise Exception(
                 "Unknown message type: " + str(message_chain) + str(type(message_chain))
@@ -152,22 +153,22 @@ class OfficialMessageConverter(adapter_model.MessageConverter):
 
         # 遍历并转换
         for component in msg_list:
-            if type(component) is mirai.Plain:
+            if type(component) is platform_message.Plain:
                 offcial_messages.append({"type": "text", "content": component.text})
-            elif type(component) is mirai.Image:
+            elif type(component) is platform_message.Image:
                 if component.url is not None:
                     offcial_messages.append({"type": "image", "content": component.url})
                 elif component.path is not None:
                     offcial_messages.append(
                         {"type": "file_image", "content": component.path}
                     )
-            elif type(component) is mirai.At:
+            elif type(component) is platform_message.At:
                 offcial_messages.append({"type": "at", "content": ""})
-            elif type(component) is mirai.AtAll:
+            elif type(component) is platform_message.AtAll:
                 print(
                     "上层组件要求发送 AtAll 消息，但 QQ 官方 API 不支持此消息类型，忽略此消息。"
                 )
-            elif type(component) is mirai.Voice:
+            elif type(component) is platform_message.Voice:
                 print(
                     "上层组件要求发送 Voice 消息，但 QQ 官方 API 不支持此消息类型，忽略此消息。"
                 )
@@ -193,32 +194,32 @@ class OfficialMessageConverter(adapter_model.MessageConverter):
 
     @staticmethod
     def extract_message_chain_from_obj(
-        message: typing.Union[botpy_message.Message, botpy_message.DirectMessage],
+        message: typing.Union[botpy_message.Message, botpy_message.DirectMessage, botpy_message.GroupMessage, botpy_message.C2CMessage],
         message_id: str = None,
         bot_account_id: int = 0,
-    ) -> mirai.MessageChain:
+    ) -> platform_message.MessageChain:
         yiri_msg_list = []
         # 存id
 
         yiri_msg_list.append(
-            mirai.models.message.Source(
+            platform_message.Source(
                 id=save_msg_id(message_id), time=datetime.datetime.now()
             )
         )
 
-        if type(message) is not botpy_message.DirectMessage:
-            yiri_msg_list.append(mirai.At(target=bot_account_id))
+        if type(message) not in [botpy_message.DirectMessage, botpy_message.C2CMessage]:
+            yiri_msg_list.append(platform_message.At(target=bot_account_id))
 
         if hasattr(message, "mentions"):
             for mention in message.mentions:
                 if mention.bot:
                     continue
 
-                yiri_msg_list.append(mirai.At(target=mention.id))
+                yiri_msg_list.append(platform_message.At(target=mention.id))
 
         for attachment in message.attachments:
             if attachment.content_type.startswith("image"):
-                yiri_msg_list.append(mirai.Image(url=attachment.url))
+                yiri_msg_list.append(platform_message.Image(url=attachment.url))
             else:
                 logging.warning(
                     "不支持的附件类型：" + attachment.content_type + "，忽略此附件。"
@@ -226,9 +227,9 @@ class OfficialMessageConverter(adapter_model.MessageConverter):
 
         content = re.sub(r"<@!\d+>", "", str(message.content))
         if content.strip() != "":
-            yiri_msg_list.append(mirai.Plain(text=content))
+            yiri_msg_list.append(platform_message.Plain(text=content))
 
-        chain = mirai.MessageChain(yiri_msg_list)
+        chain = platform_message.MessageChain(yiri_msg_list)
 
         return chain
 
@@ -243,10 +244,10 @@ class OfficialEventConverter(adapter_model.EventConverter):
         self.member_openid_mapping = member_openid_mapping
         self.group_openid_mapping = group_openid_mapping
 
-    def yiri2target(self, event: typing.Type[mirai.Event]):
-        if event == mirai.GroupMessage:
+    def yiri2target(self, event: typing.Type[platform_events.Event]):
+        if event == platform_events.GroupMessage:
             return botpy_message.Message
-        elif event == mirai.FriendMessage:
+        elif event == platform_events.FriendMessage:
             return botpy_message.DirectMessage
         else:
             raise Exception(
@@ -255,9 +256,8 @@ class OfficialEventConverter(adapter_model.EventConverter):
 
     def target2yiri(
         self,
-        event: typing.Union[botpy_message.Message, botpy_message.DirectMessage]
-    ) -> mirai.Event:
-        import mirai.models.entities as mirai_entities
+        event: typing.Union[botpy_message.Message, botpy_message.DirectMessage, botpy_message.GroupMessage, botpy_message.C2CMessage],
+    ) -> platform_events.Event:
 
         if type(event) == botpy_message.Message:  # 频道内，转群聊事件
             permission = "MEMBER"
@@ -267,15 +267,15 @@ class OfficialEventConverter(adapter_model.EventConverter):
             elif "4" in event.member.roles:
                 permission = "OWNER"
 
-            return mirai.GroupMessage(
-                sender=mirai_entities.GroupMember(
+            return platform_events.GroupMessage(
+                sender=platform_entities.GroupMember(
                     id=event.author.id,
                     member_name=event.author.username,
                     permission=permission,
-                    group=mirai_entities.Group(
+                    group=platform_entities.Group(
                         id=event.channel_id,
                         name=event.author.username,
-                        permission=mirai_entities.Permission.Member,
+                        permission=platform_entities.Permission.Member,
                     ),
                     special_title="",
                     join_timestamp=int(
@@ -295,9 +295,9 @@ class OfficialEventConverter(adapter_model.EventConverter):
                     ).timestamp()
                 ),
             )
-        elif type(event) == botpy_message.DirectMessage:  # 私聊，转私聊事件
-            return mirai.FriendMessage(
-                sender=mirai_entities.Friend(
+        elif type(event) == botpy_message.DirectMessage:  # 频道私聊，转私聊事件
+            return platform_events.FriendMessage(
+                sender=platform_entities.Friend(
                     id=event.guild_id,
                     nickname=event.author.username,
                     remark=event.author.username,
@@ -311,19 +311,19 @@ class OfficialEventConverter(adapter_model.EventConverter):
                     ).timestamp()
                 ),
             )
-        elif type(event) == botpy_message.GroupMessage:
+        elif type(event) == botpy_message.GroupMessage:  # 群聊，转群聊事件
 
             replacing_member_id = self.member_openid_mapping.save_openid(event.author.member_openid)
 
             return OfficialGroupMessage(
-                sender=mirai_entities.GroupMember(
+                sender=platform_entities.GroupMember(
                     id=replacing_member_id,
                     member_name=replacing_member_id,
                     permission="MEMBER",
-                    group=mirai_entities.Group(
+                    group=platform_entities.Group(
                         id=self.group_openid_mapping.save_openid(event.group_openid),
                         name=replacing_member_id,
-                        permission=mirai_entities.Permission.Member,
+                        permission=platform_entities.Permission.Member,
                     ),
                     special_title="",
                     join_timestamp=int(0),
@@ -339,6 +339,25 @@ class OfficialEventConverter(adapter_model.EventConverter):
                     ).timestamp()
                 ),
             )
+        elif type(event) == botpy_message.C2CMessage:  # 私聊，转私聊事件
+
+            user_id_alter = self.member_openid_mapping.save_openid(event.author.user_openid)  # 实测这里的user_openid与group的member_openid是一样的
+
+            return OfficialFriendMessage(
+                sender=platform_entities.Friend(
+                    id=user_id_alter,
+                    nickname=user_id_alter,
+                    remark=user_id_alter,
+                ),
+                message_chain=OfficialMessageConverter.extract_message_chain_from_obj(
+                    event, event.id
+                ),
+                time=int(
+                    datetime.datetime.strptime(
+                        event.timestamp, "%Y-%m-%dT%H:%M:%S%z"
+                    ).timestamp()
+                ),
+            )
 
 
 @adapter_model.adapter_class("qq-botpy")
@@ -368,6 +387,7 @@ class OfficialAdapter(adapter_model.MessageSourceAdapter):
     group_openid_mapping: OpenIDMapping[str, int] = None
 
     group_msg_seq = None
+    c2c_msg_seq = None
 
     def __init__(self, cfg: dict, ap: app.Application):
         """初始化适配器"""
@@ -375,6 +395,7 @@ class OfficialAdapter(adapter_model.MessageSourceAdapter):
         self.ap = ap
 
         self.group_msg_seq = 1
+        self.c2c_msg_seq = 1
 
         switchs = {}
 
@@ -388,7 +409,7 @@ class OfficialAdapter(adapter_model.MessageSourceAdapter):
         self.bot = botpy.Client(intents=intents)
 
     async def send_message(
-        self, target_type: str, target_id: str, message: mirai.MessageChain
+        self, target_type: str, target_id: str, message: platform_message.MessageChain
     ):
         message_list = self.message_converter.yiri2target(message)
 
@@ -415,8 +436,8 @@ class OfficialAdapter(adapter_model.MessageSourceAdapter):
 
     async def reply_message(
         self,
-        message_source: mirai.MessageEvent,
-        message: mirai.MessageChain,
+        message_source: platform_events.MessageEvent,
+        message: platform_message.MessageChain,
         quote_origin: bool = False,
     ):
         
@@ -441,40 +462,80 @@ class OfficialAdapter(adapter_model.MessageSourceAdapter):
                     ]
                 )
 
-            if type(message_source) == mirai.GroupMessage:
+            if type(message_source) == platform_events.GroupMessage:
                 args["channel_id"] = str(message_source.sender.group.id)
                 args["msg_id"] = cached_message_ids[
                     str(message_source.message_chain.message_id)
                 ]
                 await self.bot.api.post_message(**args)
-            elif type(message_source) == mirai.FriendMessage:
+            elif type(message_source) == platform_events.FriendMessage:
                 args["guild_id"] = str(message_source.sender.id)
                 args["msg_id"] = cached_message_ids[
                     str(message_source.message_chain.message_id)
                 ]
                 await self.bot.api.post_dms(**args)
             elif type(message_source) == OfficialGroupMessage:
-                if "image" in args or "file_image" in args:
+
+                if "file_image" in args:  # 暂不支持发送文件图片
                     continue
+
                 args["group_openid"] = self.group_openid_mapping.getkey(
                     message_source.sender.group.id
                 )
 
+                if "image" in args:
+                    uploadMedia = await self.bot.api.post_group_file(
+                        group_openid=args["group_openid"],
+                        file_type=1,
+                        url=str(args['image'])
+                    )
+
+                    del args['image']
+                    args['media'] = uploadMedia
+                    args['msg_type'] = 7
+
                 args["msg_id"] = cached_message_ids[
                     str(message_source.message_chain.message_id)
                 ]
                 args["msg_seq"] = self.group_msg_seq
                 self.group_msg_seq += 1
+
                 await self.bot.api.post_group_message(**args)
+            elif type(message_source) == OfficialFriendMessage:
+                if "file_image" in args:
+                    continue
+                args["openid"] = self.member_openid_mapping.getkey(
+                    message_source.sender.id
+                )
+
+                if "image" in args:
+                    uploadMedia = await self.bot.api.post_c2c_file(
+                        openid=args["openid"],
+                        file_type=1,
+                        url=str(args['image'])
+                    )
+
+                    del args['image']
+                    args['media'] = uploadMedia
+                    args['msg_type'] = 7
+
+                args["msg_id"] = cached_message_ids[
+                    str(message_source.message_chain.message_id)
+                ]
+
+                args["msg_seq"] = self.c2c_msg_seq
+                self.c2c_msg_seq += 1
+
+                await self.bot.api.post_c2c_message(**args)
 
     async def is_muted(self, group_id: int) -> bool:
         return False
 
     def register_listener(
         self,
-        event_type: typing.Type[mirai.Event],
+        event_type: typing.Type[platform_events.Event],
         callback: typing.Callable[
-            [mirai.Event, adapter_model.MessageSourceAdapter], None
+            [platform_events.Event, adapter_model.MessageSourceAdapter], None
         ],
     ):
 
@@ -498,9 +559,9 @@ class OfficialAdapter(adapter_model.MessageSourceAdapter):
 
     def unregister_listener(
         self,
-        event_type: typing.Type[mirai.Event],
+        event_type: typing.Type[platform_events.Event],
         callback: typing.Callable[
-            [mirai.Event, adapter_model.MessageSourceAdapter], None
+            [platform_events.Event, adapter_model.MessageSourceAdapter], None
         ],
     ):
         delattr(self.bot, event_handler_mapping[event_type])
@@ -524,8 +585,12 @@ class OfficialAdapter(adapter_model.MessageSourceAdapter):
             self.member_openid_mapping, self.group_openid_mapping
         )
 
-        self.ap.logger.info("运行 QQ 官方适配器")
-        await self.bot.start(**self.cfg)
+        self.cfg['ret_coro'] = True
 
-    def kill(self) -> bool:
-        return False
+        self.ap.logger.info("运行 QQ 官方适配器")
+        await (await self.bot.start(**self.cfg))
+
+    async def kill(self) -> bool:
+        if not self.bot.is_closed():
+            await self.bot.close()
+            return True

pkg/platform/sources/yirimirai.py

@@ -1,124 +0,0 @@
-import asyncio
-import typing
-
-import mirai
-import mirai.models.bus
-from mirai.bot import MiraiRunner
-
-from .. import adapter as adapter_model
-from ...core import app
-
-
-@adapter_model.adapter_class("yiri-mirai")
-class YiriMiraiAdapter(adapter_model.MessageSourceAdapter):
-    """YiriMirai适配器"""
-    bot: mirai.Mirai
-
-    def __init__(self, config: dict, ap: app.Application):
-        """初始化YiriMirai的对象"""
-        self.ap = ap
-        self.config = config
-        if 'adapter' not in config or \
-            config['adapter'] == 'WebSocketAdapter':
-            self.bot = mirai.Mirai(
-                qq=config['qq'],
-                adapter=mirai.WebSocketAdapter(
-                    host=config['host'],
-                    port=config['port'],
-                    verify_key=config['verifyKey']
-                )
-            )
-        elif config['adapter'] == 'HTTPAdapter':
-            self.bot = mirai.Mirai(
-                qq=config['qq'],
-                adapter=mirai.HTTPAdapter(
-                    host=config['host'],
-                    port=config['port'],
-                    verify_key=config['verifyKey']
-                )
-            )
-        else:
-            raise Exception('Unknown adapter for YiriMirai: ' + config['adapter'])
-    
-    async def send_message(
-        self,
-        target_type: str,
-        target_id: str,
-        message: mirai.MessageChain
-    ):
-        """发送消息
-        
-        Args:
-            target_type (str): 目标类型，`person`或`group`
-            target_id (str): 目标ID
-            message (mirai.MessageChain): YiriMirai库的消息链
-        """
-        task = None
-        if target_type == 'person':
-            task = self.bot.send_friend_message(int(target_id), message)
-        elif target_type == 'group':
-            task = self.bot.send_group_message(int(target_id), message)
-        else:
-            raise Exception('Unknown target type: ' + target_type)
-
-        await task
-
-    async def reply_message(
-        self,
-        message_source: mirai.MessageEvent,
-        message: mirai.MessageChain,
-        quote_origin: bool = False
-    ):
-        """回复消息
-
-        Args:
-            message_source (mirai.MessageEvent): YiriMirai消息源事件
-            message (mirai.MessageChain): YiriMirai库的消息链
-            quote_origin (bool, optional): 是否引用原消息. Defaults to False.
-        """
-        await self.bot.send(message_source, message, quote_origin)
-
-    async def is_muted(self, group_id: int) -> bool:
-        result = await self.bot.member_info(target=group_id, member_id=self.bot.qq).get()
-        if result.mute_time_remaining > 0:
-            return True
-        return False
-
-    def register_listener(
-        self,
-        event_type: typing.Type[mirai.Event],
-        callback: typing.Callable[[mirai.Event, adapter_model.MessageSourceAdapter], None]
-    ):
-        """注册事件监听器
-        
-        Args:
-            event_type (typing.Type[mirai.Event]): YiriMirai事件类型
-            callback (typing.Callable[[mirai.Event], None]): 回调函数，接收一个参数，为YiriMirai事件
-        """
-        async def wrapper(event: mirai.Event):
-            await callback(event, self)
-        self.bot.on(event_type)(wrapper)
-
-    def unregister_listener(
-        self,
-        event_type: typing.Type[mirai.Event],
-        callback: typing.Callable[[mirai.Event, adapter_model.MessageSourceAdapter], None]
-    ):
-        """注销事件监听器
-        
-        Args:
-            event_type (typing.Type[mirai.Event]): YiriMirai事件类型
-            callback (typing.Callable[[mirai.Event], None]): 回调函数，接收一个参数，为YiriMirai事件
-        """
-        assert isinstance(self.bot, mirai.Mirai)
-        bus = self.bot.bus
-        assert isinstance(bus, mirai.models.bus.ModelEventBus)
-        
-        bus.unsubscribe(event_type, callback)
-
-    async def run_async(self):
-        self.bot_account_id = self.bot.qq
-        return await MiraiRunner(self.bot)._run()
-
-    async def kill(self) -> bool:
-        return False

pkg/platform/types/__init__.py

@@ -0,0 +1,3 @@
+from .entities import *
+from .events import *
+from .message import *

pkg/platform/types/base.py

@@ -0,0 +1,105 @@
+
+from typing import Dict, List, Type
+
+import pydantic.v1.main as pdm
+from pydantic.v1 import BaseModel
+
+
+class PlatformMetaclass(pdm.ModelMetaclass):
+    """此类是平台中使用的 pydantic 模型的元类的基类。"""
+
+
+def to_camel(name: str) -> str:
+    """将下划线命名风格转换为小驼峰命名。"""
+    if name[:2] == '__':  # 不处理双下划线开头的特殊命名。
+        return name
+    name_parts = name.split('_')
+    return ''.join(name_parts[:1] + [x.title() for x in name_parts[1:]])
+
+
+class PlatformBaseModel(BaseModel, metaclass=PlatformMetaclass):
+    """模型基类。
+
+    启用了三项配置：
+    1. 允许解析时传入额外的值，并将额外值保存在模型中。
+    2. 允许通过别名访问字段。
+    3. 自动生成小驼峰风格的别名。
+    """
+    def __init__(self, *args, **kwargs):
+        """"""
+        super().__init__(*args, **kwargs)
+
+    def __repr__(self) -> str:
+        return self.__class__.__name__ + '(' + ', '.join(
+            (f'{k}={repr(v)}' for k, v in self.__dict__.items() if v)
+        ) + ')'
+
+    class Config:
+        extra = 'allow'
+        allow_population_by_field_name = True
+        alias_generator = to_camel
+
+
+class PlatformIndexedMetaclass(PlatformMetaclass):
+    """可以通过子类名获取子类的类的元类。"""
+    __indexedbases__: List[Type['PlatformIndexedModel']] = []
+    __indexedmodel__ = None
+
+    def __new__(cls, name, bases, attrs, **kwargs):
+        new_cls = super().__new__(cls, name, bases, attrs, **kwargs)
+        # 第一类：PlatformIndexedModel
+        if name == 'PlatformIndexedModel':
+            cls.__indexedmodel__ = new_cls
+            new_cls.__indexes__ = {}
+            return new_cls
+        # 第二类：PlatformIndexedModel 的直接子类，这些是可以通过子类名获取子类的类。
+        if cls.__indexedmodel__ in bases:
+            cls.__indexedbases__.append(new_cls)
+            new_cls.__indexes__ = {}
+            return new_cls
+        # 第三类：PlatformIndexedModel 的直接子类的子类，这些添加到直接子类的索引中。
+        for base in cls.__indexedbases__:
+            if issubclass(new_cls, base):
+                base.__indexes__[name] = new_cls
+                return new_cls
+
+    def __getitem__(cls, name):
+        return cls.get_subtype(name)
+
+
+class PlatformIndexedModel(PlatformBaseModel, metaclass=PlatformIndexedMetaclass):
+    """可以通过子类名获取子类的类。"""
+    __indexes__: Dict[str, Type['PlatformIndexedModel']]
+
+    @classmethod
+    def get_subtype(cls, name: str) -> Type['PlatformIndexedModel']:
+        """根据类名称，获取相应的子类类型。
+
+        Args:
+            name: 类名称。
+
+        Returns:
+            Type['PlatformIndexedModel']: 子类类型。
+        """
+        try:
+            type_ = cls.__indexes__.get(name)
+            if not (type_ and issubclass(type_, cls)):
+                raise ValueError(f'`{name}` 不是 `{cls.__name__}` 的子类！')
+            return type_
+        except AttributeError as e:
+            raise ValueError(f'`{name}` 不是 `{cls.__name__}` 的子类！') from None
+
+    @classmethod
+    def parse_subtype(cls, obj: dict) -> 'PlatformIndexedModel':
+        """通过字典，构造对应的模型对象。
+
+        Args:
+            obj: 一个字典，包含了模型对象的属性。
+
+        Returns:
+            PlatformIndexedModel: 构造的对象。
+        """
+        if cls in PlatformIndexedModel.__subclasses__():
+            ModelType = cls.get_subtype(obj['type'])
+            return ModelType.parse_obj(obj)
+        return super().parse_obj(obj)

pkg/platform/types/entities.py

@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*-
+"""
+此模块提供实体和配置项模型。
+"""
+import abc
+from datetime import datetime
+from enum import Enum
+import typing
+
+import pydantic.v1 as pydantic
+
+
+class Entity(pydantic.BaseModel):
+    """实体，表示一个用户或群。"""
+    id: int
+    """QQ 号或群号。"""
+    @abc.abstractmethod
+    def get_avatar_url(self) -> str:
+        """头像图片链接。"""
+
+    @abc.abstractmethod
+    def get_name(self) -> str:
+        """名称。"""
+
+
+class Friend(Entity):
+    """好友。"""
+    id: int
+    """QQ 号。"""
+    nickname: typing.Optional[str]
+    """昵称。"""
+    remark: typing.Optional[str]
+    """备注。"""
+    def get_avatar_url(self) -> str:
+        return f'http://q4.qlogo.cn/g?b=qq&nk={self.id}&s=140'
+
+    def get_name(self) -> str:
+        return self.nickname or self.remark or ''
+
+
+class Permission(str, Enum):
+    """群成员身份权限。"""
+    Member = "MEMBER"
+    """成员。"""
+    Administrator = "ADMINISTRATOR"
+    """管理员。"""
+    Owner = "OWNER"
+    """群主。"""
+    def __repr__(self) -> str:
+        return repr(self.value)
+
+
+class Group(Entity):
+    """群。"""
+    id: int
+    """群号。"""
+    name: str
+    """群名称。"""
+    permission: Permission
+    """Bot 在群中的权限。"""
+    def get_avatar_url(self) -> str:
+        return f'https://p.qlogo.cn/gh/{self.id}/{self.id}/'
+
+    def get_name(self) -> str:
+        return self.name
+
+
+class GroupMember(Entity):
+    """群成员。"""
+    id: int
+    """QQ 号。"""
+    member_name: str
+    """群成员名称。"""
+    permission: Permission
+    """Bot 在群中的权限。"""
+    group: Group
+    """群。"""
+    special_title: str = ''
+    """群头衔。"""
+    join_timestamp: datetime = datetime.utcfromtimestamp(0)
+    """加入群的时间。"""
+    last_speak_timestamp: datetime = datetime.utcfromtimestamp(0)
+    """最后一次发言的时间。"""
+    mute_time_remaining: int = 0
+    """禁言剩余时间。"""
+    def get_avatar_url(self) -> str:
+        return f'http://q4.qlogo.cn/g?b=qq&nk={self.id}&s=140'
+
+    def get_name(self) -> str:
+        return self.member_name
+
+
+class Client(Entity):
+    """来自其他客户端的用户。"""
+    id: int
+    """识别 id。"""
+    platform: str
+    """来源平台。"""
+    def get_avatar_url(self) -> str:
+        raise NotImplementedError
+
+    def get_name(self) -> str:
+        return self.platform
+
+
+class Subject(pydantic.BaseModel):
+    """另一种实体类型表示。"""
+    id: int
+    """QQ 号或群号。"""
+    kind: typing.Literal['Friend', 'Group', 'Stranger']
+    """类型。"""
+
+
+class Config(pydantic.BaseModel):
+    """配置项类型。"""
+    def modify(self, **kwargs) -> 'Config':
+        """修改部分设置。"""
+        for k, v in kwargs.items():
+            if k in self.__fields__:
+                setattr(self, k, v)
+            else:
+                raise ValueError(f'未知配置项: {k}')
+        return self
+
+
+class GroupConfigModel(Config):
+    """群配置。"""
+    name: str
+    """群名称。"""
+    confess_talk: bool
+    """是否允许坦白说。"""
+    allow_member_invite: bool
+    """是否允许成员邀请好友入群。"""
+    auto_approve: bool
+    """是否开启自动审批入群。"""
+    anonymous_chat: bool
+    """是否开启匿名聊天。"""
+    announcement: str = ''
+    """群公告。"""
+
+
+class MemberInfoModel(Config, GroupMember):
+    """群成员信息。"""

pkg/platform/types/events.py

@@ -0,0 +1,124 @@
+# -*- coding: utf-8 -*-
+"""
+此模块提供事件模型。
+"""
+from datetime import datetime
+from enum import Enum
+import typing
+
+import pydantic.v1 as pydantic
+
+from . import entities as platform_entities
+from . import message as platform_message
+
+
+class Event(pydantic.BaseModel):
+    """事件基类。
+
+    Args:
+        type: 事件名。
+    """
+    type: str
+    """事件名。"""
+    def __repr__(self):
+        return self.__class__.__name__ + '(' + ', '.join(
+            (
+                f'{k}={repr(v)}'
+                for k, v in self.__dict__.items() if k != 'type' and v
+            )
+        ) + ')'
+
+    @classmethod
+    def parse_subtype(cls, obj: dict) -> 'Event':
+        try:
+            return typing.cast(Event, super().parse_subtype(obj))
+        except ValueError:
+            return Event(type=obj['type'])
+
+    @classmethod
+    def get_subtype(cls, name: str) -> typing.Type['Event']:
+        try:
+            return typing.cast(typing.Type[Event], super().get_subtype(name))
+        except ValueError:
+            return Event
+
+
+###############################
+# Bot Event
+class BotEvent(Event):
+    """Bot 自身事件。
+
+    Args:
+        type: 事件名。
+        qq: Bot 的 QQ 号。
+    """
+    type: str
+    """事件名。"""
+    qq: int
+    """Bot 的 QQ 号。"""
+
+
+###############################
+# Message Event
+class MessageEvent(Event):
+    """消息事件。
+
+    Args:
+        type: 事件名。
+        message_chain: 消息内容。
+    """
+    type: str
+    """事件名。"""
+    message_chain: platform_message.MessageChain
+    """消息内容。"""
+
+
+class FriendMessage(MessageEvent):
+    """好友消息。
+
+    Args:
+        type: 事件名。
+        sender: 发送消息的好友。
+        message_chain: 消息内容。
+    """
+    type: str = 'FriendMessage'
+    """事件名。"""
+    sender: platform_entities.Friend
+    """发送消息的好友。"""
+    message_chain: platform_message.MessageChain
+    """消息内容。"""
+
+
+class GroupMessage(MessageEvent):
+    """群消息。
+
+    Args:
+        type: 事件名。
+        sender: 发送消息的群成员。
+        message_chain: 消息内容。
+    """
+    type: str = 'GroupMessage'
+    """事件名。"""
+    sender: platform_entities.GroupMember
+    """发送消息的群成员。"""
+    message_chain: platform_message.MessageChain
+    """消息内容。"""
+    @property
+    def group(self) -> platform_entities.Group:
+        return self.sender.group
+
+
+class StrangerMessage(MessageEvent):
+    """陌生人消息。
+
+    Args:
+        type: 事件名。
+        sender: 发送消息的人。
+        message_chain: 消息内容。
+    """
+    type: str = 'StrangerMessage'
+    """事件名。"""
+    sender: platform_entities.Friend
+    """发送消息的人。"""
+    message_chain: platform_message.MessageChain
+    """消息内容。"""

pkg/platform/types/message.py

@@ -0,0 +1,816 @@
+import itertools
+import logging
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+import typing
+
+import pydantic.v1 as pydantic
+
+from . import entities as platform_entities
+from .base import PlatformBaseModel, PlatformIndexedMetaclass, PlatformIndexedModel
+
+
+logger = logging.getLogger(__name__)
+
+
+class MessageComponentMetaclass(PlatformIndexedMetaclass):
+    """消息组件元类。"""
+    __message_component__ = None
+
+    def __new__(cls, name, bases, attrs, **kwargs):
+        new_cls = super().__new__(cls, name, bases, attrs, **kwargs)
+        if name == 'MessageComponent':
+            cls.__message_component__ = new_cls
+
+        if not cls.__message_component__:
+            return new_cls
+
+        for base in bases:
+            if issubclass(base, cls.__message_component__):
+                # 获取字段名
+                if hasattr(new_cls, '__fields__'):
+                    # 忽略 type 字段
+                    new_cls.__parameter_names__ = list(new_cls.__fields__)[1:]
+                else:
+                    new_cls.__parameter_names__ = []
+                break
+
+        return new_cls
+
+
+class MessageComponent(PlatformIndexedModel, metaclass=MessageComponentMetaclass):
+    """消息组件。"""
+    type: str
+    """消息组件类型。"""
+    def __str__(self):
+        return ''
+
+    def __repr__(self):
+        return self.__class__.__name__ + '(' + ', '.join(
+            (
+                f'{k}={repr(v)}'
+                for k, v in self.__dict__.items() if k != 'type' and v
+            )
+        ) + ')'
+
+    def __init__(self, *args, **kwargs):
+        # 解析参数列表，将位置参数转化为具名参数
+        parameter_names = self.__parameter_names__
+        if len(args) > len(parameter_names):
+            raise TypeError(
+                f'`{self.type}`需要{len(parameter_names)}个参数，但传入了{len(args)}个。'
+            )
+        for name, value in zip(parameter_names, args):
+            if name in kwargs:
+                raise TypeError(f'在 `{self.type}` 中，具名参数 `{name}` 与位置参数重复。')
+            kwargs[name] = value
+
+        super().__init__(**kwargs)
+
+
+TMessageComponent = typing.TypeVar('TMessageComponent', bound=MessageComponent)
+
+
+class MessageChain(PlatformBaseModel):
+    """消息链。
+
+    一个构造消息链的例子：
+    ```py
+    message_chain = MessageChain([
+        AtAll(),
+        Plain("Hello World!"),
+    ])
+    ```
+
+    `Plain` 可以省略。
+    ```py
+    message_chain = MessageChain([
+        AtAll(),
+        "Hello World!",
+    ])
+    ```
+
+    在调用 API 时，参数中需要 MessageChain 的，也可以使用 `List[MessageComponent]` 代替。
+    例如，以下两种写法是等价的：
+    ```py
+    await bot.send_friend_message(12345678, [
+        Plain("Hello World!")
+    ])
+    ```
+    ```py
+    await bot.send_friend_message(12345678, MessageChain([
+        Plain("Hello World!")
+    ]))
+    ```
+
+    可以使用 `in` 运算检查消息链中：
+    1. 是否有某个消息组件。
+    2. 是否有某个类型的消息组件。
+
+    ```py
+    if AtAll in message_chain:
+        print('AtAll')
+
+    if At(bot.qq) in message_chain:
+        print('At Me')
+    ```
+
+    消息链对索引操作进行了增强。以消息组件类型为索引，获取消息链中的全部该类型的消息组件。
+    ```py
+    plain_list = message_chain[Plain]
+    '[Plain("Hello World!")]'
+    ```
+
+    可以用加号连接两个消息链。
+    ```py
+    MessageChain(['Hello World!']) + MessageChain(['Goodbye World!'])
+    # 返回 MessageChain([Plain("Hello World!"), Plain("Goodbye World!")])
+    ```
+
+    """
+    __root__: typing.List[MessageComponent]
+
+    @staticmethod
+    def _parse_message_chain(msg_chain: typing.Iterable):
+        result = []
+        for msg in msg_chain:
+            if isinstance(msg, dict):
+                result.append(MessageComponent.parse_subtype(msg))
+            elif isinstance(msg, MessageComponent):
+                result.append(msg)
+            elif isinstance(msg, str):
+                result.append(Plain(msg))
+            else:
+                raise TypeError(
+                    f"消息链中元素需为 dict 或 str 或 MessageComponent，当前类型：{type(msg)}"
+                )
+        return result
+    
+    @pydantic.validator('__root__', always=True, pre=True)
+    def _parse_component(cls, msg_chain):
+        if isinstance(msg_chain, (str, MessageComponent)):
+            msg_chain = [msg_chain]
+        if not msg_chain:
+            msg_chain = []
+        return cls._parse_message_chain(msg_chain)
+
+    @classmethod
+    def parse_obj(cls, msg_chain: typing.Iterable):
+        """通过列表形式的消息链，构造对应的 `MessageChain` 对象。
+
+        Args:
+            msg_chain: 列表形式的消息链。
+        """
+        result = cls._parse_message_chain(msg_chain)
+        return cls(__root__=result)
+
+    def __init__(self, __root__: typing.Iterable[MessageComponent] = None):
+        super().__init__(__root__=__root__)
+
+    def __str__(self):
+        return "".join(str(component) for component in self.__root__)
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}({self.__root__!r})'
+
+    def __iter__(self):
+        yield from self.__root__
+
+    def get_first(self,
+                  t: typing.Type[TMessageComponent]) -> typing.Optional[TMessageComponent]:
+        """获取消息链中第一个符合类型的消息组件。"""
+        for component in self:
+            if isinstance(component, t):
+                return component
+        return None
+
+    @typing.overload
+    def __getitem__(self, index: int) -> MessageComponent:
+        ...
+
+    @typing.overload
+    def __getitem__(self, index: slice) -> typing.List[MessageComponent]:
+        ...
+
+    @typing.overload
+    def __getitem__(self,
+                    index: typing.Type[TMessageComponent]) -> typing.List[TMessageComponent]:
+        ...
+
+    @typing.overload
+    def __getitem__(
+        self, index: typing.Tuple[typing.Type[TMessageComponent], int]
+    ) -> typing.List[TMessageComponent]:
+        ...
+
+    def __getitem__(
+        self, index: typing.Union[int, slice, typing.Type[TMessageComponent],
+                           typing.Tuple[typing.Type[TMessageComponent], int]]
+    ) -> typing.Union[MessageComponent, typing.List[MessageComponent],
+               typing.List[TMessageComponent]]:
+        return self.get(index)
+
+    def __setitem__(
+        self, key: typing.Union[int, slice],
+        value: typing.Union[MessageComponent, str, typing.Iterable[typing.Union[MessageComponent,
+                                                           str]]]
+    ):
+        if isinstance(value, str):
+            value = Plain(value)
+        if isinstance(value, typing.Iterable):
+            value = (Plain(c) if isinstance(c, str) else c for c in value)
+        self.__root__[key] = value  # type: ignore
+
+    def __delitem__(self, key: typing.Union[int, slice]):
+        del self.__root__[key]
+
+    def __reversed__(self) -> typing.Iterable[MessageComponent]:
+        return reversed(self.__root__)
+
+    def has(
+        self, sub: typing.Union[MessageComponent, typing.Type[MessageComponent],
+                         'MessageChain', str]
+    ) -> bool:
+        """判断消息链中：
+        1. 是否有某个消息组件。
+        2. 是否有某个类型的消息组件。
+
+        Args:
+            sub (`Union[MessageComponent, Type[MessageComponent], 'MessageChain', str]`):
+                若为 `MessageComponent`，则判断该组件是否在消息链中。
+                若为 `Type[MessageComponent]`，则判断该组件类型是否在消息链中。
+
+        Returns:
+            bool: 是否找到。
+        """
+        if isinstance(sub, type):  # 检测消息链中是否有某种类型的对象
+            for i in self:
+                if type(i) is sub:
+                    return True
+            return False
+        if isinstance(sub, MessageComponent):  # 检查消息链中是否有某个组件
+            for i in self:
+                if i == sub:
+                    return True
+            return False
+        raise TypeError(f"类型不匹配，当前类型：{type(sub)}")
+
+    def __contains__(self, sub) -> bool:
+        return self.has(sub)
+
+    def __ge__(self, other):
+        return other in self
+
+    def __len__(self) -> int:
+        return len(self.__root__)
+
+    def __add__(
+        self, other: typing.Union['MessageChain', MessageComponent, str]
+    ) -> 'MessageChain':
+        if isinstance(other, MessageChain):
+            return self.__class__(self.__root__ + other.__root__)
+        if isinstance(other, str):
+            return self.__class__(self.__root__ + [Plain(other)])
+        if isinstance(other, MessageComponent):
+            return self.__class__(self.__root__ + [other])
+        return NotImplemented
+
+    def __radd__(self, other: typing.Union[MessageComponent, str]) -> 'MessageChain':
+        if isinstance(other, MessageComponent):
+            return self.__class__([other] + self.__root__)
+        if isinstance(other, str):
+            return self.__class__(
+                [typing.cast(MessageComponent, Plain(other))] + self.__root__
+            )
+        return NotImplemented
+
+    def __mul__(self, other: int):
+        if isinstance(other, int):
+            return self.__class__(self.__root__ * other)
+        return NotImplemented
+
+    def __rmul__(self, other: int):
+        return self.__mul__(other)
+
+    def __iadd__(self, other: typing.Iterable[typing.Union[MessageComponent, str]]):
+        self.extend(other)
+
+    def __imul__(self, other: int):
+        if isinstance(other, int):
+            self.__root__ *= other
+        return NotImplemented
+
+    def index(
+        self,
+        x: typing.Union[MessageComponent, typing.Type[MessageComponent]],
+        i: int = 0,
+        j: int = -1
+    ) -> int:
+        """返回 x 在消息链中首次出现项的索引号（索引号在 i 或其后且在 j 之前）。
+
+        Args:
+            x (`Union[MessageComponent, Type[MessageComponent]]`):
+                要查找的消息元素或消息元素类型。
+            i: 从哪个位置开始查找。
+            j: 查找到哪个位置结束。
+
+        Returns:
+            int: 如果找到，则返回索引号。
+
+        Raises:
+            ValueError: 没有找到。
+            TypeError: 类型不匹配。
+        """
+        if isinstance(x, type):
+            l = len(self)
+            if i < 0:
+                i += l
+            if i < 0:
+                i = 0
+            if j < 0:
+                j += l
+            if j > l:
+                j = l
+            for index in range(i, j):
+                if type(self[index]) is x:
+                    return index
+            raise ValueError("消息链中不存在该类型的组件。")
+        if isinstance(x, MessageComponent):
+            return self.__root__.index(x, i, j)
+        raise TypeError(f"类型不匹配，当前类型：{type(x)}")
+
+    def count(self, x: typing.Union[MessageComponent, typing.Type[MessageComponent]]) -> int:
+        """返回消息链中 x 出现的次数。
+
+        Args:
+            x (`Union[MessageComponent, Type[MessageComponent]]`):
+                要查找的消息元素或消息元素类型。
+
+        Returns:
+            int: 次数。
+        """
+        if isinstance(x, type):
+            return sum(1 for i in self if type(i) is x)
+        if isinstance(x, MessageComponent):
+            return self.__root__.count(x)
+        raise TypeError(f"类型不匹配，当前类型：{type(x)}")
+
+    def extend(self, x: typing.Iterable[typing.Union[MessageComponent, str]]):
+        """将另一个消息链中的元素添加到消息链末尾。
+
+        Args:
+            x: 另一个消息链，也可为消息元素或字符串元素的序列。
+        """
+        self.__root__.extend(Plain(c) if isinstance(c, str) else c for c in x)
+
+    def append(self, x: typing.Union[MessageComponent, str]):
+        """将一个消息元素或字符串元素添加到消息链末尾。
+
+        Args:
+            x: 消息元素或字符串元素。
+        """
+        self.__root__.append(Plain(x) if isinstance(x, str) else x)
+
+    def insert(self, i: int, x: typing.Union[MessageComponent, str]):
+        """将一个消息元素或字符串添加到消息链中指定位置。
+
+        Args:
+            i: 插入位置。
+            x: 消息元素或字符串元素。
+        """
+        self.__root__.insert(i, Plain(x) if isinstance(x, str) else x)
+
+    def pop(self, i: int = -1) -> MessageComponent:
+        """从消息链中移除并返回指定位置的元素。
+
+        Args:
+            i: 移除位置。默认为末尾。
+
+        Returns:
+            MessageComponent: 移除的元素。
+        """
+        return self.__root__.pop(i)
+
+    def remove(self, x: typing.Union[MessageComponent, typing.Type[MessageComponent]]):
+        """从消息链中移除指定元素或指定类型的一个元素。
+
+        Args:
+            x: 指定的元素或元素类型。
+        """
+        if isinstance(x, type):
+            self.pop(self.index(x))
+        if isinstance(x, MessageComponent):
+            self.__root__.remove(x)
+
+    def exclude(
+        self,
+        x: typing.Union[MessageComponent, typing.Type[MessageComponent]],
+        count: int = -1
+    ) -> 'MessageChain':
+        """返回移除指定元素或指定类型的元素后剩余的消息链。
+
+        Args:
+            x: 指定的元素或元素类型。
+            count: 至多移除的数量。默认为全部移除。
+
+        Returns:
+            MessageChain: 剩余的消息链。
+        """
+        def _exclude():
+            nonlocal count
+            x_is_type = isinstance(x, type)
+            for c in self:
+                if count > 0 and ((x_is_type and type(c) is x) or c == x):
+                    count -= 1
+                    continue
+                yield c
+
+        return self.__class__(_exclude())
+
+    def reverse(self):
+        """将消息链原地翻转。"""
+        self.__root__.reverse()
+
+    @classmethod
+    def join(cls, *args: typing.Iterable[typing.Union[str, MessageComponent]]):
+        return cls(
+            Plain(c) if isinstance(c, str) else c
+            for c in itertools.chain(*args)
+        )
+
+    @property
+    def source(self) -> typing.Optional['Source']:
+        """获取消息链中的 `Source` 对象。"""
+        return self.get_first(Source)
+
+    @property
+    def message_id(self) -> int:
+        """获取消息链的 message_id，若无法获取，返回 -1。"""
+        source = self.source
+        return source.id if source else -1
+
+
+TMessage = typing.Union[MessageChain, typing.Iterable[typing.Union[MessageComponent, str]],
+                 MessageComponent, str]
+"""可以转化为 MessageChain 的类型。"""
+
+
+class Source(MessageComponent):
+    """源。包含消息的基本信息。"""
+    type: str = "Source"
+    """消息组件类型。"""
+    id: int
+    """消息的识别号，用于引用回复（Source 类型永远为 MessageChain 的第一个元素）。"""
+    time: datetime
+    """消息时间。"""
+
+
+class Plain(MessageComponent):
+    """纯文本。"""
+    type: str = "Plain"
+    """消息组件类型。"""
+    text: str
+    """文字消息。"""
+    def __str__(self):
+        return self.text
+
+    def __repr__(self):
+        return f'Plain({self.text!r})'
+
+
+class Quote(MessageComponent):
+    """引用。"""
+    type: str = "Quote"
+    """消息组件类型。"""
+    id: typing.Optional[int] = None
+    """被引用回复的原消息的 message_id。"""
+    group_id: typing.Optional[int] = None
+    """被引用回复的原消息所接收的群号，当为好友消息时为0。"""
+    sender_id: typing.Optional[int] = None
+    """被引用回复的原消息的发送者的QQ号。"""
+    target_id: typing.Optional[int] = None
+    """被引用回复的原消息的接收者者的QQ号（或群号）。"""
+    origin: MessageChain
+    """被引用回复的原消息的消息链对象。"""
+
+    @pydantic.validator("origin", always=True, pre=True)
+    def origin_formater(cls, v):
+        return MessageChain.parse_obj(v)
+
+
+class At(MessageComponent):
+    """At某人。"""
+    type: str = "At"
+    """消息组件类型。"""
+    target: int
+    """群员 QQ 号。"""
+    display: typing.Optional[str] = None
+    """At时显示的文字，发送消息时无效，自动使用群名片。"""
+    def __eq__(self, other):
+        return isinstance(other, At) and self.target == other.target
+
+    def __str__(self):
+        return f"@{self.display or self.target}"
+
+
+class AtAll(MessageComponent):
+    """At全体。"""
+    type: str = "AtAll"
+    """消息组件类型。"""
+    def __str__(self):
+        return "@全体成员"
+
+
+class Image(MessageComponent):
+    """图片。"""
+    type: str = "Image"
+    """消息组件类型。"""
+    image_id: typing.Optional[str] = None
+    """图片的 image_id，群图片与好友图片格式不同。不为空时将忽略 url 属性。"""
+    url: typing.Optional[pydantic.HttpUrl] = None
+    """图片的 URL，发送时可作网络图片的链接；接收时为腾讯图片服务器的链接，可用于图片下载。"""
+    path: typing.Union[str, Path, None] = None
+    """图片的路径，发送本地图片。"""
+    base64: typing.Optional[str] = None
+    """图片的 Base64 编码。"""
+    def __eq__(self, other):
+        return isinstance(
+            other, Image
+        ) and self.type == other.type and self.uuid == other.uuid
+
+    def __str__(self):
+        return '[图片]'
+
+    @pydantic.validator('path')
+    def validate_path(cls, path: typing.Union[str, Path, None]):
+        """修复 path 参数的行为，使之相对于 LangBot 的启动路径。"""
+        if path:
+            try:
+                return str(Path(path).resolve(strict=True))
+            except FileNotFoundError:
+                raise ValueError(f"无效路径：{path}")
+        else:
+            return path
+
+    @property
+    def uuid(self):
+        image_id = self.image_id
+        if image_id[0] == '{':  # 群图片
+            image_id = image_id[1:37]
+        elif image_id[0] == '/':  # 好友图片
+            image_id = image_id[1:]
+        return image_id
+
+    async def download(
+        self,
+        filename: typing.Union[str, Path, None] = None,
+        directory: typing.Union[str, Path, None] = None,
+        determine_type: bool = True
+    ):
+        """下载图片到本地。
+
+        Args:
+            filename: 下载到本地的文件路径。与 `directory` 二选一。
+            directory: 下载到本地的文件夹路径。与 `filename` 二选一。
+            determine_type: 是否自动根据图片类型确定拓展名，默认为 True。
+        """
+        if not self.url:
+            logger.warning(f'图片 `{self.uuid}` 无 url 参数，下载失败。')
+            return
+
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.get(self.url)
+            response.raise_for_status()
+            content = response.content
+
+            if filename:
+                path = Path(filename)
+                if determine_type:
+                    import imghdr
+                    path = path.with_suffix(
+                        '.' + str(imghdr.what(None, content))
+                    )
+                path.parent.mkdir(parents=True, exist_ok=True)
+            elif directory:
+                import imghdr
+                path = Path(directory)
+                path.mkdir(parents=True, exist_ok=True)
+                path = path / f'{self.uuid}.{imghdr.what(None, content)}'
+            else:
+                raise ValueError("请指定文件路径或文件夹路径！")
+
+            import aiofiles
+            async with aiofiles.open(path, 'wb') as f:
+                await f.write(content)
+
+            return path
+
+    @classmethod
+    async def from_local(
+        cls,
+        filename: typing.Union[str, Path, None] = None,
+        content: typing.Optional[bytes] = None,
+    ) -> "Image":
+        """从本地文件路径加载图片，以 base64 的形式传递。
+
+        Args:
+            filename: 从本地文件路径加载图片，与 `content` 二选一。
+            content: 从本地文件内容加载图片，与 `filename` 二选一。
+
+        Returns:
+            Image: 图片对象。
+        """
+        if content:
+            pass
+        elif filename:
+            path = Path(filename)
+            import aiofiles
+            async with aiofiles.open(path, 'rb') as f:
+                content = await f.read()
+        else:
+            raise ValueError("请指定图片路径或图片内容！")
+        import base64
+        img = cls(base64=base64.b64encode(content).decode())
+        return img
+
+    @classmethod
+    def from_unsafe_path(cls, path: typing.Union[str, Path]) -> "Image":
+        """从不安全的路径加载图片。
+
+        Args:
+            path: 从不安全的路径加载图片。
+
+        Returns:
+            Image: 图片对象。
+        """
+        return cls.construct(path=str(path))
+
+
+class Unknown(MessageComponent):
+    """未知。"""
+    type: str = "Unknown"
+    """消息组件类型。"""
+    text: str
+    """文本。"""
+
+
+class Voice(MessageComponent):
+    """语音。"""
+    type: str = "Voice"
+    """消息组件类型。"""
+    voice_id: typing.Optional[str] = None
+    """语音的 voice_id，不为空时将忽略 url 属性。"""
+    url: typing.Optional[str] = None
+    """语音的 URL，发送时可作网络语音的链接；接收时为腾讯语音服务器的链接，可用于语音下载。"""
+    path: typing.Optional[str] = None
+    """语音的路径，发送本地语音。"""
+    base64: typing.Optional[str] = None
+    """语音的 Base64 编码。"""
+    length: typing.Optional[int] = None
+    """语音的长度，单位为秒。"""
+    @pydantic.validator('path')
+    def validate_path(cls, path: typing.Optional[str]):
+        """修复 path 参数的行为，使之相对于 LangBot 的启动路径。"""
+        if path:
+            try:
+                return str(Path(path).resolve(strict=True))
+            except FileNotFoundError:
+                raise ValueError(f"无效路径：{path}")
+        else:
+            return path
+
+    def __str__(self):
+        return '[语音]'
+
+    async def download(
+        self,
+        filename: typing.Union[str, Path, None] = None,
+        directory: typing.Union[str, Path, None] = None
+    ):
+        """下载语音到本地。
+
+        语音采用 silk v3 格式，silk 格式的编码解码请使用 [graiax-silkcoder](https://pypi.org/project/graiax-silkcoder/)。
+
+        Args:
+            filename: 下载到本地的文件路径。与 `directory` 二选一。
+            directory: 下载到本地的文件夹路径。与 `filename` 二选一。
+        """
+        if not self.url:
+            logger.warning(f'语音 `{self.voice_id}` 无 url 参数，下载失败。')
+            return
+
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.get(self.url)
+            response.raise_for_status()
+            content = response.content
+
+            if filename:
+                path = Path(filename)
+                path.parent.mkdir(parents=True, exist_ok=True)
+            elif directory:
+                path = Path(directory)
+                path.mkdir(parents=True, exist_ok=True)
+                path = path / f'{self.voice_id}.silk'
+            else:
+                raise ValueError("请指定文件路径或文件夹路径！")
+
+            import aiofiles
+            async with aiofiles.open(path, 'wb') as f:
+                await f.write(content)
+
+    @classmethod
+    async def from_local(
+        cls,
+        filename: typing.Union[str, Path, None] = None,
+        content: typing.Optional[bytes] = None,
+    ) -> "Voice":
+        """从本地文件路径加载语音，以 base64 的形式传递。
+
+        Args:
+            filename: 从本地文件路径加载语音，与 `content` 二选一。
+            content: 从本地文件内容加载语音，与 `filename` 二选一。
+        """
+        if content:
+            pass
+        if filename:
+            path = Path(filename)
+            import aiofiles
+            async with aiofiles.open(path, 'rb') as f:
+                content = await f.read()
+        else:
+            raise ValueError("请指定语音路径或语音内容！")
+        import base64
+        img = cls(base64=base64.b64encode(content).decode())
+        return img
+
+
+class ForwardMessageNode(pydantic.BaseModel):
+    """合并转发中的一条消息。"""
+    sender_id: typing.Optional[int] = None
+    """发送人QQ号。"""
+    sender_name: typing.Optional[str] = None
+    """显示名称。"""
+    message_chain: typing.Optional[MessageChain] = None
+    """消息内容。"""
+    message_id: typing.Optional[int] = None
+    """消息的 message_id，可以只使用此属性，从缓存中读取消息内容。"""
+    time: typing.Optional[datetime] = None
+    """发送时间。"""
+    @pydantic.validator('message_chain', check_fields=False)
+    def _validate_message_chain(cls, value: typing.Union[MessageChain, list]):
+        if isinstance(value, list):
+            return MessageChain.parse_obj(value)
+        return value
+
+    @classmethod
+    def create(
+        cls, sender: typing.Union[platform_entities.Friend, platform_entities.GroupMember], message: MessageChain
+    ) -> 'ForwardMessageNode':
+        """从消息链生成转发消息。
+
+        Args:
+            sender: 发送人。
+            message: 消息内容。
+
+        Returns:
+            ForwardMessageNode: 生成的一条消息。
+        """
+        return ForwardMessageNode(
+            sender_id=sender.id,
+            sender_name=sender.get_name(),
+            message_chain=message
+        )
+
+
+class Forward(MessageComponent):
+    """合并转发。"""
+    type: str = "Forward"
+    """消息组件类型。"""
+    node_list: typing.List[ForwardMessageNode]
+    """转发消息节点列表。"""
+    def __init__(self, *args, **kwargs):
+        if len(args) == 1:
+            self.node_list = args[0]
+            super().__init__(**kwargs)
+        super().__init__(*args, **kwargs)
+
+    def __str__(self):
+        return '[聊天记录]'
+
+
+class File(MessageComponent):
+    """文件。"""
+    type: str = "File"
+    """消息组件类型。"""
+    id: str
+    """文件识别 ID。"""
+    name: str
+    """文件名称。"""
+    size: int
+    """文件大小。"""
+    def __str__(self):
+        return f'[文件]{self.name}'
+

pkg/plugin/context.py

@@ -2,12 +2,13 @@ from __future__ import annotations
 
 import typing
 import abc
-import pydantic
-import mirai
+import pydantic.v1 as pydantic
+import enum
 
 from . import events
 from ..provider.tools import entities as tools_entities
 from ..core import app
+from ..platform.types import message as platform_message
 
 
 def register(
@@ -85,15 +86,24 @@ class BasePlugin(metaclass=abc.ABCMeta):
     """应用程序对象"""
 
     def __init__(self, host: APIHost):
+        """初始化阶段被调用"""
         self.host = host
 
     async def initialize(self):
-        """初始化插件"""
+        """初始化阶段被调用"""
+        pass
+    
+    async def destroy(self):
+        """释放/禁用插件时被调用"""
+        pass
+
+    def __del__(self):
+        """释放/禁用插件时被调用"""
         pass
 
 
 class APIHost:
-    """QChatGPT API 宿主"""
+    """LangBot API 宿主"""
 
     ap: app.Application
 
@@ -126,7 +136,7 @@ class APIHost:
 
         if self.ap.ver_mgr.compare_version_str(qchatgpt_version, ge) < 0 or \
             (self.ap.ver_mgr.compare_version_str(qchatgpt_version, le) > 0):
-            raise Exception("QChatGPT 版本不满足要求，某些功能（可能是由插件提供的）无法正常使用。（要求版本：{}-{}，但当前版本：{}）".format(ge, le, qchatgpt_version))
+            raise Exception("LangBot 版本不满足要求，某些功能（可能是由插件提供的）无法正常使用。（要求版本：{}-{}，但当前版本：{}）".format(ge, le, qchatgpt_version))
 
         return True
 
@@ -174,11 +184,11 @@ class EventContext:
             self.__return_value__[key] = []
         self.__return_value__[key].append(ret)
     
-    async def reply(self, message_chain: mirai.MessageChain):
+    async def reply(self, message_chain: platform_message.MessageChain):
         """回复此次消息请求
         
         Args:
-            message_chain (mirai.MessageChain): YiriMirai库的消息链，若用户使用的不是 YiriMirai 适配器，程序也能自动转换为目标消息链
+            message_chain (platform.types.MessageChain): 源平台的消息链，若用户使用的不是源平台适配器，程序也能自动转换为目标平台消息链
         """
         await self.host.ap.platform_mgr.send(
             event=self.event.query.message_event,
@@ -190,14 +200,14 @@ class EventContext:
         self,
         target_type: str,
         target_id: str,
-        message: mirai.MessageChain
+        message: platform_message.MessageChain
     ):
         """主动发送消息
         
         Args:
             target_type (str): 目标类型，`person`或`group`
             target_id (str): 目标ID
-            message (mirai.MessageChain): YiriMirai库的消息链，若用户使用的不是 YiriMirai 适配器，程序也能自动转换为目标消息链
+            message (platform.types.MessageChain): 源平台的消息链，若用户使用的不是源平台适配器，程序也能自动转换为目标平台消息链
         """
         await self.event.query.adapter.send_message(
             target_type=target_type,
@@ -247,6 +257,16 @@ class EventContext:
         EventContext.eid += 1
 
 
+class RuntimeContainerStatus(enum.Enum):
+    """插件容器状态"""
+
+    MOUNTED = "mounted"
+    """已加载进内存，所有位于运行时记录中的 RuntimeContainer 至少是这个状态"""
+
+    INITIALIZED = "initialized"
+    """已初始化"""
+
+
 class RuntimeContainer(pydantic.BaseModel):
     """运行时的插件容器
     
@@ -294,6 +314,9 @@ class RuntimeContainer(pydantic.BaseModel):
     content_functions: list[tools_entities.LLMFunction] = []
     """内容函数"""
 
+    status: RuntimeContainerStatus = RuntimeContainerStatus.MOUNTED
+    """插件状态"""
+
     class Config:
         arbitrary_types_allowed = True
 
@@ -318,5 +341,30 @@ class RuntimeContainer(pydantic.BaseModel):
         self.priority = setting['priority']
         self.enabled = setting['enabled']
 
-        for function in self.content_functions:
-            function.enable = self.enabled
+    def model_dump(self, *args, **kwargs):
+        return {
+            'name': self.plugin_name,
+            'description': self.plugin_description,
+            'version': self.plugin_version,
+            'author': self.plugin_author,
+            'source': self.plugin_source,
+            'main_file': self.main_file,
+            'pkg_path': self.pkg_path,
+            'enabled': self.enabled,
+            'priority': self.priority,
+            'event_handlers': {
+                event_name.__name__: handler.__name__
+                for event_name, handler in self.event_handlers.items()
+            },
+            'content_functions': [
+                {
+                    'name': function.name,
+                    'human_desc': function.human_desc,
+                    'description': function.description,
+                    'parameters': function.parameters,
+                    'func': function.func.__name__,
+                }
+                for function in self.content_functions
+            ],
+            'status': self.status.value,
+        }

pkg/plugin/events.py

@@ -2,11 +2,11 @@ from __future__ import annotations
 
 import typing
 
-import pydantic
-import mirai
+import pydantic.v1 as pydantic
 
 from ..core import entities as core_entities
 from ..provider import entities as llm_entities
+from ..platform.types import message as platform_message
 
 
 class BaseEventModel(pydantic.BaseModel):
@@ -31,7 +31,7 @@ class PersonMessageReceived(BaseEventModel):
     sender_id: int
     """发送者ID(QQ号)"""
 
-    message_chain: mirai.MessageChain
+    message_chain: platform_message.MessageChain
 
 
 class GroupMessageReceived(BaseEventModel):
@@ -43,7 +43,7 @@ class GroupMessageReceived(BaseEventModel):
     
     sender_id: int
 
-    message_chain: mirai.MessageChain
+    message_chain: platform_message.MessageChain
 
 
 class PersonNormalMessageReceived(BaseEventModel):