chore: release v3.4.14.3 (#1358)

* feat(gewechat): 重构target2yiri代码+引用消息展开

* feat(gewe): 引用消息，图片视频音频是单独的类型

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -1,63 +1,27 @@
 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使用的框架"
-      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
+      required: true
   - type: textarea
     attributes:
       label: 启用的插件

.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,29 @@
+name: Build Dev Image
+
+on:
+  push:
+  workflow_dispatch:
+
+jobs:
+  build-dev-image:
+    runs-on: ubuntu-latest
+    # 如果是tag则跳过
+    if: ${{ !startsWith(github.ref, 'refs/tags/') }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+        with:
+          persist-credentials: false
+
+      - 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

@@ -13,18 +13,15 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v2
+        with:
+          persist-credentials: false
+
       - name: judge has env GITHUB_REF  # 如果没有GITHUB_REF环境变量，则把github.ref变量赋值给GITHUB_REF
         run: |
           if [ -z "$GITHUB_REF" ]; then
             export GITHUB_REF=${{ github.ref }}
             echo $GITHUB_REF
           fi
-      # - name: Check GITHUB_REF env
-      #   run: echo $GITHUB_REF
-      # - name: Get version  # 在 GitHub Actions 运行环境
-      #   id: get_version
-      #   if: (startsWith(env.GITHUB_REF, 'refs/tags/')||startsWith(github.ref, 'refs/tags/')) && startsWith(github.repository, 'RockChinQ/QChatGPT')
-      #   run: export GITHUB_REF=${GITHUB_REF/refs\/tags\//}
       - name: Check version
         id: check_version
         run: |
@@ -44,5 +41,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,62 @@
+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
+        with:
+          persist-credentials: false
+
+      - 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: .
+
+      - name: Upload To Release
+        env:
+          GH_TOKEN: ${{ secrets.RELEASE_UPLOAD_GITHUB_TOKEN }}
+        run: |
+          # 本目录下所有文件打包成zip
+          zip -r langbot-${{ steps.check_version.outputs.version }}-all.zip .
+          gh release upload ${{ github.event.release.tag_name }} langbot-${{ steps.check_version.outputs.version }}-all.zip

.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

.github/workflows/test-pr.yml

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

.gitignore

@@ -2,10 +2,10 @@
 .idea/
 __pycache__/
 database.db
-qchatgpt.log
+langbot.log
 /banlist.py
-plugins/
-!plugins/__init__.py
+/plugins/
+!/plugins/__init__.py
 /revcfg.py
 prompts/
 logs/
@@ -16,11 +16,10 @@ scenario/
 !scenario/default-template.json
 override.json
 cookies.json
-res/announcement_saved
-res/announcement_saved.json
+data/labels/announcement_saved.json
 cmdpriv.json
 tips.py
-.venv
+venv*
 bin/
 .vscode
 test_*
@@ -30,8 +29,14 @@ qcapi
 claude.json
 bard.json
 /*yaml
+!components.yaml
 !/docker-compose.yaml
-res/instance_id.json
+data/labels/instance_id.json
 .DS_Store
 /data
-botpy.log*
+botpy.log*
+/poc
+/libs/wecom_api/test.py
+/venv
+test.py
+/web_ui

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,45 +1,151 @@
 
 <p align="center">
-<img src="https://qchatgpt.rockchin.top/logo.png" alt="QChatGPT" width="180" />
-</p>
+<a href="https://langbot.app">
+<img src="https://docs.langbot.app/social.png" alt="LangBot"/>
+</a>
+
 <div align="center">
 
-# QChatGPT
+<a href="https://trendshift.io/repositories/12901" target="_blank"><img src="https://trendshift.io/api/badge/repositories/12901" alt="RockChinQ%2FLangBot | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
 
-<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>
+<a href="https://langbot.app">项目主页</a> ｜
+<a href="https://docs.langbot.app/insight/intro.html">功能介绍</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>
 
-[![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)
-<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">
-</a>
-<a href="https://qm.qq.com/q/1yxEaIgXMA">
-<img alt="Static Badge" src="https://img.shields.io/badge/%E7%A4%BE%E5%8C%BA%E7%BE%A4-619154800-purple">
-</a>
-<a href="https://codecov.io/gh/RockChinQ/QChatGPT" > 
- <img src="https://codecov.io/gh/RockChinQ/QChatGPT/graph/badge.svg?token=pjxYIL2kbC"/> 
- </a>
- 
-## 使用文档
-
-<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/the-lazy-me/QChatGPT-Wiki">官方文档储存库</a>
-
-<img alt="回复效果（带有联网插件）" src="https://qchatgpt.rockchin.top/assets/image/QChatGPT-0516.png" width="500px"/>
+<div align="center">
+😎高稳定、🧩支持扩展、🦄多模态 - 大模型原生即时通信机器人平台🤖  
 </div>
+
+<br/>
+
+
+[![Discord](https://img.shields.io/discord/1335141740050649118?logo=discord&labelColor=%20%235462eb&logoColor=%20%23f5f5f5&color=%20%235462eb)](https://discord.gg/wdNEHETs87)
+[![QQ Group](https://img.shields.io/badge/%E7%A4%BE%E5%8C%BAQQ%E7%BE%A4-966235608-blue)](https://qm.qq.com/q/JLi38whHum)
+[![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.13 -blue.svg" alt="python">
+[![star](https://gitcode.com/RockChinQ/LangBot/star/badge.svg)](https://gitcode.com/RockChinQ/LangBot)
+
+[简体中文](README.md) / [English](README_EN.md) / [日本語](README_JP.md)
+
+</div>
+
+</p>
+
+## ✨ 特性
+
+- 💬 大模型对话、Agent：支持多种大模型，适配群聊和私聊；具有多轮对话、工具调用、多模态能力，并深度适配 [Dify](https://dify.ai)。目前支持 QQ、QQ频道、企业微信、个人微信、飞书、Discord、Telegram 等平台。
+- 🛠️ 高稳定性、功能完备：原生支持访问控制、限速、敏感词过滤等机制；配置简单，支持多种部署方式。
+- 🧩 插件扩展、活跃社区：支持事件驱动、组件扩展等插件机制；适配 Anthropic [MCP 协议](https://modelcontextprotocol.io/)；目前已有数十个[插件](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效果，公开环境，请不要在其中填入您的任何敏感信息。
+
+## 🔌 组件兼容性
+
+### 消息平台
+
+| 平台 | 状态 | 备注 |
+| --- | --- | --- |
+| QQ 个人号 | ✅ | QQ 个人号私聊、群聊 |
+| QQ 官方机器人 | ✅ | QQ 官方机器人，支持频道、私聊、群聊 |
+| 企业微信 | ✅ |  |
+| 企微对外客服 | ✅ |  |
+| 个人微信 | ✅ | 使用 [Gewechat](https://github.com/Devo919/Gewechat) 接入 |
+| 微信公众号 | ✅ |  |
+| 飞书 | ✅ |  |
+| 钉钉 | ✅ |  |
+| Discord | ✅ |  |
+| Telegram | ✅ |  |
+| Slack | ✅ |  |
+| LINE | 🚧 |  |
+| WhatsApp | 🚧 |  |
+
+🚧: 正在开发中
+
+### 大模型能力
+
+| 模型 | 状态 | 备注 |
+| --- | --- | --- |
+| [OpenAI](https://platform.openai.com/) | ✅ | 可接入任何 OpenAI 接口格式模型 |
+| [DeepSeek](https://www.deepseek.com/) | ✅ |  |
+| [Moonshot](https://www.moonshot.cn/) | ✅ |  |
+| [Anthropic](https://www.anthropic.com/) | ✅ |  |
+| [xAI](https://x.ai/) | ✅ |  |
+| [智谱AI](https://open.bigmodel.cn/) | ✅ |  |
+| [PPIO](https://ppinfra.com/user/register?invited_by=QJKFYD&utm_source=github_langbot) | ✅ | 大模型和 GPU 资源平台 |
+| [Dify](https://dify.ai) | ✅ | LLMOps 平台 |
+| [Ollama](https://ollama.com/) | ✅ | 本地大模型运行平台 |
+| [LMStudio](https://lmstudio.ai/) | ✅ | 本地大模型运行平台 |
+| [GiteeAI](https://ai.gitee.com/) | ✅ | 大模型接口聚合平台 |
+| [SiliconFlow](https://siliconflow.cn/) | ✅ | 大模型聚合平台 |
+| [阿里云百炼](https://bailian.console.aliyun.com/) | ✅ | 大模型聚合平台, LLMOps 平台 |
+| [火山方舟](https://console.volcengine.com/ark/region:ark+cn-beijing/model?vendor=Bytedance&view=LIST_VIEW) | ✅ | 大模型聚合平台, LLMOps 平台 |
+| [ModelScope](https://modelscope.cn/docs/model-service/API-Inference/intro) | ✅ | 大模型聚合平台 |
+| [MCP](https://modelcontextprotocol.io/) | ✅ | 支持通过 MCP 协议获取工具 |
+
+### TTS
+
+| 平台/模型 | 备注 |
+| --- | --- |
+| [FishAudio](https://fish.audio/zh-CN/discovery/) | [插件](https://github.com/the-lazy-me/NewChatVoice) |
+| [海豚 AI](https://www.ttson.cn/?source=thelazy) | [插件](https://github.com/the-lazy-me/NewChatVoice) |
+| [AzureTTS](https://portal.azure.com/) | [插件](https://github.com/Ingnaryk/LangBot_AzureTTS) |
+
+### 文生图
+
+| 平台/模型 | 备注 |
+| --- | --- |
+| 阿里云百炼 | [插件](https://github.com/Thetail001/LangBot_BailianTextToImagePlugin)
+
+## 😘 社区贡献
+
+感谢以下[代码贡献者](https://github.com/RockChinQ/LangBot/graphs/contributors)和社区里其他成员对 LangBot 的贡献：
+
+<a href="https://github.com/RockChinQ/LangBot/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=RockChinQ/LangBot" />
+</a>
+
+以及 LangBot 核心团队成员：
+
+- [RockChinQ](https://github.com/RockChinQ)
+- [the-lazy-me](https://github.com/the-lazy-me)
+- [wangcham](https://github.com/wangcham)
+- [KaedeSAMA](https://github.com/KaedeSAMA)

README_EN.md

@@ -0,0 +1,135 @@
+<p align="center">
+<a href="https://langbot.app">
+<img src="https://docs.langbot.app/social.png" alt="LangBot"/>
+</a>
+
+<div align="center">
+
+<a href="https://trendshift.io/repositories/12901" target="_blank"><img src="https://trendshift.io/api/badge/repositories/12901" alt="RockChinQ%2FLangBot | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+
+<a href="https://langbot.app">Home</a> ｜
+<a href="https://docs.langbot.app/insight/intro.html">Features</a> ｜
+<a href="https://docs.langbot.app/insight/guide.html">Deployment</a> ｜
+<a href="https://docs.langbot.app/usage/faq.html">FAQ</a> ｜
+<a href="https://docs.langbot.app/plugin/plugin-intro.html">Plugin</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">Submit Plugin</a>
+
+<div align="center">
+😎High Stability, 🧩Extension Supported, 🦄Multi-modal - LLM Native Instant Messaging Bot Platform🤖  
+</div>
+
+<br/>
+
+
+[![Discord](https://img.shields.io/discord/1335141740050649118?logo=discord&labelColor=%20%235462eb&logoColor=%20%23f5f5f5&color=%20%235462eb)](https://discord.gg/wdNEHETs87)
+[![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=Usage(7days))
+<img src="https://img.shields.io/badge/python-3.10 ~ 3.13 -blue.svg" alt="python">
+
+[简体中文](README.md) / [English](README_EN.md) / [日本語](README_JP.md)
+
+</div>
+
+</p>
+
+## ✨ Features
+
+- 💬 Chat with LLM / Agent: Supports multiple LLMs, adapt to group chats and private chats; Supports multi-round conversations, tool calls, and multi-modal capabilities. Deeply integrates with [Dify](https://dify.ai). Currently supports QQ, QQ Channel, WeCom, personal WeChat, Lark, DingTalk, Discord, Telegram, etc.
+- 🛠️ High Stability, Feature-rich: Native access control, rate limiting, sensitive word filtering, etc. mechanisms; Easy to use, supports multiple deployment methods.
+- 🧩 Plugin Extension, Active Community: Support event-driven, component extension, etc. plugin mechanisms; Integrate Anthropic [MCP protocol](https://modelcontextprotocol.io/); Currently has dozens of [plugins](https://docs.langbot.app/plugin/plugin-intro.html)
+- 😻 [New] Web UI: Support management LangBot instance through the browser, for details, see [documentation](https://docs.langbot.app/webui/intro.html)
+
+## 📦 Getting Started
+
+> [!IMPORTANT]
+>
+> - Before you start deploying in any way, please read the [New User Guide](https://docs.langbot.app/insight/guide.html).  
+> - All documentation is in Chinese, we will provide i18n version in the near future.
+> - Read [the auto-generated wiki on DeepWiki](https://deepwiki.com/RockChinQ/LangBot).
+
+#### Docker Compose Deployment
+
+Suitable for users familiar with Docker, see the [Docker Deployment](https://docs.langbot.app/deploy/langbot/docker.html) documentation.
+
+#### One-click Deployment on BTPanel
+
+LangBot has been listed on the BTPanel, if you have installed the BTPanel, you can use the [document](https://docs.langbot.app/deploy/langbot/one-click/bt.html) to use it.
+
+#### Zeabur Cloud Deployment
+
+Community contributed Zeabur template.
+
+[![Deploy on Zeabur](https://zeabur.com/button.svg)](https://zeabur.com/zh-CN/templates/ZKTBDH)
+
+#### Railway Cloud Deployment
+
+[![Deploy on Railway](https://railway.com/button.svg)](https://railway.app/template/yRrAyL?referralCode=vogKPF)
+
+#### Other Deployment Methods
+
+Directly use the released version to run, see the [Manual Deployment](https://docs.langbot.app/deploy/langbot/manual.html) documentation.
+
+## 📸 Demo
+
+<img alt="Reply Effect (with Internet Plugin)" src="https://docs.langbot.app/QChatGPT-0516.png" width="500px"/>
+
+- WebUI Demo: https://demo.langbot.dev/
+    - Login information: Email: `demo@langbot.app` Password: `langbot123456`
+    - Note: Only the WebUI effect is shown, please do not fill in any sensitive information in the public environment.
+
+## 🔌 Component Compatibility
+
+### Message Platform
+
+| Platform | Status | Remarks |
+| --- | --- | --- |
+| Personal QQ | ✅ |  |
+| QQ Official API | ✅ |  |
+| WeCom | ✅ |  |
+| WeComCS | ✅ |  |
+| Personal WeChat | ✅ | Use [Gewechat](https://github.com/Devo919/Gewechat) to access |
+| Lark | ✅ |  |
+| DingTalk | ✅ |  |
+| Discord | ✅ |  |
+| Telegram | ✅ |  |
+| Slack | ✅ |  |
+| LINE | 🚧 |  |
+| WhatsApp | 🚧 |  |
+
+🚧: In development
+
+### LLMs
+
+| LLM | Status | Remarks |
+| --- | --- | --- |
+| [OpenAI](https://platform.openai.com/) | ✅ | Available for any OpenAI interface format model |
+| [DeepSeek](https://www.deepseek.com/) | ✅ |  |
+| [Moonshot](https://www.moonshot.cn/) | ✅ |  |
+| [Anthropic](https://www.anthropic.com/) | ✅ |  |
+| [xAI](https://x.ai/) | ✅ |  |
+| [Zhipu AI](https://open.bigmodel.cn/) | ✅ |  |
+| [Dify](https://dify.ai) | ✅ | LLMOps platform |
+| [PPIO](https://ppinfra.com/user/register?invited_by=QJKFYD&utm_source=github_langbot) | ✅ | LLM and GPU resource platform |
+| [Ollama](https://ollama.com/) | ✅ | Local LLM running platform |
+| [LMStudio](https://lmstudio.ai/) | ✅ | Local LLM running platform |
+| [GiteeAI](https://ai.gitee.com/) | ✅ | LLM interface gateway(MaaS) |
+| [SiliconFlow](https://siliconflow.cn/) | ✅ | LLM gateway(MaaS) |
+| [Aliyun Bailian](https://bailian.console.aliyun.com/) | ✅ | LLM gateway(MaaS), LLMOps platform |
+| [Volc Engine Ark](https://console.volcengine.com/ark/region:ark+cn-beijing/model?vendor=Bytedance&view=LIST_VIEW) | ✅ | LLM gateway(MaaS), LLMOps platform |
+| [ModelScope](https://modelscope.cn/docs/model-service/API-Inference/intro) | ✅ | LLM gateway(MaaS) |
+| [MCP](https://modelcontextprotocol.io/) | ✅ | Support tool access through MCP protocol |
+
+## 🤝 Community Contribution
+
+Thank you for the following [code contributors](https://github.com/RockChinQ/LangBot/graphs/contributors) and other members in the community for their contributions to LangBot:
+
+<a href="https://github.com/RockChinQ/LangBot/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=RockChinQ/LangBot" />
+</a>
+
+And the core team members of LangBot:
+
+- [RockChinQ](https://github.com/RockChinQ)
+- [the-lazy-me](https://github.com/the-lazy-me)
+- [wangcham](https://github.com/wangcham)
+- [KaedeSAMA](https://github.com/KaedeSAMA)

README_JP.md

@@ -0,0 +1,134 @@
+<p align="center">
+<a href="https://langbot.app">
+<img src="https://docs.langbot.app/social.png" alt="LangBot"/>
+</a>
+
+<div align="center">
+
+<a href="https://trendshift.io/repositories/12901" target="_blank"><img src="https://trendshift.io/api/badge/repositories/12901" alt="RockChinQ%2FLangBot | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+
+<a href="https://langbot.app">ホーム</a> ｜
+<a href="https://docs.langbot.app/insight/intro.html">機能</a> ｜
+<a href="https://docs.langbot.app/insight/guide.html">デプロイ</a> ｜
+<a href="https://docs.langbot.app/usage/faq.html">FAQ</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">
+😎高い安定性、🧩拡張サポート、🦄マルチモーダル - LLMネイティブインスタントメッセージングボットプラットフォーム🤖  
+</div>
+
+<br/>
+
+[![Discord](https://img.shields.io/discord/1335141740050649118?logo=discord&labelColor=%20%235462eb&logoColor=%20%23f5f5f5&color=%20%235462eb)](https://discord.gg/wdNEHETs87)
+[![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=Usage(7days))
+<img src="https://img.shields.io/badge/python-3.10 ~ 3.13 -blue.svg" alt="python">
+
+[简体中文](README.md) / [English](README_EN.md) / [日本語](README_JP.md)
+
+</div>
+
+</p>
+
+## ✨ 機能
+
+- 💬 LLM / エージェントとのチャット: 複数のLLMをサポートし、グループチャットとプライベートチャットに対応。マルチラウンドの会話、ツールの呼び出し、マルチモーダル機能をサポート。 [Dify](https://dify.ai) と深く統合。現在、QQ、QQ チャンネル、WeChat、個人 WeChat、Lark、DingTalk、Discord、Telegram など、複数のプラットフォームをサポートしています。
+- 🛠️ 高い安定性、豊富な機能: ネイティブのアクセス制御、レート制限、敏感な単語のフィルタリングなどのメカニズムをサポート。使いやすく、複数のデプロイ方法をサポート。
+- 🧩 プラグイン拡張、活発なコミュニティ: イベント駆動、コンポーネント拡張などのプラグインメカニズムをサポート。適配 Anthropic [MCP プロトコル](https://modelcontextprotocol.io/)；豊富なエコシステム、現在数十の[プラグイン](https://docs.langbot.app/plugin/plugin-intro.html)が存在。
+- 😻 [新機能] Web UI: ブラウザを通じてLangBotインスタンスを管理することをサポート。詳細は[ドキュメント](https://docs.langbot.app/webui/intro.html)を参照。
+
+## 📦 始め方
+
+> [!IMPORTANT]
+>
+> - どのデプロイ方法を始める前に、必ず[新規ユーザーガイド](https://docs.langbot.app/insight/guide.html)をお読みください。  
+> - すべてのドキュメントは中国語で提供されています。近い将来、i18nバージョンを提供する予定です。
+> - Read [the auto-generated wiki on DeepWiki](https://deepwiki.com/RockChinQ/LangBot)。
+
+#### Docker Compose デプロイ
+
+Dockerに慣れているユーザーに適しています。[Dockerデプロイ](https://docs.langbot.app/deploy/langbot/docker.html)のドキュメントを参照してください。
+
+#### BTPanelでのワンクリックデプロイ
+
+LangBotはBTPanelにリストされています。BTPanelをインストールしている場合は、[ドキュメント](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デモ: https://demo.langbot.dev/
+    - ログイン情報: メール: `demo@langbot.app` パスワード: `langbot123456`
+    - 注意: WebUIの効果のみを示しています。公開環境では、機密情報を入力しないでください。
+
+## 🔌 コンポーネントの互換性
+
+### メッセージプラットフォーム
+
+| プラットフォーム | ステータス | 備考 |
+| --- | --- | --- |
+| 個人QQ | ✅ |  |
+| QQ公式API | ✅ |  |
+| WeCom | ✅ |  |
+| WeComCS | ✅ |  |
+| 個人WeChat | ✅ | [Gewechat](https://github.com/Devo919/Gewechat)を使用して接続 |
+| Lark | ✅ |  |
+| DingTalk | ✅ |  |
+| Discord | ✅ |  |
+| Telegram | ✅ |  |
+| Slack | ✅ |  |
+| LINE | 🚧 |  |
+| WhatsApp | 🚧 |  |
+
+🚧: 開発中
+
+### LLMs
+
+| LLM | ステータス | 備考 |
+| --- | --- | --- |
+| [OpenAI](https://platform.openai.com/) | ✅ | 任意のOpenAIインターフェース形式モデルに対応 |
+| [DeepSeek](https://www.deepseek.com/) | ✅ |  |
+| [Moonshot](https://www.moonshot.cn/) | ✅ |  |
+| [Anthropic](https://www.anthropic.com/) | ✅ |  |
+| [xAI](https://x.ai/) | ✅ |  |
+| [Zhipu AI](https://open.bigmodel.cn/) | ✅ |  |
+| [PPIO](https://ppinfra.com/user/register?invited_by=QJKFYD&utm_source=github_langbot) | ✅ | 大模型とGPUリソースプラットフォーム |
+| [Dify](https://dify.ai) | ✅ | LLMOpsプラットフォーム |
+| [Ollama](https://ollama.com/) | ✅ | ローカルLLM実行プラットフォーム |
+| [LMStudio](https://lmstudio.ai/) | ✅ | ローカルLLM実行プラットフォーム |
+| [GiteeAI](https://ai.gitee.com/) | ✅ | LLMインターフェースゲートウェイ(MaaS) |
+| [SiliconFlow](https://siliconflow.cn/) | ✅ | LLMゲートウェイ(MaaS) |
+| [Aliyun Bailian](https://bailian.console.aliyun.com/) | ✅ | LLMゲートウェイ(MaaS), LLMOpsプラットフォーム |
+| [Volc Engine Ark](https://console.volcengine.com/ark/region:ark+cn-beijing/model?vendor=Bytedance&view=LIST_VIEW) | ✅ | LLMゲートウェイ(MaaS), LLMOpsプラットフォーム |
+| [ModelScope](https://modelscope.cn/docs/model-service/API-Inference/intro) | ✅ | LLMゲートウェイ(MaaS) |
+| [MCP](https://modelcontextprotocol.io/) | ✅ | MCPプロトコルをサポート |
+
+## 🤝 コミュニティ貢献
+
+LangBot への貢献に対して、以下の [コード貢献者](https://github.com/RockChinQ/LangBot/graphs/contributors) とコミュニティの他のメンバーに感謝します。
+
+<a href="https://github.com/RockChinQ/LangBot/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=RockChinQ/LangBot" />
+</a>
+
+LangBot の核心チームメンバー:
+
+- [RockChinQ](https://github.com/RockChinQ)
+- [the-lazy-me](https://github.com/the-lazy-me)
+- [wangcham](https://github.com/wangcham)
+- [KaedeSAMA](https://github.com/KaedeSAMA)

components.yaml

@@ -0,0 +1,19 @@
+apiVersion: v1
+kind: Blueprint
+metadata:
+  name: builtin-components
+  label:
+    en_US: Builtin Components
+    zh_CN: 内置组件
+spec:
+  components:
+    ComponentTemplate:
+      fromFiles:
+        - pkg/platform/adapter.yaml
+        - pkg/provider/modelmgr/requester.yaml
+    MessagePlatformAdapter:
+      fromDirs:
+        - path: pkg/platform/sources/
+    LLMAPIRequester:
+      fromDirs:
+        - path: pkg/provider/modelmgr/requesters/

docker-compose.yaml

@@ -1,10 +1,16 @@
 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
-    # 根据具体环境配置网络
+    environment:
+      - TZ=Asia/Shanghai
+    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)

libs/dingtalk_api/EchoHandler.py

@@ -0,0 +1,31 @@
+import asyncio
+import json
+import dingtalk_stream
+from dingtalk_stream import AckMessage
+
+class EchoTextHandler(dingtalk_stream.ChatbotHandler):
+    def __init__(self, client):
+        self.msg_id = ''
+        self.incoming_message = None
+        self.client = client  # 用于更新 DingTalkClient 中的 incoming_message
+
+    """处理钉钉消息"""
+    async def process(self, callback: dingtalk_stream.CallbackMessage):
+        incoming_message = dingtalk_stream.ChatbotMessage.from_dict(callback.data)
+        if incoming_message.message_id != self.msg_id:
+            self.msg_id = incoming_message.message_id
+
+        await self.client.update_incoming_message(incoming_message)
+
+        return AckMessage.STATUS_OK, 'OK'
+
+    async def get_incoming_message(self):
+        """异步等待消息的到来"""
+        while self.incoming_message is None:
+            await asyncio.sleep(0.1)  # 异步等待，避免阻塞
+
+        return self.incoming_message
+
+async def get_dingtalk_client(client_id, client_secret):
+    from api import DingTalkClient  # 延迟导入，避免循环导入
+    return DingTalkClient(client_id, client_secret)

libs/dingtalk_api/api.py

@@ -0,0 +1,255 @@
+import base64
+import json
+import time
+from typing import Callable
+import dingtalk_stream
+from .EchoHandler import EchoTextHandler
+from .dingtalkevent import DingTalkEvent
+import httpx
+import traceback
+
+
+class DingTalkClient:
+    def __init__(self, client_id: str, client_secret: str,robot_name:str,robot_code:str,markdown_card:bool):
+        """初始化 WebSocket 连接并自动启动"""
+        self.credential = dingtalk_stream.Credential(client_id, client_secret)
+        self.client = dingtalk_stream.DingTalkStreamClient(self.credential)
+        self.key = client_id
+        self.secret = client_secret
+        # 在 DingTalkClient 中传入自己作为参数，避免循环导入
+        self.EchoTextHandler = EchoTextHandler(self)
+        self.client.register_callback_handler(dingtalk_stream.chatbot.ChatbotMessage.TOPIC, self.EchoTextHandler)
+        self._message_handlers = {
+            "example":[],
+        }
+        self.access_token = ''
+        self.robot_name = robot_name
+        self.robot_code = robot_code
+        self.access_token_expiry_time = ''
+        self.markdown_card = markdown_card
+
+
+
+    async def get_access_token(self):
+        url = "https://api.dingtalk.com/v1.0/oauth2/accessToken"
+        headers = {
+            "Content-Type": "application/json"
+        }
+        data = {
+            "appKey": self.key,
+            "appSecret": self.secret
+        }
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(url,json=data,headers=headers)
+                if response.status_code == 200:
+                    response_data = response.json()
+                    self.access_token = response_data.get("accessToken")
+                    expires_in = int(response_data.get("expireIn",7200))
+                    self.access_token_expiry_time = time.time() + expires_in - 60
+            except Exception as e:
+                raise Exception(e)
+
+
+    async def is_token_expired(self):
+        """检查token是否过期"""
+        if self.access_token_expiry_time is None:
+            return True
+        return time.time() > self.access_token_expiry_time
+            
+    async def check_access_token(self):
+        if not self.access_token or await self.is_token_expired():
+            return False
+        return bool(self.access_token and self.access_token.strip())
+
+    async def download_image(self,download_code:str):
+        if not await self.check_access_token():
+            await self.get_access_token()
+        url = 'https://api.dingtalk.com/v1.0/robot/messageFiles/download'
+        params = {
+            "downloadCode":download_code,
+            "robotCode":self.robot_code
+        }
+        headers ={
+            "x-acs-dingtalk-access-token": self.access_token
+        }
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, headers=headers, json=params)
+            if response.status_code == 200:
+                result = response.json()
+                download_url = result.get("downloadUrl")
+            else:
+                raise Exception(f"Error: {response.status_code}, {response.text}")
+
+        if download_url:
+            return await self.download_url_to_base64(download_url)
+
+    async def download_url_to_base64(self,download_url):
+        async with httpx.AsyncClient() as client:
+            response = await client.get(download_url)
+            
+            if response.status_code == 200:
+                
+                file_bytes = response.content
+                base64_str = base64.b64encode(file_bytes).decode('utf-8')  # 返回字符串格式
+                return base64_str
+            else:
+                raise Exception("获取文件失败")
+            
+    async def get_audio_url(self,download_code:str):
+        if not await self.check_access_token():
+            await self.get_access_token()
+        url = 'https://api.dingtalk.com/v1.0/robot/messageFiles/download'
+        params = {
+            "downloadCode":download_code,
+            "robotCode":self.robot_code
+        }
+        headers ={
+            "x-acs-dingtalk-access-token": self.access_token
+        }
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, headers=headers, json=params)
+            if response.status_code == 200:
+                result = response.json()
+                download_url = result.get("downloadUrl")
+                if download_url:
+                    return await self.download_url_to_base64(download_url)
+                else:
+                    raise Exception("获取音频失败")
+            else:
+                raise Exception(f"Error: {response.status_code}, {response.text}")
+                
+    async def update_incoming_message(self, message):
+        """异步更新 DingTalkClient 中的 incoming_message"""
+        message_data = await self.get_message(message)
+        if message_data:
+            event = DingTalkEvent.from_payload(message_data)
+            if event:
+                await self._handle_message(event)
+        
+
+    async def send_message(self,content:str,incoming_message):
+        if self.markdown_card:
+            self.EchoTextHandler.reply_markdown(title=self.robot_name+'的回答',text=content,incoming_message=incoming_message)
+        else:
+            self.EchoTextHandler.reply_text(content,incoming_message)
+    
+
+    async def get_incoming_message(self):
+        """获取收到的消息"""
+        return await self.EchoTextHandler.get_incoming_message()
+
+
+
+    def on_message(self, msg_type: str):
+        def decorator(func: Callable[[DingTalkEvent], None]):
+            if msg_type not in self._message_handlers:
+                self._message_handlers[msg_type] = []
+            self._message_handlers[msg_type].append(func)
+            return func
+        return decorator
+
+    async def _handle_message(self, event: DingTalkEvent):
+        """
+        处理消息事件。
+        """
+        msg_type = event.conversation
+        if msg_type in self._message_handlers:
+            for handler in self._message_handlers[msg_type]:
+                await handler(event)
+
+
+    async def get_message(self,incoming_message:dingtalk_stream.chatbot.ChatbotMessage):
+        try:
+            
+            # print(json.dumps(incoming_message.to_dict(), indent=4, ensure_ascii=False))
+            message_data = {
+                "IncomingMessage":incoming_message,
+            }
+            if str(incoming_message.conversation_type) == '1':
+                message_data["conversation_type"] = 'FriendMessage'
+            elif str(incoming_message.conversation_type) == '2':
+                message_data["conversation_type"] = 'GroupMessage'
+
+            
+            if incoming_message.message_type == 'richText':
+            
+                data = incoming_message.rich_text_content.to_dict()
+                for item in data['richText']:
+                    if 'text' in item:
+                        message_data["Content"] = item['text']
+                    if incoming_message.get_image_list()[0]:
+                        message_data["Picture"] = await self.download_image(incoming_message.get_image_list()[0])
+                message_data["Type"] = 'text'
+            
+            elif incoming_message.message_type == 'text':
+                message_data['Content'] = incoming_message.get_text_list()[0]
+
+                message_data["Type"] = 'text'
+            elif incoming_message.message_type == 'picture':
+                message_data['Picture'] = await self.download_image(incoming_message.get_image_list()[0])
+                
+                message_data['Type'] = 'image'
+            elif incoming_message.message_type == 'audio':
+                message_data['Audio'] = await self.get_audio_url(incoming_message.to_dict()['content']['downloadCode'])
+
+                message_data['Type'] = 'audio'
+
+            copy_message_data = message_data.copy()
+            del copy_message_data['IncomingMessage']
+            # print("message_data:", json.dumps(copy_message_data, indent=4, ensure_ascii=False))
+        except Exception:
+            traceback.print_exc()
+            
+        return message_data
+
+    async def send_proactive_message_to_one(self,target_id:str,content:str):
+        if not await self.check_access_token():
+            await self.get_access_token()
+
+        url = 'https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend'
+
+        headers ={
+            "x-acs-dingtalk-access-token":self.access_token,
+            "Content-Type":"application/json",
+        }
+
+        data ={
+            "robotCode":self.robot_code,
+            "userIds":[target_id],
+            "msgKey": "sampleText",
+            "msgParam": json.dumps({"content":content}),
+        }
+        try:
+            async with httpx.AsyncClient() as client:
+                response  = await client.post(url,headers=headers,json=data)
+        except Exception:
+            traceback.print_exc()
+
+
+    async def send_proactive_message_to_group(self,target_id:str,content:str):
+        if not await self.check_access_token():
+            await self.get_access_token()
+
+        url = 'https://api.dingtalk.com/v1.0/robot/groupMessages/send'
+
+        headers ={
+            "x-acs-dingtalk-access-token":self.access_token,
+            "Content-Type":"application/json",
+        }
+
+        data ={
+            "robotCode":self.robot_code,
+            "openConversationId":target_id,
+            "msgKey": "sampleText",
+            "msgParam": json.dumps({"content":content}),
+        }
+        try:
+            async with httpx.AsyncClient() as client:
+                response  = await client.post(url,headers=headers,json=data)
+        except Exception:
+            traceback.print_exc()
+    
+    async def start(self):
+        """启动 WebSocket 连接，监听消息"""
+        await self.client.start() 

libs/dingtalk_api/dingtalkevent.py

@@ -0,0 +1,69 @@
+from typing import Dict, Any, Optional
+import dingtalk_stream
+
+class DingTalkEvent(dict):
+    @staticmethod
+    def from_payload(payload: Dict[str, Any]) -> Optional["DingTalkEvent"]:
+        try:
+            event = DingTalkEvent(payload)
+            return event
+        except KeyError:
+            return None
+        
+    
+    @property
+    def content(self):
+        return self.get("Content","")
+
+    @property
+    def incoming_message(self) -> Optional["dingtalk_stream.chatbot.ChatbotMessage"]:
+        return self.get("IncomingMessage")
+
+    @property
+    def type(self):
+        return self.get("Type","")
+    
+    @property
+    def picture(self):
+        return self.get("Picture","")
+    
+    @property
+    def audio(self):
+        return self.get("Audio","")
+
+    @property
+    def conversation(self):
+        return self.get("conversation_type","")
+    
+    
+
+    def __getattr__(self, key: str) -> Optional[Any]:
+        """
+        允许通过属性访问数据中的任意字段。
+
+        Args:
+            key (str): 字段名。
+
+        Returns:
+            Optional[Any]: 字段值。
+        """
+        return self.get(key)
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        """
+        允许通过属性设置数据中的任意字段。
+
+        Args:
+            key (str): 字段名。
+            value (Any): 字段值。
+        """
+        self[key] = value
+
+    def __repr__(self) -> str:
+        """
+        生成事件对象的字符串表示。
+
+        Returns:
+            str: 字符串表示。
+        """
+        return f"<DingTalkEvent {super().__repr__()}>"

libs/official_account_api/api.py

@@ -0,0 +1,340 @@
+# 微信公众号的加解密算法与企业微信一样，所以直接使用企业微信的加解密算法文件
+from collections import deque
+import time
+import traceback
+from ..wecom_api.WXBizMsgCrypt3 import WXBizMsgCrypt
+import xml.etree.ElementTree as ET
+from quart import Quart,request
+import hashlib
+from typing import Callable, Dict, Any
+from .oaevent import OAEvent
+import httpx
+
+import asyncio
+import time
+import xml.etree.ElementTree as ET
+from pkg.platform.sources import officialaccount as oa
+
+
+
+xml_template = """
+<xml>
+    <ToUserName><![CDATA[{to_user}]]></ToUserName>
+    <FromUserName><![CDATA[{from_user}]]></FromUserName>
+    <CreateTime>{create_time}</CreateTime>
+    <MsgType><![CDATA[text]]></MsgType>
+    <Content><![CDATA[{content}]]></Content>
+</xml>
+"""
+
+
+class OAClient():
+
+    def __init__(self,token:str,EncodingAESKey:str,AppID:str,Appsecret:str):
+        self.token = token
+        self.aes = EncodingAESKey
+        self.appid = AppID
+        self.appsecret = Appsecret
+        self.base_url = 'https://api.weixin.qq.com'
+        self.access_token = ''
+        self.app = Quart(__name__)
+        self.app.add_url_rule('/callback/command', 'handle_callback', self.handle_callback_request, methods=['GET', 'POST'])
+        self._message_handlers = {
+            "example":[],
+        }
+        self.access_token_expiry_time = None
+        self.msg_id_map = {}
+        self.generated_content = {}
+
+    async def handle_callback_request(self):
+
+        try:
+            # 每隔100毫秒查询是否生成ai回答
+            start_time = time.time()
+            signature = request.args.get("signature", "")
+            timestamp = request.args.get("timestamp", "")
+            nonce = request.args.get("nonce", "")
+            echostr = request.args.get("echostr", "")
+            msg_signature = request.args.get("msg_signature","")
+            if msg_signature is None:
+                raise Exception("msg_signature不在请求体中")
+
+            if request.method == 'GET':
+                # 校验签名
+                check_str = "".join(sorted([self.token, timestamp, nonce]))
+                check_signature = hashlib.sha1(check_str.encode("utf-8")).hexdigest()
+                
+                if check_signature == signature:
+                    return echostr  # 验证成功返回echostr
+                else:
+                    raise Exception("拒绝请求")
+            elif request.method == "POST":
+                encryt_msg = await request.data
+                wxcpt =  WXBizMsgCrypt(self.token,self.aes,self.appid)
+                ret,xml_msg = wxcpt.DecryptMsg(encryt_msg,msg_signature,timestamp,nonce)
+                xml_msg = xml_msg.decode('utf-8')
+
+                if ret != 0:
+                    raise Exception("消息解密失败")
+
+                message_data = await self.get_message(xml_msg)
+                if message_data :
+                    event = OAEvent.from_payload(message_data)
+                    if event:
+                        await self._handle_message(event)
+
+                root = ET.fromstring(xml_msg)
+                from_user = root.find("FromUserName").text  # 发送者
+                to_user = root.find("ToUserName").text  # 机器人
+                
+                timeout = 4.80
+                interval = 0.1
+                while True:
+                    content = self.generated_content.pop(message_data["MsgId"], None)
+                    if content:
+                        response_xml = xml_template.format(
+                            to_user=from_user,
+                            from_user=to_user,
+                            create_time=int(time.time()),
+                            content = content
+                        )
+
+                        return response_xml
+                    
+                    if time.time() - start_time >= timeout:
+                        break
+                    
+                    await asyncio.sleep(interval)
+
+                if self.msg_id_map.get(message_data["MsgId"], 1) == 3:
+
+                    # response_xml = xml_template.format(
+                    #     to_user=from_user,
+                    #     from_user=to_user,
+                    #     create_time=int(time.time()),
+                    #     content = "请求失效：暂不支持公众号超过15秒的请求，如有需求，请联系 LangBot 团队。"
+                    # )
+                    print("请求失效：暂不支持公众号超过15秒的请求，如有需求，请联系 LangBot 团队。")
+                    return ''
+
+        except Exception as e:
+            traceback.print_exc()
+
+    
+    async def get_message(self, xml_msg: str):
+
+        root = ET.fromstring(xml_msg)
+
+        message_data = {
+                "ToUserName": root.find("ToUserName").text,
+                "FromUserName": root.find("FromUserName").text,
+                "CreateTime": int(root.find("CreateTime").text),
+                "MsgType": root.find("MsgType").text,
+                "Content": root.find("Content").text if root.find("Content") is not None else None,
+                "MsgId": int(root.find("MsgId").text) if root.find("MsgId") is not None else None,
+        }
+
+        return message_data
+
+
+    async def run_task(self, host: str, port: int, *args, **kwargs):
+        """
+        启动 Quart 应用。
+        """
+        await self.app.run_task(host=host, port=port, *args, **kwargs)
+
+
+    def on_message(self, msg_type: str):
+        """
+        注册消息类型处理器。
+        """
+        def decorator(func: Callable[[OAEvent], None]):
+            if msg_type not in self._message_handlers:
+                self._message_handlers[msg_type] = []
+            self._message_handlers[msg_type].append(func)
+            return func
+        return decorator
+
+    async def _handle_message(self, event: OAEvent):
+        """
+        处理消息事件。
+        """
+        message_id = event.message_id
+        if message_id in self.msg_id_map.keys():
+            self.msg_id_map[message_id] += 1
+            return
+
+        self.msg_id_map[message_id] = 1
+        msg_type = event.type
+        if msg_type in self._message_handlers:
+            for handler in self._message_handlers[msg_type]:
+                await handler(event)
+
+    async def set_message(self,msg_id:int,content:str):
+        self.generated_content[msg_id] = content
+
+
+
+class OAClientForLongerResponse():
+    
+    def __init__(self,token:str,EncodingAESKey:str,AppID:str,Appsecret:str,LoadingMessage:str):
+        self.token = token
+        self.aes = EncodingAESKey
+        self.appid = AppID
+        self.appsecret = Appsecret
+        self.base_url = 'https://api.weixin.qq.com'
+        self.access_token = ''
+        self.app = Quart(__name__)
+        self.app.add_url_rule('/callback/command', 'handle_callback', self.handle_callback_request, methods=['GET', 'POST'])
+        self._message_handlers = {
+            "example":[],
+        }
+        self.access_token_expiry_time = None
+        self.loading_message = LoadingMessage
+        self.msg_queue = {}
+        self.user_msg_queue = {}
+
+    async def handle_callback_request(self):
+        try:
+            start_time = time.time()
+            signature = request.args.get("signature", "")
+            timestamp = request.args.get("timestamp", "")
+            nonce = request.args.get("nonce", "")
+            echostr = request.args.get("echostr", "")
+            msg_signature = request.args.get("msg_signature", "")
+
+            if msg_signature is None:
+                raise Exception("msg_signature不在请求体中")
+
+            if request.method == 'GET':
+                check_str = "".join(sorted([self.token, timestamp, nonce]))
+                check_signature = hashlib.sha1(check_str.encode("utf-8")).hexdigest()
+                return echostr if check_signature == signature else "拒绝请求"
+
+            elif request.method == "POST":
+                encryt_msg = await request.data
+                wxcpt = WXBizMsgCrypt(self.token, self.aes, self.appid)
+                ret, xml_msg = wxcpt.DecryptMsg(encryt_msg, msg_signature, timestamp, nonce)
+                xml_msg = xml_msg.decode('utf-8')
+
+                if ret != 0:
+                    raise Exception("消息解密失败")
+
+                # 解析 XML
+                root = ET.fromstring(xml_msg)
+                from_user = root.find("FromUserName").text
+                to_user = root.find("ToUserName").text
+
+
+                if self.msg_queue.get(from_user) and self.msg_queue[from_user][0]["content"]:
+
+                    queue_top = self.msg_queue[from_user].pop(0)
+                    queue_content = queue_top["content"]
+
+                    # 弹出用户消息
+                    if self.user_msg_queue.get(from_user) and self.user_msg_queue[from_user]:
+                        self.user_msg_queue[from_user].pop(0)
+
+                    response_xml = xml_template.format(
+                        to_user=from_user,
+                        from_user=to_user,
+                        create_time=int(time.time()),
+                        content=queue_content
+                    )
+                    return response_xml
+
+                else:
+                    response_xml = xml_template.format(
+                        to_user=from_user,
+                        from_user=to_user,
+                        create_time=int(time.time()),
+                        content=self.loading_message
+                    )
+                    
+                    if self.user_msg_queue.get(from_user) and self.user_msg_queue[from_user][0]["content"]:
+                        return response_xml
+                    else:
+                        message_data = await self.get_message(xml_msg)
+                        
+                        if message_data:
+                            event = OAEvent.from_payload(message_data)
+                            if event:
+                                self.user_msg_queue.setdefault(from_user,[]).append(
+                                    {
+                                        "content":event.message,
+                                    }
+                                )
+                                await self._handle_message(event)
+
+                        return response_xml
+
+        except Exception as e:
+            traceback.print_exc()
+
+
+
+    async def get_message(self, xml_msg: str):
+
+        root = ET.fromstring(xml_msg)
+
+        message_data = {
+                "ToUserName": root.find("ToUserName").text,
+                "FromUserName": root.find("FromUserName").text,
+                "CreateTime": int(root.find("CreateTime").text),
+                "MsgType": root.find("MsgType").text,
+                "Content": root.find("Content").text if root.find("Content") is not None else None,
+                "MsgId": int(root.find("MsgId").text) if root.find("MsgId") is not None else None,
+        }
+
+        return message_data
+
+    
+
+    async def run_task(self, host: str, port: int, *args, **kwargs):
+        """
+        启动 Quart 应用。
+        """
+        await self.app.run_task(host=host, port=port, *args, **kwargs)
+
+
+
+    def on_message(self, msg_type: str):
+        """
+        注册消息类型处理器。
+        """
+        def decorator(func: Callable[[OAEvent], None]):
+            if msg_type not in self._message_handlers:
+                self._message_handlers[msg_type] = []
+            self._message_handlers[msg_type].append(func)
+            return func
+        return decorator
+
+    async def _handle_message(self, event: OAEvent):
+        """
+        处理消息事件。
+        """
+
+        msg_type = event.type
+        if msg_type in self._message_handlers:
+            for handler in self._message_handlers[msg_type]:
+                await handler(event)
+
+    async def set_message(self,from_user:int,message_id:int,content:str):
+        if  from_user not in self.msg_queue:
+            self.msg_queue[from_user] = []
+        
+        self.msg_queue[from_user].append(
+            {
+                "msg_id":message_id,
+                "content":content,
+            }
+        )
+        
+
+
+
+            
+
+            
+
+

libs/official_account_api/oaevent.py

@@ -0,0 +1,167 @@
+from typing import Dict, Any, Optional
+
+
+class OAEvent(dict):
+    """
+    封装从微信公众号收到的事件数据对象（字典），提供属性以获取其中的字段。
+
+    除 `type` 和 `detail_type` 属性对于任何事件都有效外，其它属性是否存在（若不存在则返回 `None`）依事件类型不同而不同。
+    """
+
+    @staticmethod
+    def from_payload(payload: Dict[str, Any]) -> Optional["OAEvent"]:
+        """
+        从微信公众号事件数据构造 `WecomEvent` 对象。
+
+        Args:
+            payload (Dict[str, Any]): 解密后的微信事件数据。
+
+        Returns:
+            Optional[OAEvent]: 如果事件数据合法，则返回 OAEvent 对象；否则返回 None。
+        """
+        try:
+            event = OAEvent(payload)
+            _ = event.type, event.detail_type  # 确保必须字段存在
+            return event
+        except KeyError:
+            return None
+
+    @property
+    def type(self) -> str:
+        """
+        事件类型，例如 "message"、"event"、"text" 等。
+
+        Returns:
+            str: 事件类型。
+        """
+        return self.get("MsgType", "")
+    
+    @property
+    def picurl(self) -> str:
+        """
+        图片链接
+        """
+        return self.get("PicUrl","")
+
+    @property
+    def detail_type(self) -> str:
+        """
+        事件详细类型，依 `type` 的不同而不同。例如：
+        - 消息事件: "text", "image", "voice", 等
+        - 事件通知: "subscribe", "unsubscribe", "click", 等
+
+        Returns:
+            str: 事件详细类型。
+        """
+        if self.type == "event":
+            return self.get("Event", "")
+        return self.type
+
+    @property
+    def name(self) -> str:
+        """
+        事件名，对于消息事件是 `type.detail_type`，对于其他事件是 `event_type`。
+
+        Returns:
+            str: 事件名。
+        """
+        return f"{self.type}.{self.detail_type}"
+
+    @property
+    def user_id(self) -> Optional[str]:
+        """
+        发送方账号
+        """
+        return self.get("FromUserName")
+
+
+    @property
+    def receiver_id(self) -> Optional[str]:
+        """
+        接收者 ID，例如机器人自身的公众号微信 ID。
+
+        Returns:
+            Optional[str]: 接收者 ID。
+        """
+        return self.get("ToUserName")
+
+    @property
+    def message_id(self) -> Optional[str]:
+        """
+        消息 ID，仅在消息类型事件中存在。
+
+        Returns:
+            Optional[str]: 消息 ID。
+        """
+        return self.get("MsgId")
+
+    @property
+    def message(self) -> Optional[str]:
+        """
+        消息内容，仅在消息类型事件中存在。
+
+        Returns:
+            Optional[str]: 消息内容。
+        """
+        return self.get("Content")
+
+    @property
+    def media_id(self) -> Optional[str]:
+        """
+        媒体文件 ID，仅在图片、语音等消息类型中存在。
+
+        Returns:
+            Optional[str]: 媒体文件 ID。
+        """
+        return self.get("MediaId")
+
+    @property
+    def timestamp(self) -> Optional[int]:
+        """
+        事件发生的时间戳。
+
+        Returns:
+            Optional[int]: 时间戳。
+        """
+        return self.get("CreateTime")
+
+    @property
+    def event_key(self) -> Optional[str]:
+        """
+        事件的 Key 值，例如点击菜单时的 `EventKey`。
+
+        Returns:
+            Optional[str]: 事件 Key。
+        """
+        return self.get("EventKey")
+
+    def __getattr__(self, key: str) -> Optional[Any]:
+        """
+        允许通过属性访问数据中的任意字段。
+
+        Args:
+            key (str): 字段名。
+
+        Returns:
+            Optional[Any]: 字段值。
+        """
+        return self.get(key)
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        """
+        允许通过属性设置数据中的任意字段。
+
+        Args:
+            key (str): 字段名。
+            value (Any): 字段值。
+        """
+        self[key] = value
+
+    def __repr__(self) -> str:
+        """
+        生成事件对象的字符串表示。
+
+        Returns:
+            str: 字符串表示。
+        """
+        return f"<WecomEvent {super().__repr__()}>"

libs/qq_official_api/api.py

@@ -0,0 +1,274 @@
+import time
+from quart import request
+import base64
+import binascii
+import httpx
+from quart import Quart
+import xml.etree.ElementTree as ET
+from typing import Callable, Dict, Any
+from pkg.platform.types import events as platform_events, message as platform_message
+import aiofiles
+from .qqofficialevent import QQOfficialEvent
+import json
+import hmac
+import base64
+import hashlib
+import traceback
+from cryptography.hazmat.primitives.asymmetric import ed25519
+from .qqofficialevent import QQOfficialEvent
+
+def handle_validation(body: dict, bot_secret: str):
+    
+    # bot正确的secert是32位的，此处仅为了适配演示demo
+    while len(bot_secret) < 32:
+        bot_secret = bot_secret * 2
+    bot_secret = bot_secret[:32]
+    # 实际使用场景中以上三行内容可清除
+
+    seed_bytes = bot_secret.encode()
+
+    signing_key = ed25519.Ed25519PrivateKey.from_private_bytes(seed_bytes)
+
+    msg = body['d']['event_ts'] + body['d']['plain_token']
+    msg_bytes = msg.encode()
+
+    signature = signing_key.sign(msg_bytes)
+
+    signature_hex = signature.hex()
+
+    response = {
+        "plain_token": body['d']['plain_token'],
+        "signature": signature_hex
+    }
+
+    return response
+
+class QQOfficialClient:
+    def __init__(self, secret: str, token: str, app_id: str):
+        self.app = Quart(__name__)
+        self.app.add_url_rule(
+            "/callback/command",
+            "handle_callback",
+            self.handle_callback_request,
+            methods=["GET", "POST"],
+        )
+        self.secret = secret
+        self.token = token
+        self.app_id = app_id
+        self._message_handlers = {
+        }
+        self.base_url = "https://api.sgroup.qq.com"
+        self.access_token = ""
+        self.access_token_expiry_time = None
+
+    async def check_access_token(self):
+        """检查access_token是否存在"""
+        if not self.access_token or await self.is_token_expired():
+            return False
+        return bool(self.access_token and self.access_token.strip())
+    
+    async def get_access_token(self):
+        """获取access_token"""
+        url = "https://bots.qq.com/app/getAppAccessToken"
+        async with httpx.AsyncClient() as client:
+            params = {
+                "appId":self.app_id,
+                "clientSecret":self.secret,
+            }
+            headers = {
+                "content-type":"application/json",
+            }
+            try:
+                response = await client.post(url,json=params,headers=headers)
+                if response.status_code == 200:
+                    response_data = response.json()
+                access_token = response_data.get("access_token")
+                expires_in = int(response_data.get("expires_in",7200))
+                self.access_token_expiry_time = time.time() + expires_in - 60
+                if access_token:
+                    self.access_token = access_token
+            except Exception as e:
+                raise Exception(f"获取access_token失败: {e}")
+
+
+    async def handle_callback_request(self):
+        """处理回调请求"""
+        try:
+            # 读取请求数据
+            body = await request.get_data()
+            payload = json.loads(body)
+
+            
+            # 验证是否为回调验证请求
+            if payload.get("op") == 13:
+                # 生成签名
+                response = handle_validation(payload, self.secret)
+
+                return response
+
+            if payload.get("op") == 0:
+                    message_data = await self.get_message(payload)
+                    if message_data:
+                        event = QQOfficialEvent.from_payload(message_data)
+                        await self._handle_message(event)
+            
+            return {"code": 0, "message": "success"}
+
+        except Exception as e:
+            traceback.print_exc()
+            return {"error": str(e)}, 400
+
+    
+
+    async def run_task(self, host: str, port: int, *args, **kwargs):
+        """启动 Quart 应用"""
+        await self.app.run_task(host=host, port=port, *args, **kwargs)
+
+    def on_message(self, msg_type: str):
+        """注册消息类型处理器"""
+
+        def decorator(func: Callable[[platform_events.Event], None]):
+            if msg_type not in self._message_handlers:
+                self._message_handlers[msg_type] = []
+            self._message_handlers[msg_type].append(func)
+            return func
+
+        return decorator
+
+    async def _handle_message(self, event:QQOfficialEvent):
+        """处理消息事件"""
+        msg_type = event.t
+        if msg_type in self._message_handlers:
+            for handler in self._message_handlers[msg_type]:
+                await handler(event)
+
+
+    async def get_message(self,msg:dict) -> Dict[str,Any]:
+        """获取消息"""
+        message_data = {
+            "t":  msg.get("t",{}),
+            "user_openid": msg.get("d",{}).get("author",{}).get("user_openid",{}),
+            "timestamp": msg.get("d",{}).get("timestamp",{}),
+            "d_author_id": msg.get("d",{}).get("author",{}).get("id",{}),
+            "content": msg.get("d",{}).get("content",{}),
+            "d_id": msg.get("d",{}).get("id",{}),
+            "id": msg.get("id",{}),
+            "channel_id": msg.get("d",{}).get("channel_id",{}),
+            "username": msg.get("d",{}).get("author",{}).get("username",{}),
+            "guild_id": msg.get("d",{}).get("guild_id",{}),
+            "member_openid": msg.get("d",{}).get("author",{}).get("openid",{}),
+            "group_openid": msg.get("d",{}).get("group_openid",{})
+        }
+        attachments = msg.get("d", {}).get("attachments", [])
+        image_attachments = [attachment['url'] for attachment in attachments if await self.is_image(attachment)]
+        image_attachments_type = [attachment['content_type'] for attachment in attachments if await self.is_image(attachment)]
+        if image_attachments:
+            message_data["image_attachments"] = image_attachments[0]
+            message_data["content_type"] = image_attachments_type[0]
+        else:
+            
+            message_data["image_attachments"] = None
+        
+        return message_data
+    
+
+    async def is_image(self,attachment:dict) -> bool:
+        """判断是否为图片附件"""
+        content_type = attachment.get("content_type","")
+        return content_type.startswith("image/")
+    
+    
+    async def send_private_text_msg(self,user_openid:str,content:str,msg_id:str):
+        """发送私聊消息"""
+        if not await self.check_access_token():
+             await self.get_access_token()
+
+        url = self.base_url + "/v2/users/" + user_openid + "/messages"
+        async with httpx.AsyncClient() as client:
+            headers = {
+                "Authorization": f"QQBot {self.access_token}",
+                "Content-Type": "application/json",
+            }
+            data = {
+                "content": content,
+                "msg_type": 0,
+                "msg_id": msg_id,
+            }
+            response = await client.post(url,headers=headers,json=data)
+            if response.status_code == 200:
+                return
+            else:
+                raise ValueError(response)
+    
+
+    async def send_group_text_msg(self,group_openid:str,content:str,msg_id:str):
+        """发送群聊消息"""
+        if not await self.check_access_token():
+            await self.get_access_token()
+
+        url = self.base_url + "/v2/groups/" + group_openid + "/messages"
+        async with httpx.AsyncClient() as client:
+            headers = {
+                "Authorization": f"QQBot {self.access_token}",
+                "Content-Type": "application/json",
+            }
+            data = {
+                "content": content,
+                "msg_type": 0,
+                "msg_id": msg_id,
+            }
+            response = await client.post(url,headers=headers,json=data)
+            if response.status_code == 200:
+                return
+            else:
+                raise Exception(response.read().decode())
+
+    async def send_channle_group_text_msg(self,channel_id:str,content:str,msg_id:str):
+        """发送频道群聊消息"""
+        if not await self.check_access_token():
+             await self.get_access_token()
+
+        url = self.base_url + "/channels/" + channel_id + "/messages"
+        async with httpx.AsyncClient() as client:
+            headers = {
+                "Authorization": f"QQBot {self.access_token}",
+                "Content-Type": "application/json",
+            }
+            params = {
+                "content": content,
+                "msg_type": 0,
+                "msg_id": msg_id,
+            }
+            response = await client.post(url,headers=headers,json=params)
+            if response.status_code == 200:
+                return True
+            else:
+                raise Exception(response)
+
+    async def send_channle_private_text_msg(self,guild_id:str,content:str,msg_id:str):
+        """发送频道私聊消息"""
+        if not await self.check_access_token():
+             await self.get_access_token()
+
+        url = self.base_url + "/dms/" + guild_id + "/messages"
+        async with httpx.AsyncClient() as client:
+            headers = {
+                "Authorization": f"QQBot {self.access_token}",
+                "Content-Type": "application/json",
+            }
+            params = {
+                "content": content,
+                "msg_type": 0,
+                "msg_id": msg_id,
+            }
+            response = await client.post(url,headers=headers,json=params)
+            if response.status_code == 200:
+                return True
+            else:
+                raise Exception(response)
+
+    async def is_token_expired(self):
+        """检查token是否过期"""
+        if self.access_token_expiry_time is None:
+            return True
+        return time.time() > self.access_token_expiry_time

libs/qq_official_api/qqofficialevent.py

@@ -0,0 +1,114 @@
+from typing import Dict, Any, Optional
+
+class QQOfficialEvent(dict):
+    @staticmethod
+    def from_payload(payload: Dict[str, Any]) -> Optional["QQOfficialEvent"]:
+        try:
+            event = QQOfficialEvent(payload)
+            return event
+        except KeyError:
+            return None
+        
+
+    @property
+    def t(self) -> str:
+        """
+        事件类型
+        """
+        return self.get("t", "")
+    
+    @property
+    def user_openid(self) -> str:
+        """
+        用户openid
+        """
+        return self.get("user_openid",{})
+    
+    @property
+    def timestamp(self) -> str:
+        """
+        时间戳
+        """
+        return self.get("timestamp",{})
+    
+    
+    @property
+    def d_author_id(self) -> str:
+        """
+        作者id
+        """
+        return self.get("id",{})
+    
+    @property
+    def content(self) -> str:
+        """
+        内容
+        """
+        return self.get("content",'')
+    
+    @property
+    def d_id(self) -> str:
+        """
+        d_id
+        """
+        return self.get("d_id",{})
+    
+    @property
+    def id(self) -> str:
+        """
+        消息id，msg_id
+        """
+        return self.get("id",{})
+    
+    @property
+    def channel_id(self) -> str:
+        """
+        频道id
+        """
+        return self.get("channel_id",{})
+    
+    @property
+    def username(self) -> str:
+        """
+        用户名
+        """
+        return self.get("username",{})
+    
+    @property
+    def guild_id(self) -> str:
+        """
+        频道id
+        """
+        return self.get("guild_id",{})
+    
+    @property
+    def member_openid(self) -> str:
+        """
+        成员openid
+        """
+        return self.get("openid",{})
+    
+    @property
+    def attachments(self) -> str:
+        """
+        附件url
+        """
+        url = self.get("image_attachments", "")
+        if url and not url.startswith("https://"):
+            url = "https://" + url
+        return url
+    
+    @property
+    def group_openid(self) -> str:
+        """
+        群组id
+        """
+        return self.get("group_openid",{})
+    
+    @property
+    def content_type(self) -> str:
+        """
+        文件类型
+        """
+        return self.get("content_type","")
+    

libs/slack_api/api.py

@@ -0,0 +1,111 @@
+import json
+from quart import Quart, jsonify,request
+from slack_sdk.web.async_client import AsyncWebClient
+from .slackevent import SlackEvent
+from typing import Callable, Dict, Any
+from pkg.platform.types import events as platform_events, message as platform_message
+
+class SlackClient():
+    
+      def __init__(self,bot_token:str,signing_secret:str):
+
+            self.bot_token = bot_token
+            self.signing_secret = signing_secret
+            self.app = Quart(__name__)
+            self.client = AsyncWebClient(self.bot_token)
+            self.app.add_url_rule('/callback/command', 'handle_callback', self.handle_callback_request, methods=['GET', 'POST'])
+            self._message_handlers = {
+            "example":[],
+            }
+            self.bot_user_id = None # 避免机器人回复自己的消息
+
+      async def handle_callback_request(self):
+            try:
+                  body = await request.get_data()
+                  data = json.loads(body)
+                  if 'type' in data:
+                        if data['type'] == 'url_verification':
+                              return data['challenge']
+                  
+                  bot_user_id = data.get("event",{}).get("bot_id","")
+
+                  if self.bot_user_id and bot_user_id == self.bot_user_id:
+                        return jsonify({'status': 'ok'})
+                  
+                  
+                  # 处理私信
+                  if data and data.get("event", {}).get("channel_type") in ["im"]:
+                        event = SlackEvent.from_payload(data)
+                        await self._handle_message(event)
+                        return jsonify({'status': 'ok'})
+                  
+                  #处理群聊
+                  if data.get("event",{}).get("type") == 'app_mention':
+                             data.setdefault("event", {})["channel_type"] = "channel"
+                             event = SlackEvent.from_payload(data)
+                             await self._handle_message(event)
+                             return jsonify({'status':'ok'})
+
+                  return jsonify({'status': 'ok'})
+            
+            except Exception as e:
+                 raise(e)
+            
+
+
+      async def _handle_message(self, event: SlackEvent):
+        """
+        处理消息事件。
+        """
+        msg_type = event.type
+        if msg_type in self._message_handlers:
+            for handler in self._message_handlers[msg_type]:
+                await handler(event)
+
+      def on_message(self, msg_type: str):
+        """注册消息类型处理器"""
+        def decorator(func: Callable[[platform_events.Event], None]):
+            if msg_type not in self._message_handlers:
+                self._message_handlers[msg_type] = []
+            self._message_handlers[msg_type].append(func)
+            return func
+        return decorator
+
+      async def send_message_to_channel(self,text:str,channel_id:str):
+            try:
+                  response = await self.client.chat_postMessage(
+                        channel=channel_id,
+                        text=text
+                  )
+                  if self.bot_user_id is None and response.get("ok"):
+                        self.bot_user_id = response["message"]["bot_id"]
+                  return 
+            except Exception as e:
+                  raise e
+
+      async def send_message_to_one(self,text:str,user_id:str):
+            try:
+                  response = await self.client.chat_postMessage(
+                        channel = '@'+user_id,
+                        text= text
+                  )
+                  if self.bot_user_id is None and response.get("ok"):
+                        self.bot_user_id = response["message"]["bot_id"]
+                  
+                  return 
+            except Exception as e:
+                  raise e
+
+      async def run_task(self, host: str, port: int, *args, **kwargs):
+            """
+            启动 Quart 应用。
+            """
+            await self.app.run_task(host=host, port=port, *args, **kwargs)
+
+
+
+
+
+            
+
+

libs/slack_api/slackevent.py

@@ -0,0 +1,91 @@
+from typing import Dict, Any, Optional
+
+class SlackEvent(dict):
+    @staticmethod
+    def from_payload(payload: Dict[str, Any]) -> Optional["SlackEvent"]:
+        try:
+            event = SlackEvent(payload)
+            return event
+        except KeyError:
+            return None
+    
+    @property
+    def text(self) -> str:
+        
+        if self.get("event", {}).get("channel_type") == "im":
+                blocks = self.get("event", {}).get("blocks", [])
+                if not blocks:
+                    return ""
+
+                elements = blocks[0].get("elements", [])
+                if not elements:
+                    return "" 
+
+                elements = elements[0].get("elements", [])
+                text = ""
+
+                for el in elements:
+                    if el.get("type") == "text":
+                        text += el.get("text", "")
+                    elif el.get("type") == "link":
+                        text += el.get("url", "")
+
+                return text 
+
+                
+        if self.get("event",{}).get("channel_type") == 'channel': 
+            message_text = ""
+            for block in self.get("event", {}).get("blocks", []):
+                if block.get("type") == "rich_text":
+                    for element in block.get("elements", []):
+                        if element.get("type") == "rich_text_section":
+                            parts = []
+                            for el in element.get("elements", []):
+                                if el.get("type") == "text":
+                                    parts.append(el["text"])
+                                elif el.get("type") == "link":
+                                    parts.append(el["url"])
+                            message_text = "".join(parts)
+                            
+            return message_text
+
+
+    
+    @property
+    def user_id(self) -> Optional[str]:
+        return self.get("event", {}).get("user","")
+    
+    @property
+    def channel_id(self) -> Optional[str]:
+        return self.get("event", {}).get("channel","")
+    
+    @property
+    def type(self) -> str:
+        """ message对应私聊，app_mention对应频道at """
+        return self.get("event", {}).get("channel_type", "")
+    
+    @property
+    def message_id(self) -> str:
+        return self.get("event_id","")
+    
+    @property
+    def pic_url(self) -> str:
+        """提取 Slack 事件中的图片 URL"""
+        files = self.get("event", {}).get("files", [])
+        if files:
+            return files[0].get("url_private", "")
+        return None
+        
+    
+    @property
+    def sender_name(self) -> str:
+        return self.get("event", {}).get("user","")
+    
+    def __getattr__(self, key: str) -> Optional[Any]:
+        return self.get(key)
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        self[key] = value
+
+    def __repr__(self) -> str:
+        return f"<SlackEvent {super().__repr__()}>"

libs/wecom_api/WXBizMsgCrypt3.py

@@ -0,0 +1,279 @@
+#!/usr/bin/env python
+# -*- encoding:utf-8 -*-
+
+""" 对企业微信发送给企业后台的消息加解密示例代码.
+@copyright: Copyright (c) 1998-2014 Tencent Inc.
+
+"""
+# ------------------------------------------------------------------------
+import logging
+import base64
+import random
+import hashlib
+import time
+import struct
+from Crypto.Cipher import AES
+import xml.etree.cElementTree as ET
+import socket
+
+from . import ierror
+
+
+"""
+Crypto.Cipher包已不再维护，开发者可以通过以下命令下载安装最新版的加解密工具包
+    pip install pycryptodome
+"""
+
+
+class FormatException(Exception):
+    pass
+
+
+def throw_exception(message, exception_class=FormatException):
+    """my define raise exception function"""
+    raise exception_class(message)
+
+
+class SHA1:
+    """计算企业微信的消息签名接口"""
+
+    def getSHA1(self, token, timestamp, nonce, encrypt):
+        """用SHA1算法生成安全签名
+        @param token:  票据
+        @param timestamp: 时间戳
+        @param encrypt: 密文
+        @param nonce: 随机字符串
+        @return: 安全签名
+        """
+        try:
+            sortlist = [token, timestamp, nonce, encrypt]
+            sortlist.sort()
+            sha = hashlib.sha1()
+            sha.update("".join(sortlist).encode())
+            return ierror.WXBizMsgCrypt_OK, sha.hexdigest()
+        except Exception as e:
+            logger = logging.getLogger()
+            logger.error(e)
+            return ierror.WXBizMsgCrypt_ComputeSignature_Error, None
+
+
+class XMLParse:
+    """提供提取消息格式中的密文及生成回复消息格式的接口"""
+
+    # xml消息模板
+    AES_TEXT_RESPONSE_TEMPLATE = """<xml>
+<Encrypt><![CDATA[%(msg_encrypt)s]]></Encrypt>
+<MsgSignature><![CDATA[%(msg_signaturet)s]]></MsgSignature>
+<TimeStamp>%(timestamp)s</TimeStamp>
+<Nonce><![CDATA[%(nonce)s]]></Nonce>
+</xml>"""
+
+    def extract(self, xmltext):
+        """提取出xml数据包中的加密消息
+        @param xmltext: 待提取的xml字符串
+        @return: 提取出的加密消息字符串
+        """
+        try:
+            xml_tree = ET.fromstring(xmltext)
+            encrypt = xml_tree.find("Encrypt")
+            return ierror.WXBizMsgCrypt_OK, encrypt.text
+        except Exception as e:
+            logger = logging.getLogger()
+            logger.error(e)
+            return ierror.WXBizMsgCrypt_ParseXml_Error, None
+
+    def generate(self, encrypt, signature, timestamp, nonce):
+        """生成xml消息
+        @param encrypt: 加密后的消息密文
+        @param signature: 安全签名
+        @param timestamp: 时间戳
+        @param nonce: 随机字符串
+        @return: 生成的xml字符串
+        """
+        resp_dict = {
+            'msg_encrypt': encrypt,
+            'msg_signaturet': signature,
+            'timestamp': timestamp,
+            'nonce': nonce,
+        }
+        resp_xml = self.AES_TEXT_RESPONSE_TEMPLATE % resp_dict
+        return resp_xml
+
+
+class PKCS7Encoder():
+    """提供基于PKCS7算法的加解密接口"""
+
+    block_size = 32
+
+    def encode(self, text):
+        """ 对需要加密的明文进行填充补位
+        @param text: 需要进行填充补位操作的明文
+        @return: 补齐明文字符串
+        """
+        text_length = len(text)
+        # 计算需要填充的位数
+        amount_to_pad = self.block_size - (text_length % self.block_size)
+        if amount_to_pad == 0:
+            amount_to_pad = self.block_size
+        # 获得补位所用的字符
+        pad = chr(amount_to_pad)
+        return text + (pad * amount_to_pad).encode()
+
+    def decode(self, decrypted):
+        """删除解密后明文的补位字符
+        @param decrypted: 解密后的明文
+        @return: 删除补位字符后的明文
+        """
+        pad = ord(decrypted[-1])
+        if pad < 1 or pad > 32:
+            pad = 0
+        return decrypted[:-pad]
+
+
+class Prpcrypt(object):
+    """提供接收和推送给企业微信消息的加解密接口"""
+
+    def __init__(self, key):
+
+        # self.key = base64.b64decode(key+"=")
+        self.key = key
+        # 设置加解密模式为AES的CBC模式
+        self.mode = AES.MODE_CBC
+
+    def encrypt(self, text, receiveid):
+        """对明文进行加密
+        @param text: 需要加密的明文
+        @return: 加密得到的字符串
+        """
+        # 16位随机字符串添加到明文开头
+        text = text.encode()
+        text = self.get_random_str() + struct.pack("I", socket.htonl(len(text))) + text + receiveid.encode()
+
+        # 使用自定义的填充方式对明文进行补位填充
+        pkcs7 = PKCS7Encoder()
+        text = pkcs7.encode(text)
+        # 加密
+        cryptor = AES.new(self.key, self.mode, self.key[:16])
+        try:
+            ciphertext = cryptor.encrypt(text)
+            # 使用BASE64对加密后的字符串进行编码
+            return ierror.WXBizMsgCrypt_OK, base64.b64encode(ciphertext)
+        except Exception as e:
+            logger = logging.getLogger()
+            logger.error(e)
+            return ierror.WXBizMsgCrypt_EncryptAES_Error, None
+
+    def decrypt(self, text, receiveid):
+        """对解密后的明文进行补位删除
+        @param text: 密文
+        @return: 删除填充补位后的明文
+        """
+        try:
+            cryptor = AES.new(self.key, self.mode, self.key[:16])
+            # 使用BASE64对密文进行解码，然后AES-CBC解密
+            plain_text = cryptor.decrypt(base64.b64decode(text))
+        except Exception as e:
+            logger = logging.getLogger()
+            logger.error(e)
+            return ierror.WXBizMsgCrypt_DecryptAES_Error, None
+        try:
+            pad = plain_text[-1]
+            # 去掉补位字符串
+            # pkcs7 = PKCS7Encoder()
+            # plain_text = pkcs7.encode(plain_text)
+            # 去除16位随机字符串
+            content = plain_text[16:-pad]
+            xml_len = socket.ntohl(struct.unpack("I", content[: 4])[0])
+            xml_content = content[4: xml_len + 4]
+            from_receiveid = content[xml_len + 4:]
+        except Exception as e:
+            logger = logging.getLogger()
+            logger.error(e)
+            return ierror.WXBizMsgCrypt_IllegalBuffer, None
+
+        if from_receiveid.decode('utf8') != receiveid:
+            return ierror.WXBizMsgCrypt_ValidateCorpid_Error, None
+        return 0, xml_content
+
+    def get_random_str(self):
+        """ 随机生成16位字符串
+        @return: 16位字符串
+        """
+        return str(random.randint(1000000000000000, 9999999999999999)).encode()
+
+
+class WXBizMsgCrypt(object):
+    # 构造函数
+    def __init__(self, sToken, sEncodingAESKey, sReceiveId):
+        try:
+            self.key = base64.b64decode(sEncodingAESKey + "=")
+            assert len(self.key) == 32
+        except:
+            throw_exception("[error]: EncodingAESKey unvalid !", FormatException)
+            # return ierror.WXBizMsgCrypt_IllegalAesKey,None
+        self.m_sToken = sToken
+        self.m_sReceiveId = sReceiveId
+
+        # 验证URL
+        # @param sMsgSignature: 签名串，对应URL参数的msg_signature
+        # @param sTimeStamp: 时间戳，对应URL参数的timestamp
+        # @param sNonce: 随机串，对应URL参数的nonce
+        # @param sEchoStr: 随机串，对应URL参数的echostr
+        # @param sReplyEchoStr: 解密之后的echostr，当return返回0时有效
+        # @return：成功0，失败返回对应的错误码
+
+    def VerifyURL(self, sMsgSignature, sTimeStamp, sNonce, sEchoStr):
+        sha1 = SHA1()
+        ret, signature = sha1.getSHA1(self.m_sToken, sTimeStamp, sNonce, sEchoStr)
+        if ret != 0:
+            return ret, None
+        if not signature == sMsgSignature:
+            return ierror.WXBizMsgCrypt_ValidateSignature_Error, None
+        pc = Prpcrypt(self.key)
+        ret, sReplyEchoStr = pc.decrypt(sEchoStr, self.m_sReceiveId)
+        return ret, sReplyEchoStr
+
+    def EncryptMsg(self, sReplyMsg, sNonce, timestamp=None):
+        # 将企业回复用户的消息加密打包
+        # @param sReplyMsg: 企业号待回复用户的消息，xml格式的字符串
+        # @param sTimeStamp: 时间戳，可以自己生成，也可以用URL参数的timestamp,如为None则自动用当前时间
+        # @param sNonce: 随机串，可以自己生成，也可以用URL参数的nonce
+        # sEncryptMsg: 加密后的可以直接回复用户的密文，包括msg_signature, timestamp, nonce, encrypt的xml格式的字符串,
+        # return：成功0，sEncryptMsg,失败返回对应的错误码None
+        pc = Prpcrypt(self.key)
+        ret, encrypt = pc.encrypt(sReplyMsg, self.m_sReceiveId)
+        encrypt = encrypt.decode('utf8')
+        if ret != 0:
+            return ret, None
+        if timestamp is None:
+            timestamp = str(int(time.time()))
+        # 生成安全签名
+        sha1 = SHA1()
+        ret, signature = sha1.getSHA1(self.m_sToken, timestamp, sNonce, encrypt)
+        if ret != 0:
+            return ret, None
+        xmlParse = XMLParse()
+        return ret, xmlParse.generate(encrypt, signature, timestamp, sNonce)
+
+    def DecryptMsg(self, sPostData, sMsgSignature, sTimeStamp, sNonce):
+        # 检验消息的真实性，并且获取解密后的明文
+        # @param sMsgSignature: 签名串，对应URL参数的msg_signature
+        # @param sTimeStamp: 时间戳，对应URL参数的timestamp
+        # @param sNonce: 随机串，对应URL参数的nonce
+        # @param sPostData: 密文，对应POST请求的数据
+        #  xml_content: 解密后的原文，当return返回0时有效
+        # @return: 成功0，失败返回对应的错误码
+        # 验证安全签名
+        xmlParse = XMLParse()
+        ret, encrypt = xmlParse.extract(sPostData)
+        if ret != 0:
+            return ret, None
+        sha1 = SHA1()
+        ret, signature = sha1.getSHA1(self.m_sToken, sTimeStamp, sNonce, encrypt)
+        if ret != 0:
+            return ret, None
+        if not signature == sMsgSignature:
+            return ierror.WXBizMsgCrypt_ValidateSignature_Error, None
+        pc = Prpcrypt(self.key)
+        ret, xml_content = pc.decrypt(encrypt, self.m_sReceiveId)
+        return ret, xml_content

libs/wecom_api/api.py

@@ -0,0 +1,318 @@
+from quart import request
+from .WXBizMsgCrypt3 import WXBizMsgCrypt
+import base64
+import binascii
+import httpx
+from quart import Quart
+import xml.etree.ElementTree as ET
+from typing import Callable, Dict, Any
+from .wecomevent import WecomEvent
+from pkg.platform.types import events as platform_events, message as platform_message
+import aiofiles
+
+
+class WecomClient():
+    def __init__(self,corpid:str,secret:str,token:str,EncodingAESKey:str,contacts_secret:str):
+        self.corpid = corpid
+        self.secret = secret
+        self.access_token_for_contacts =''
+        self.token = token
+        self.aes = EncodingAESKey
+        self.base_url = 'https://qyapi.weixin.qq.com/cgi-bin'
+        self.access_token = ''
+        self.secret_for_contacts = contacts_secret
+        self.app = Quart(__name__)
+        self.wxcpt = WXBizMsgCrypt(self.token, self.aes, self.corpid)
+        self.app.add_url_rule('/callback/command', 'handle_callback', self.handle_callback_request, methods=['GET', 'POST'])
+        self._message_handlers = {
+            "example":[],
+        }
+
+    #access——token操作
+    async def check_access_token(self):
+        return bool(self.access_token and self.access_token.strip())
+
+    async def check_access_token_for_contacts(self):
+        return bool(self.access_token_for_contacts and self.access_token_for_contacts.strip())
+
+    async def get_access_token(self,secret):
+        url = f'https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid={self.corpid}&corpsecret={secret}'
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url)
+            data = response.json()
+            if 'access_token' in data:
+                return data['access_token']
+            else:
+                raise Exception(f"未获取access token: {data}")
+
+    async def get_users(self):
+        if not self.check_access_token_for_contacts():
+            self.access_token_for_contacts = await self.get_access_token(self.secret_for_contacts)
+
+        url = self.base_url+'/user/list_id?access_token='+self.access_token_for_contacts
+        async with httpx.AsyncClient() as client:
+            params = {
+                "cursor":"",
+                "limit":10000,
+            }
+            response = await client.post(url,json=params)
+            data = response.json()
+            if data['errcode'] == 0:
+                dept_users = data['dept_user']
+                userid = []
+                for user in dept_users:
+                    userid.append(user["userid"])
+                return userid
+            else:
+                raise Exception("未获取用户")
+            
+    async def send_to_all(self,content:str,agent_id:int):
+        if not self.check_access_token_for_contacts():
+            self.access_token_for_contacts = await self.get_access_token(self.secret_for_contacts)
+
+            url = self.base_url+'/message/send?access_token='+self.access_token_for_contacts
+            user_ids = await self.get_users()
+            user_ids_string = "|".join(user_ids)
+            async with httpx.AsyncClient() as client:
+                params = {
+                "touser" : user_ids_string,
+                "msgtype" : "text",
+                "agentid" : agent_id,
+                "text" : {
+                    "content" : content,
+                },
+                "safe":0,
+                "enable_id_trans": 0,
+                "enable_duplicate_check": 0,
+                "duplicate_check_interval": 1800
+                }
+                response = await client.post(url,json=params)
+                data = response.json()
+                if data['errcode'] != 0:
+                    raise Exception("Failed to send message: "+str(data))
+
+    async def send_image(self,user_id:str,agent_id:int,media_id:str):
+        if not await self.check_access_token():
+            self.access_token = await self.get_access_token(self.secret)
+        url = self.base_url+'/media/upload?access_token='+self.access_token
+        async with httpx.AsyncClient() as client:
+            params = {
+                "touser" : user_id,
+                "toparty" : "",
+                "totag":"",
+                "agentid" : agent_id,
+                "msgtype" : "image",
+                "image" : {
+                    "media_id" : media_id,
+                },
+                "safe":0,
+                "enable_id_trans": 0,
+                "enable_duplicate_check": 0,
+                "duplicate_check_interval": 1800
+            }
+            try:
+                response = await client.post(url,json=params)
+                data = response.json()
+            except Exception as e:
+                raise Exception("Failed to send image: "+str(e))
+
+            # 企业微信错误码40014和42001，代表accesstoken问题
+            if data['errcode'] == 40014 or data['errcode'] == 42001:
+                self.access_token = await self.get_access_token(self.secret)
+                return await self.send_image(user_id,agent_id,media_id)
+
+            if data['errcode'] != 0:
+                raise Exception("Failed to send image: "+str(data))
+            
+    async def send_private_msg(self,user_id:str, agent_id:int,content:str):
+        if not await self.check_access_token():
+            self.access_token = await self.get_access_token(self.secret)
+
+        url = self.base_url+'/message/send?access_token='+self.access_token
+        async with httpx.AsyncClient() as client:
+            params={
+                "touser" : user_id,
+                "msgtype" : "text",
+                "agentid" : agent_id,
+                "text" : {
+                    "content" : content,
+                },
+                "safe":0,
+                "enable_id_trans": 0,
+                "enable_duplicate_check": 0,
+                "duplicate_check_interval": 1800
+            }
+            response = await client.post(url,json=params)
+            data = response.json()
+            if data['errcode'] == 40014 or data['errcode'] == 42001:
+                self.access_token = await self.get_access_token(self.secret)
+                return await self.send_private_msg(user_id,agent_id,content)
+            if data['errcode'] != 0:
+                raise Exception("Failed to send message: "+str(data))
+
+    async def handle_callback_request(self):
+        """
+        处理回调请求，包括 GET 验证和 POST 消息接收。
+        """
+        try:
+
+            msg_signature = request.args.get("msg_signature")
+            timestamp = request.args.get("timestamp")
+            nonce = request.args.get("nonce")
+
+            if request.method == "GET":
+                echostr = request.args.get("echostr")
+                ret, reply_echo_str = self.wxcpt.VerifyURL(msg_signature, timestamp, nonce, echostr)
+                if ret != 0:
+                    raise Exception(f"验证失败，错误码: {ret}")
+                return reply_echo_str
+
+            elif request.method == "POST":
+                encrypt_msg = await request.data
+                ret, xml_msg = self.wxcpt.DecryptMsg(encrypt_msg, msg_signature, timestamp, nonce)
+                if ret != 0:
+                    raise Exception(f"消息解密失败，错误码: {ret}")
+
+                # 解析消息并处理
+                message_data = await self.get_message(xml_msg)
+                if message_data:
+                    event = WecomEvent.from_payload(message_data)  # 转换为 WecomEvent 对象
+                    if event:
+                        await self._handle_message(event)
+
+                return "success"
+        except Exception as e:
+            return f"Error processing request: {str(e)}", 400
+
+    async def run_task(self, host: str, port: int, *args, **kwargs):
+        """
+        启动 Quart 应用。
+        """
+        await self.app.run_task(host=host, port=port, *args, **kwargs)
+
+    def on_message(self, msg_type: str):
+        """
+        注册消息类型处理器。
+        """
+        def decorator(func: Callable[[WecomEvent], None]):
+            if msg_type not in self._message_handlers:
+                self._message_handlers[msg_type] = []
+            self._message_handlers[msg_type].append(func)
+            return func
+        return decorator
+
+    async def _handle_message(self, event: WecomEvent):
+        """
+        处理消息事件。
+        """
+        msg_type = event.type
+        if msg_type in self._message_handlers:
+            for handler in self._message_handlers[msg_type]:
+                await handler(event)
+
+    async def get_message(self, xml_msg: str) -> Dict[str, Any]:
+        """
+        解析微信返回的 XML 消息并转换为字典。
+        """
+        root = ET.fromstring(xml_msg)
+        message_data = {
+            "ToUserName": root.find("ToUserName").text,
+            "FromUserName": root.find("FromUserName").text,
+            "CreateTime": int(root.find("CreateTime").text),
+            "MsgType": root.find("MsgType").text,
+            "Content": root.find("Content").text if root.find("Content") is not None else None,
+            "MsgId": int(root.find("MsgId").text) if root.find("MsgId") is not None else None,
+            "AgentID": int(root.find("AgentID").text) if root.find("AgentID") is not None else None,
+        }
+        if message_data["MsgType"] == "image":
+            message_data["MediaId"] = root.find("MediaId").text if root.find("MediaId") is not None else None
+            message_data["PicUrl"] = root.find("PicUrl").text if root.find("PicUrl") is not None else None
+        
+        return message_data
+    
+    @staticmethod
+    async def get_image_type(image_bytes: bytes) -> str:
+        """
+        通过图片的magic numbers判断图片类型
+        """
+        magic_numbers = {
+            b'\xFF\xD8\xFF': 'jpg',
+            b'\x89\x50\x4E\x47': 'png',
+            b'\x47\x49\x46': 'gif',
+            b'\x42\x4D': 'bmp',
+            b'\x00\x00\x01\x00': 'ico'
+        }
+    
+        for magic, ext in magic_numbers.items():
+            if image_bytes.startswith(magic):
+                return ext
+        return 'jpg'  # 默认返回jpg
+    
+
+    async def upload_to_work(self, image: platform_message.Image):
+        """
+        获取 media_id
+        """
+        if not await self.check_access_token():
+            self.access_token = await self.get_access_token(self.secret)
+
+        url = self.base_url + '/media/upload?access_token=' + self.access_token + '&type=file'
+        file_bytes = None
+        file_name = "uploaded_file.txt"
+
+        # 获取文件的二进制数据
+        if image.path:
+            async with aiofiles.open(image.path, 'rb') as f:
+                file_bytes = await f.read()
+                file_name = image.path.split('/')[-1]
+        elif image.url:
+            file_bytes = await self.download_image_to_bytes(image.url)
+            file_name = image.url.split('/')[-1]
+        elif image.base64:
+            try:
+                base64_data = image.base64
+                if ',' in base64_data:
+                    base64_data = base64_data.split(',', 1)[1]
+                padding = 4 - (len(base64_data) % 4) if len(base64_data) % 4 else 0
+                padded_base64 = base64_data + '=' * padding
+                file_bytes = base64.b64decode(padded_base64)
+            except binascii.Error as e:
+                raise ValueError(f"Invalid base64 string: {str(e)}")
+        else:
+            raise ValueError("image对象出错")
+
+        # 设置 multipart/form-data 格式的文件
+        boundary = "-------------------------acebdf13572468"
+        headers = {
+            'Content-Type': f'multipart/form-data; boundary={boundary}'
+        }
+        body = (
+            f"--{boundary}\r\n"
+            f"Content-Disposition: form-data; name=\"media\"; filename=\"{file_name}\"; filelength={len(file_bytes)}\r\n"
+            f"Content-Type: application/octet-stream\r\n\r\n"
+        ).encode('utf-8') + file_bytes + f"\r\n--{boundary}--\r\n".encode('utf-8')
+
+        # 上传文件
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, headers=headers, content=body)
+            data = response.json()
+            if data['errcode'] == 40014 or data['errcode'] == 42001:
+                self.access_token = await self.get_access_token(self.secret)
+                media_id = await self.upload_to_work(image)
+            if data.get('errcode', 0) != 0:
+                raise Exception("failed to upload file")
+
+            media_id = data.get('media_id')
+            return media_id
+
+    async def download_image_to_bytes(self,url:str) -> bytes:
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url)
+            response.raise_for_status()
+            return response.content
+
+    #进行media_id的获取
+    async def get_media_id(self, image: platform_message.Image):
+
+        media_id = await self.upload_to_work(image=image)
+        return media_id

libs/wecom_api/ierror.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#########################################################################
+# Author: jonyqin
+# Created Time: Thu 11 Sep 2014 01:53:58 PM CST
+# File Name: ierror.py
+# Description:定义错误码含义 
+#########################################################################
+WXBizMsgCrypt_OK = 0
+WXBizMsgCrypt_ValidateSignature_Error = -40001
+WXBizMsgCrypt_ParseXml_Error = -40002
+WXBizMsgCrypt_ComputeSignature_Error = -40003
+WXBizMsgCrypt_IllegalAesKey = -40004
+WXBizMsgCrypt_ValidateCorpid_Error = -40005
+WXBizMsgCrypt_EncryptAES_Error = -40006
+WXBizMsgCrypt_DecryptAES_Error = -40007
+WXBizMsgCrypt_IllegalBuffer = -40008
+WXBizMsgCrypt_EncodeBase64_Error = -40009
+WXBizMsgCrypt_DecodeBase64_Error = -40010
+WXBizMsgCrypt_GenReturnXml_Error = -40011

libs/wecom_api/wecomevent.py

@@ -0,0 +1,179 @@
+from typing import Dict, Any, Optional
+
+
+class WecomEvent(dict):
+    """
+    封装从企业微信收到的事件数据对象（字典），提供属性以获取其中的字段。
+
+    除 `type` 和 `detail_type` 属性对于任何事件都有效外，其它属性是否存在（若不存在则返回 `None`）依事件类型不同而不同。
+    """
+
+    @staticmethod
+    def from_payload(payload: Dict[str, Any]) -> Optional["WecomEvent"]:
+        """
+        从企业微信事件数据构造 `WecomEvent` 对象。
+
+        Args:
+            payload (Dict[str, Any]): 解密后的企业微信事件数据。
+
+        Returns:
+            Optional[WecomEvent]: 如果事件数据合法，则返回 WecomEvent 对象；否则返回 None。
+        """
+        try:
+            event = WecomEvent(payload)
+            _ = event.type, event.detail_type  # 确保必须字段存在
+            return event
+        except KeyError:
+            return None
+
+    @property
+    def type(self) -> str:
+        """
+        事件类型，例如 "message"、"event"、"text" 等。
+
+        Returns:
+            str: 事件类型。
+        """
+        return self.get("MsgType", "")
+    
+    @property
+    def picurl(self) -> str:
+        """
+        图片链接
+        """
+        return self.get("PicUrl")
+
+    @property
+    def detail_type(self) -> str:
+        """
+        事件详细类型，依 `type` 的不同而不同。例如：
+        - 消息事件: "text", "image", "voice", 等
+        - 事件通知: "subscribe", "unsubscribe", "click", 等
+
+        Returns:
+            str: 事件详细类型。
+        """
+        if self.type == "event":
+            return self.get("Event", "")
+        return self.type
+
+    @property
+    def name(self) -> str:
+        """
+        事件名，对于消息事件是 `type.detail_type`，对于其他事件是 `event_type`。
+
+        Returns:
+            str: 事件名。
+        """
+        return f"{self.type}.{self.detail_type}"
+
+    @property
+    def user_id(self) -> Optional[str]:
+        """
+        用户 ID，例如消息的发送者或事件的触发者。
+
+        Returns:
+            Optional[str]: 用户 ID。
+        """
+        return self.get("FromUserName")
+    
+    @property
+    def agent_id(self) -> Optional[int]:
+        """
+        机器人 ID，仅在消息类型事件中存在。
+
+        Returns:
+            Optional[int]: 机器人 ID。
+        """
+        return self.get("AgentID")
+
+    @property
+    def receiver_id(self) -> Optional[str]:
+        """
+        接收者 ID，例如机器人自身的企业微信 ID。
+
+        Returns:
+            Optional[str]: 接收者 ID。
+        """
+        return self.get("ToUserName")
+
+    @property
+    def message_id(self) -> Optional[str]:
+        """
+        消息 ID，仅在消息类型事件中存在。
+
+        Returns:
+            Optional[str]: 消息 ID。
+        """
+        return self.get("MsgId")
+
+    @property
+    def message(self) -> Optional[str]:
+        """
+        消息内容，仅在消息类型事件中存在。
+
+        Returns:
+            Optional[str]: 消息内容。
+        """
+        return self.get("Content")
+
+    @property
+    def media_id(self) -> Optional[str]:
+        """
+        媒体文件 ID，仅在图片、语音等消息类型中存在。
+
+        Returns:
+            Optional[str]: 媒体文件 ID。
+        """
+        return self.get("MediaId")
+
+    @property
+    def timestamp(self) -> Optional[int]:
+        """
+        事件发生的时间戳。
+
+        Returns:
+            Optional[int]: 时间戳。
+        """
+        return self.get("CreateTime")
+
+    @property
+    def event_key(self) -> Optional[str]:
+        """
+        事件的 Key 值，例如点击菜单时的 `EventKey`。
+
+        Returns:
+            Optional[str]: 事件 Key。
+        """
+        return self.get("EventKey")
+
+    def __getattr__(self, key: str) -> Optional[Any]:
+        """
+        允许通过属性访问数据中的任意字段。
+
+        Args:
+            key (str): 字段名。
+
+        Returns:
+            Optional[Any]: 字段值。
+        """
+        return self.get(key)
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        """
+        允许通过属性设置数据中的任意字段。
+
+        Args:
+            key (str): 字段名。
+            value (Any): 字段值。
+        """
+        self[key] = value
+
+    def __repr__(self) -> str:
+        """
+        生成事件对象的字符串表示。
+
+        Returns:
+            str: 字符串表示。
+        """
+        return f"<WecomEvent {super().__repr__()}>"

libs/wecom_customer_service_api/api.py

@@ -0,0 +1,343 @@
+from quart import request
+from ..wecom_api.WXBizMsgCrypt3 import WXBizMsgCrypt
+import base64
+import binascii
+import httpx
+import traceback
+from quart import Quart
+import xml.etree.ElementTree as ET
+from typing import Callable, Dict, Any
+from .wecomcsevent import WecomCSEvent
+from pkg.platform.types import events as platform_events, message as platform_message
+import aiofiles
+
+
+class WecomCSClient():
+    def __init__(self,corpid:str,secret:str,token:str,EncodingAESKey:str):
+        self.corpid = corpid
+        self.secret = secret
+        self.access_token_for_contacts =''
+        self.token = token
+        self.aes = EncodingAESKey
+        self.base_url = 'https://qyapi.weixin.qq.com/cgi-bin'
+        self.access_token = ''
+        self.app = Quart(__name__)
+        self.wxcpt = WXBizMsgCrypt(self.token, self.aes, self.corpid)
+        self.app.add_url_rule('/callback/command', 'handle_callback', self.handle_callback_request, methods=['GET', 'POST'])
+        self._message_handlers = {
+            "example":[],
+        }
+
+    async def get_pic_url(self, media_id: str):
+        if not await self.check_access_token():
+            self.access_token = await self.get_access_token(self.secret)
+
+        url = f"{self.base_url}/media/get?access_token={self.access_token}&media_id={media_id}"
+
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url)
+            if response.headers.get("Content-Type", "").startswith("application/json"):
+                data = response.json()
+                if data.get('errcode') in [40014, 42001]:
+                    self.access_token = await self.get_access_token(self.secret)
+                    return await self.get_pic_url(media_id)
+                else:
+                    raise Exception("Failed to get image: " + str(data))
+
+            # 否则是图片，转成 base64
+            image_bytes = response.content
+            content_type = response.headers.get("Content-Type", "")
+            base64_str = base64.b64encode(image_bytes).decode("utf-8")
+            base64_str = f"data:{content_type};base64,{base64_str}"
+            return base64_str
+
+
+    #access——token操作
+    async def check_access_token(self):
+        return bool(self.access_token and self.access_token.strip())
+
+    async def check_access_token_for_contacts(self):
+        return bool(self.access_token_for_contacts and self.access_token_for_contacts.strip())
+
+    async def get_access_token(self,secret):
+        url = f'https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid={self.corpid}&corpsecret={secret}'
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url)
+            data = response.json()
+            if 'access_token' in data:
+                return data['access_token']
+            else:
+                raise Exception(f"未获取access token: {data}")
+    
+    async def get_detailed_message_list(self,xml_msg:str):
+        # 在本方法中解析消息，并且获得消息的具体内容
+        if isinstance(xml_msg, bytes):
+            xml_msg = xml_msg.decode('utf-8')
+        root = ET.fromstring(xml_msg)
+        token = root.find("Token").text
+        open_kfid = root.find("OpenKfId").text
+        
+        # if open_kfid in self.openkfid_list:
+        #     return None
+        # else:
+        #     self.openkfid_list.append(open_kfid)
+        
+        if not await self.check_access_token():
+            self.access_token = await self.get_access_token(self.secret)
+        
+        url = self.base_url+'/kf/sync_msg?access_token='+ self.access_token
+        async with httpx.AsyncClient() as client:
+            params = {
+                "token": token,
+                "voice_format": 0,
+                "open_kfid": open_kfid,
+            }
+            response = await client.post(url,json=params)
+            data = response.json()
+            if data['errcode'] == 40014 or data['errcode'] == 42001:
+                self.access_token = await self.get_access_token(self.secret)
+                return await self.get_detailed_message_list(xml_msg)
+            if data['errcode'] != 0:
+                raise Exception("Failed to get message")
+            
+            last_msg_data = data['msg_list'][-1]
+            open_kfid = last_msg_data.get("open_kfid")
+            # 进行获取图片操作
+            if last_msg_data.get("msgtype") == "image":
+                media_id = last_msg_data.get("image").get("media_id")
+                picurl = await self.get_pic_url(media_id)
+                last_msg_data["picurl"] = picurl
+            # await self.change_service_status(userid=external_userid,openkfid=open_kfid,servicer=servicer)
+            return last_msg_data
+    
+    
+    async def change_service_status(self,userid:str,openkfid:str,servicer:str):
+        if not await self.check_access_token():
+            self.access_token = await self.get_access_token(self.secret)
+        url = self.base_url+"/kf/service_state/get?access_token="+self.access_token
+        async with httpx.AsyncClient() as client:
+            params = {
+                "open_kfid" : openkfid,
+                "external_userid" : userid,
+                "service_state" : 1,
+                "servicer_userid" : servicer,
+            }
+            response = await client.post(url,json=params)
+            data = response.json()
+            if data['errcode'] == 40014 or data['errcode'] == 42001:
+                self.access_token = await self.get_access_token(self.secret)
+                return await self.change_service_status(userid,openkfid)
+            if data['errcode'] != 0:
+                raise Exception("Failed to change service status: "+str(data))
+            
+
+    async def send_image(self,user_id:str,agent_id:int,media_id:str):
+        if not await self.check_access_token():
+            self.access_token = await self.get_access_token(self.secret)
+        url = self.base_url+'/media/upload?access_token='+self.access_token
+        async with httpx.AsyncClient() as client:
+            params = {
+                "touser" : user_id,
+                "toparty" : "",
+                "totag":"",
+                "agentid" : agent_id,
+                "msgtype" : "image",
+                "image" : {
+                    "media_id" : media_id,
+                },
+                "safe":0,
+                "enable_id_trans": 0,
+                "enable_duplicate_check": 0,
+                "duplicate_check_interval": 1800
+            }
+            try:
+                response = await client.post(url,json=params)
+                data = response.json()
+            except Exception as e:
+                raise Exception("Failed to send image: "+str(e))
+
+            # 企业微信错误码40014和42001，代表accesstoken问题
+            if data['errcode'] == 40014 or data['errcode'] == 42001:
+                self.access_token = await self.get_access_token(self.secret)
+                return await self.send_image(user_id,agent_id,media_id)
+
+            if data['errcode'] != 0:
+                raise Exception("Failed to send image: "+str(data))
+            
+
+    async def send_text_msg(self, open_kfid: str, external_userid: str, msgid: str,content:str):
+        if not await self.check_access_token():
+            self.access_token = await self.get_access_token(self.secret)
+
+        url = f"https://qyapi.weixin.qq.com/cgi-bin/kf/send_msg?access_token={self.access_token}"
+
+        payload = {
+            "touser": external_userid,
+            "open_kfid": open_kfid,
+            "msgid": msgid,
+            "msgtype": "text",
+            "text": {
+                "content": content,
+            }
+        }
+
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, json=payload)
+
+            data = response.json()
+            if data['errcode'] == 40014 or data['errcode'] == 42001:
+                self.access_token = await self.get_access_token(self.secret)
+                return await self.send_text_msg(open_kfid,external_userid,msgid,content)
+            if data['errcode'] != 0:
+                raise Exception("Failed to send message")
+            return data
+
+
+    async def handle_callback_request(self):
+        """
+        处理回调请求，包括 GET 验证和 POST 消息接收。
+        """
+        try:
+
+            msg_signature = request.args.get("msg_signature")
+            timestamp = request.args.get("timestamp")
+            nonce = request.args.get("nonce")
+
+            if request.method == "GET":
+                echostr = request.args.get("echostr")
+                ret, reply_echo_str = self.wxcpt.VerifyURL(msg_signature, timestamp, nonce, echostr)
+                if ret != 0:
+                    raise Exception(f"验证失败，错误码: {ret}")
+                return reply_echo_str
+
+            elif request.method == "POST":
+                encrypt_msg = await request.data
+                ret, xml_msg = self.wxcpt.DecryptMsg(encrypt_msg, msg_signature, timestamp, nonce)
+                if ret != 0:
+                    raise Exception(f"消息解密失败，错误码: {ret}")
+
+                # 解析消息并处理
+                message_data = await self.get_detailed_message_list(xml_msg)
+                if message_data is not None:
+                    event = WecomCSEvent.from_payload(message_data) 
+                    if event:
+                        await self._handle_message(event)
+
+                return "success"
+        except Exception as e:
+            traceback.print_exc()
+            return f"Error processing request: {str(e)}", 400
+
+    async def run_task(self, host: str, port: int, *args, **kwargs):
+        """
+        启动 Quart 应用。
+        """
+        await self.app.run_task(host=host, port=port, *args, **kwargs)
+
+    def on_message(self, msg_type: str):
+        """
+        注册消息类型处理器。
+        """
+        def decorator(func: Callable[[WecomCSEvent], None]):
+            if msg_type not in self._message_handlers:
+                self._message_handlers[msg_type] = []
+            self._message_handlers[msg_type].append(func)
+            return func
+        return decorator
+
+    async def _handle_message(self, event: WecomCSEvent):
+        """
+        处理消息事件。
+        """
+        msg_type = event.type
+        if msg_type in self._message_handlers:
+            for handler in self._message_handlers[msg_type]:
+                await handler(event)
+
+    
+    @staticmethod
+    async def get_image_type(image_bytes: bytes) -> str:
+        """
+        通过图片的magic numbers判断图片类型
+        """
+        magic_numbers = {
+            b'\xFF\xD8\xFF': 'jpg',
+            b'\x89\x50\x4E\x47': 'png',
+            b'\x47\x49\x46': 'gif',
+            b'\x42\x4D': 'bmp',
+            b'\x00\x00\x01\x00': 'ico'
+        }
+    
+        for magic, ext in magic_numbers.items():
+            if image_bytes.startswith(magic):
+                return ext
+        return 'jpg'  # 默认返回jpg
+    
+
+    async def upload_to_work(self, image: platform_message.Image):
+        """
+        获取 media_id
+        """
+        if not await self.check_access_token():
+            self.access_token = await self.get_access_token(self.secret)
+
+        url = self.base_url + '/media/upload?access_token=' + self.access_token + '&type=file'
+        file_bytes = None
+        file_name = "uploaded_file.txt"
+
+        # 获取文件的二进制数据
+        if image.path:
+            async with aiofiles.open(image.path, 'rb') as f:
+                file_bytes = await f.read()
+                file_name = image.path.split('/')[-1]
+        elif image.url:
+            file_bytes = await self.download_image_to_bytes(image.url)
+            file_name = image.url.split('/')[-1]
+        elif image.base64:
+            try:
+                base64_data = image.base64
+                if ',' in base64_data:
+                    base64_data = base64_data.split(',', 1)[1]
+                padding = 4 - (len(base64_data) % 4) if len(base64_data) % 4 else 0
+                padded_base64 = base64_data + '=' * padding
+                file_bytes = base64.b64decode(padded_base64)
+            except binascii.Error as e:
+                raise ValueError(f"Invalid base64 string: {str(e)}")
+        else:
+            raise ValueError("image对象出错")
+
+        # 设置 multipart/form-data 格式的文件
+        boundary = "-------------------------acebdf13572468"
+        headers = {
+            'Content-Type': f'multipart/form-data; boundary={boundary}'
+        }
+        body = (
+            f"--{boundary}\r\n"
+            f"Content-Disposition: form-data; name=\"media\"; filename=\"{file_name}\"; filelength={len(file_bytes)}\r\n"
+            f"Content-Type: application/octet-stream\r\n\r\n"
+        ).encode('utf-8') + file_bytes + f"\r\n--{boundary}--\r\n".encode('utf-8')
+
+        # 上传文件
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, headers=headers, content=body)
+            data = response.json()
+            if data['errcode'] == 40014 or data['errcode'] == 42001:
+                self.access_token = await self.get_access_token(self.secret)
+                media_id = await self.upload_to_work(image)
+            if data.get('errcode', 0) != 0:
+                raise Exception("failed to upload file")
+
+            media_id = data.get('media_id')
+            return media_id
+
+    async def download_image_to_bytes(self,url:str) -> bytes:
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url)
+            response.raise_for_status()
+            return response.content
+
+    #进行media_id的获取
+    async def get_media_id(self, image: platform_message.Image):
+
+        media_id = await self.upload_to_work(image=image)
+        return media_id

libs/wecom_customer_service_api/wecomcsevent.py

@@ -0,0 +1,134 @@
+from typing import Dict, Any, Optional
+
+
+class WecomCSEvent(dict):
+    """
+    封装从企业微信收到的事件数据对象（字典），提供属性以获取其中的字段。
+
+    除 `type` 和 `detail_type` 属性对于任何事件都有效外，其它属性是否存在（若不存在则返回 `None`）依事件类型不同而不同。
+    """
+
+    @staticmethod
+    def from_payload(payload: Dict[str, Any]) -> Optional["WecomCSEvent"]:
+        """
+        从企业微信(客服会话)事件数据构造 `WecomEvent` 对象。
+
+        Args:
+            payload (Dict[str, Any]): 解密后的企业微信事件数据。
+
+        Returns:
+            Optional[WecomEvent]: 如果事件数据合法，则返回 WecomEvent 对象；否则返回 None。
+        """
+        try:
+            event = WecomCSEvent(payload)
+            _ = event.type,
+            return event
+        except KeyError:
+            return None
+
+    @property
+    def type(self) -> str:
+        """
+        事件类型，例如 "message"、"event"、"text" 等。
+
+        Returns:
+            str: 事件类型。
+        """
+        return self.get("msgtype", "")
+    
+    @property
+    def user_id(self) -> Optional[str]:
+        """
+        用户 ID，例如消息的发送者或事件的触发者。
+
+        Returns:
+            Optional[str]: 用户 ID。
+        """
+        return self.get("external_userid")
+
+    @property
+    def receiver_id(self) -> Optional[str]:
+        """
+        接收者 ID，例如机器人自身的企业微信 ID。
+
+        Returns:
+            Optional[str]: 接收者 ID。
+        """
+        return self.get("open_kfid","")
+    
+    @property
+    def picurl(self) -> Optional[str]:
+        """
+        图片 URL，仅在图片消息中存在。
+        base64格式
+        Returns:
+            Optional[str]: 图片 URL。
+        """
+
+        return self.get("picurl","")
+
+    @property
+    def message_id(self) -> Optional[str]:
+        """
+        消息 ID，仅在消息类型事件中存在。
+
+        Returns:
+            Optional[str]: 消息 ID。
+        """
+        return self.get("msgid")
+
+    @property
+    def message(self) -> Optional[str]:
+        """
+        消息内容，仅在消息类型事件中存在。
+
+        Returns:
+            Optional[str]: 消息内容。
+        """
+        if self.get("msgtype") == 'text':
+            return self.get("text").get("content","")
+        else:
+            return None
+
+
+    @property
+    def timestamp(self) -> Optional[int]:
+        """
+        事件发生的时间戳。
+
+        Returns:
+            Optional[int]: 时间戳。
+        """
+        return self.get("send_time")
+
+
+    def __getattr__(self, key: str) -> Optional[Any]:
+        """
+        允许通过属性访问数据中的任意字段。
+
+        Args:
+            key (str): 字段名。
+
+        Returns:
+            Optional[Any]: 字段值。
+        """
+        return self.get(key)
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        """
+        允许通过属性设置数据中的任意字段。
+
+        Args:
+            key (str): 字段名。
+            value (Any): 字段值。
+        """
+        self[key] = value
+
+    def __repr__(self) -> str:
+        """
+        生成事件对象的字符串表示。
+
+        Returns:
+            str: 字符串表示。
+        """
+        return f"<WecomEvent {super().__repr__()}>"

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
@@ -39,20 +49,25 @@ async def main_entry():
     generated_files = await files.generate_files()
 
     if generated_files:
-        print("以下文件不存在，已自动生成，请按需修改配置文件后重启：")
+        print("以下文件不存在，已自动生成：")
         for file in generated_files:
             print("-", file)
 
-        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 +75,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'], auth_type=group.AuthType.USER_TOKEN)
+        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'], auth_type=group.AuthType.USER_TOKEN)
+        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'], auth_type=group.AuthType.USER_TOKEN)
+        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'], auth_type=group.AuthType.USER_TOKEN)
+        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'], auth_type=group.AuthType.USER_TOKEN)
+        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'], auth_type=group.AuthType.USER_TOKEN)
+        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'], auth_type=group.AuthType.USER_TOKEN)
+        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'], auth_type=group.AuthType.USER_TOKEN)
+        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'], auth_type=group.AuthType.USER_TOKEN)
+        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'], auth_type=group.AuthType.USER_TOKEN)
+        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'], auth_type=group.AuthType.USER_TOKEN)
+        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'], auth_type=group.AuthType.USER_TOKEN)
+        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'], auth_type=group.AuthType.USER_TOKEN)
+        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'], auth_type=group.AuthType.USER_TOKEN)
+        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'], auth_type=group.AuthType.USER_TOKEN)
+        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,107 @@
+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",
+                mimetype="text/html"
+            )
+
+        @self.quart_app.route("/<path:path>")
+        async def static_file(path: str):
+
+            mimetype = None
+
+            if path.endswith(".html"):
+                mimetype = "text/html"
+            elif path.endswith(".js"):
+                mimetype = "application/javascript"
+            elif path.endswith(".css"):
+                mimetype = "text/css"
+            elif path.endswith(".png"):
+                mimetype = "image/png"
+            elif path.endswith(".jpg"):
+                mimetype = "image/jpeg"
+            elif path.endswith(".jpeg"):
+                mimetype = "image/jpeg"
+            elif path.endswith(".gif"):
+                mimetype = "image/gif"
+            elif path.endswith(".svg"):
+                mimetype = "image/svg+xml"
+            elif path.endswith(".ico"):
+                mimetype = "image/x-icon"
+            elif path.endswith(".json"):
+                mimetype = "application/json"
+            elif path.endswith(".txt"):
+                mimetype = "text/plain"
+
+            return await quart.send_from_directory(
+                frontend_path,
+                path,
+                mimetype=mimetype
+            )

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/audit/center/v2.py

@@ -9,8 +9,6 @@ from .groups import plugin
 from ...core import app
 
 
-BACKEND_URL = "https://api.qchatgpt.rockchin.top/api/v2"
-
 class V2CenterAPI:
     """中央服务器 v2 API 交互类"""
     
@@ -23,7 +21,7 @@ class V2CenterAPI:
     plugin: plugin.V2PluginDataAPI = None
     """插件 API 组"""
 
-    def __init__(self, ap: app.Application, basic_info: dict = None, runtime_info: dict = None):
+    def __init__(self, ap: app.Application, backend_url: str, basic_info: dict = None, runtime_info: dict = None):
         """初始化"""
 
         logging.debug("basic_info: %s, runtime_info: %s", basic_info, runtime_info)
@@ -31,7 +29,7 @@ class V2CenterAPI:
         apigroup.APIGroup._basic_info = basic_info
         apigroup.APIGroup._runtime_info = runtime_info
 
-        self.main = main.V2MainDataAPI(BACKEND_URL, ap)
-        self.usage = usage.V2UsageDataAPI(BACKEND_URL, ap)
-        self.plugin = plugin.V2PluginDataAPI(BACKEND_URL, ap)
+        self.main = main.V2MainDataAPI(backend_url, ap)
+        self.usage = usage.V2UsageDataAPI(backend_url, ap)
+        self.plugin = plugin.V2PluginDataAPI(backend_url, ap)
 

pkg/audit/identifier.py

@@ -13,14 +13,14 @@ identifier = {
     'instance_create_ts': 0,
 }
 
-HOST_ID_FILE = os.path.expanduser('~/.qchatgpt/host_id.json')
-INSTANCE_ID_FILE = 'res/instance_id.json'
+HOST_ID_FILE = os.path.expanduser('~/.langbot/host_id.json')
+INSTANCE_ID_FILE = 'data/labels/instance_id.json'
 
 def init():
     global identifier
 
-    if not os.path.exists(os.path.expanduser('~/.qchatgpt')):
-        os.mkdir(os.path.expanduser('~/.qchatgpt'))
+    if not os.path.exists(os.path.expanduser('~/.langbot')):
+        os.mkdir(os.path.expanduser('~/.langbot'))
 
     if not os.path.exists(HOST_ID_FILE):
         new_host_id = 'host_'+str(uuid.uuid4())

pkg/command/cmdmgr.py

@@ -8,7 +8,7 @@ from . import entities, operator, errors
 from ..config import manager as cfg_mgr
 
 # 引入所有算子以便注册
-from .operators import func, plugin, default, reset, list as list_cmd, last, next, delc, resend, prompt, cmd, help, version, update
+from .operators import func, plugin, default, reset, list as list_cmd, last, next, delc, resend, prompt, cmd, help, version, update, ollama, model
 
 
 class CommandManager:

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,17 @@ 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,
+        )
 
         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/model.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import typing
+
+from .. import operator, entities, cmdmgr, errors
+
+@operator.operator_class(
+    name="model",
+    help='显示和切换模型列表',
+    usage='!model\n!model show <模型名>\n!model set <模型名>',
+    privilege=2
+)
+class ModelOperator(operator.CommandOperator):
+    """Model命令"""
+    
+    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        content = '模型列表:\n'
+
+        model_list = self.ap.model_mgr.model_list
+
+        for model in model_list:
+            content += f"\n名称: {model.name}\n"
+            content += f"请求器: {model.requester.name}\n"
+
+        content += f"\n当前对话使用模型: {context.query.use_model.name}\n"
+        content += f"新对话默认使用模型: {self.ap.provider_cfg.data.get('model')}\n"
+
+        yield entities.CommandReturn(text=content.strip())
+
+
+@operator.operator_class(
+    name="show",
+    help='显示模型详情',
+    privilege=2,
+    parent_class=ModelOperator
+)
+class ModelShowOperator(operator.CommandOperator):
+    """Model Show命令"""
+    
+    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        model_name = context.crt_params[0]
+
+        model = None
+        for _model in self.ap.model_mgr.model_list:
+            if model_name == _model.name:
+                model = _model
+                break
+
+        if model is None:
+            yield entities.CommandReturn(error=errors.CommandError(f"未找到模型 {model_name}"))
+        else:
+            content = f"模型详情\n"
+            content += f"名称: {model.name}\n"
+            if model.model_name is not None:
+                content += f"请求模型名称: {model.model_name}\n"
+            content += f"请求器: {model.requester.name}\n"
+            content += f"密钥组: {model.token_mgr.provider}\n"
+            content += f"支持视觉: {model.vision_supported}\n"
+            content += f"支持工具: {model.tool_call_supported}\n"
+
+            yield entities.CommandReturn(text=content.strip())
+
+@operator.operator_class(
+    name="set",
+    help='设置默认使用模型',
+    privilege=2,
+    parent_class=ModelOperator
+)
+class ModelSetOperator(operator.CommandOperator):
+    """Model Set命令"""
+    
+    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        model_name = context.crt_params[0]
+
+        model = None
+        for _model in self.ap.model_mgr.model_list:
+            if model_name == _model.name:
+                model = _model
+                break
+
+        if model is None:
+            yield entities.CommandReturn(error=errors.CommandError(f"未找到模型 {model_name}"))
+        else:
+            self.ap.provider_cfg.data['model'] = model_name
+            await self.ap.provider_cfg.dump_config()
+            yield entities.CommandReturn(text=f"已设置当前使用模型为 {model_name}，重置会话以生效")

pkg/command/operators/ollama.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import json
+import typing
+import traceback
+
+import ollama
+from .. import operator, entities, errors
+
+
+@operator.operator_class(
+    name="ollama",
+    help="ollama平台操作",
+    usage="!ollama\n!ollama show <模型名>\n!ollama pull <模型名>\n!ollama del <模型名>"
+)
+class OllamaOperator(operator.CommandOperator):
+    async def execute(
+            self, context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        try:
+            content: str = '模型列表:\n'
+            model_list: list = ollama.list().get('models', [])
+            for model in model_list:
+                content += f"名称: {model['name']}\n"
+                content += f"修改时间: {model['modified_at']}\n"
+                content += f"大小: {bytes_to_mb(model['size'])}MB\n\n"
+            yield entities.CommandReturn(text=f"{content.strip()}")
+        except ollama.ResponseError as e:
+            yield entities.CommandReturn(error=errors.CommandError(f"无法获取模型列表，请确认 Ollama 服务正常"))
+
+
+def bytes_to_mb(num_bytes):
+    mb: float = num_bytes / 1024 / 1024
+    return format(mb, '.2f')
+
+
+@operator.operator_class(
+    name="show",
+    help="ollama模型详情",
+    privilege=2,
+    parent_class=OllamaOperator
+)
+class OllamaShowOperator(operator.CommandOperator):
+    async def execute(
+            self, context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        content: str = '模型详情:\n'
+        try:
+            show: dict = ollama.show(model=context.crt_params[0])
+            model_info: dict = show.get('model_info', {})
+            ignore_show: str = 'too long to show...'
+
+            for key in ['license', 'modelfile']:
+                show[key] = ignore_show
+
+            for key in ['tokenizer.chat_template.rag', 'tokenizer.chat_template.tool_use']:
+                model_info[key] = ignore_show
+
+            content += json.dumps(show, indent=4)
+            yield entities.CommandReturn(text=content.strip())
+        except ollama.ResponseError as e:
+            yield entities.CommandReturn(error=errors.CommandError(f"无法获取模型详情，请确认 Ollama 服务正常"))
+
+@operator.operator_class(
+    name="pull",
+    help="ollama模型拉取",
+    privilege=2,
+    parent_class=OllamaOperator
+)
+class OllamaPullOperator(operator.CommandOperator):
+    async def execute(
+            self, context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        try:
+            model_list: list = ollama.list().get('models', [])
+            if context.crt_params[0] in [model['name'] for model in model_list]:
+                yield entities.CommandReturn(text="模型已存在")
+                return
+        except ollama.ResponseError as e:
+            yield entities.CommandReturn(error=errors.CommandError(f"无法获取模型列表，请确认 Ollama 服务正常"))
+            return
+
+        on_progress: bool = False
+        progress_count: int = 0
+        try:
+            for resp in ollama.pull(model=context.crt_params[0], stream=True):
+                total: typing.Any = resp.get('total')
+                if not on_progress:
+                    if total is not None:
+                        on_progress = True
+                    yield entities.CommandReturn(text=resp.get('status'))
+                else:
+                    if total is None:
+                        on_progress = False
+
+                    completed: typing.Any = resp.get('completed')
+                    if isinstance(completed, int) and isinstance(total, int):
+                        percentage_completed = (completed / total) * 100
+                        if percentage_completed > progress_count:
+                            progress_count += 10
+                            yield entities.CommandReturn(
+                                text=f"下载进度: {completed}/{total} ({percentage_completed:.2f}%)")
+        except ollama.ResponseError as e:
+            yield entities.CommandReturn(text=f"拉取失败: {e.error}")
+
+
+@operator.operator_class(
+    name="del",
+    help="ollama模型删除",
+    privilege=2,
+    parent_class=OllamaOperator
+)
+class OllamaDelOperator(operator.CommandOperator):
+    async def execute(
+            self, context: entities.ExecuteContext
+    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
+        try:
+            ret: str = ollama.delete(model=context.crt_params[0])['status']
+        except ollama.ResponseError as e:
+            ret = f"{e.error}"
+        yield entities.CommandReturn(text=ret)

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/command/operators/version.py

@@ -20,7 +20,7 @@ class VersionCommand(operator.CommandOperator):
 
         try:
             if await self.ap.ver_mgr.is_new_version_available():
-                reply_str += "\n\n有新版本可用, 使用 !update 更新"
+                reply_str += "\n\n有新版本可用。"
         except:
             pass
 

pkg/config/impls/json.py

@@ -37,7 +37,10 @@ class JSONConfigFile(file_model.ConfigFile):
                 self.template_data = json.load(f)
 
         with open(self.config_file_name, "r", encoding="utf-8") as f:
-            cfg = json.load(f)
+            try:
+                cfg = json.load(f)
+            except json.JSONDecodeError as e:
+                raise Exception(f"配置文件 {self.config_file_name} 语法错误: {e}")
 
         if completion:
 

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,25 +2,46 @@ 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
 from ..provider.modelmgr import modelmgr as llm_model_mgr
 from ..provider.sysprompt import sysprompt as llm_prompt_mgr
 from ..provider.tools import toolmgr as llm_tool_mgr
+from ..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
+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 ..discover import engine as discover_engine
+from ..utils import logcache, ip
+from . import taskmgr
+from . import entities as core_entities
+from .bootutils import config
 
 
 class Application:
     """运行时应用对象和上下文"""
 
+    event_loop: asyncio.AbstractEventLoop = None
+
+    # asyncio_tasks: list[asyncio.Task] = []
+    task_mgr: taskmgr.AsyncTaskManager = None
+
+    discover: discover_engine.ComponentDiscoveryEngine = None
+
     platform_mgr: im_mgr.PlatformManager = None
 
     cmd_mgr: cmdmgr.CommandManager = None
@@ -33,6 +54,10 @@ class Application:
 
     tool_mgr: llm_tool_mgr.ToolManager = None
 
+    runner_mgr: runnermgr.RunnerManager = None
+
+    settings_mgr: settings_mgr.SettingsManager = None
+
     # ======= 配置管理器 =======
 
     command_cfg: config_mgr.ConfigManager = None
@@ -55,6 +80,8 @@ class Application:
 
     llm_models_meta: config_mgr.ConfigManager = None
 
+    instance_secret_meta: config_mgr.ConfigManager = None
+
     # =========================
 
     ctr_mgr: center_mgr.V2CenterAPI = None
@@ -69,10 +96,22 @@ class Application:
 
     ver_mgr: version_mgr.VersionManager = None
 
+    ann_mgr: announce_mgr.AnnouncementManager = None
+
     proxy_mgr: proxy_mgr.ProxyManager = None
 
     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
 
@@ -80,34 +119,113 @@ 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 core_entities.LifecycleControlScope.PROVIDER.value:
+                self.logger.info("执行热重载 scope="+scope)
+
+                await self.tool_mgr.shutdown()
+
+                latest_llm_model_config = await config.load_json_config("data/metadata/llm-models.json", "templates/metadata/llm-models.json")
+                self.llm_models_meta = latest_llm_model_config
+                llm_model_mgr_inst = llm_model_mgr.ModelManager(self)
+                await llm_model_mgr_inst.initialize()
+                self.model_mgr = llm_model_mgr_inst
+
+                llm_session_mgr_inst = llm_session_mgr.SessionManager(self)
+                await llm_session_mgr_inst.initialize()
+                self.sess_mgr = llm_session_mgr_inst
+
+                llm_prompt_mgr_inst = llm_prompt_mgr.PromptManager(self)
+                await llm_prompt_mgr_inst.initialize()
+                self.prompt_mgr = llm_prompt_mgr_inst
+
+                llm_tool_mgr_inst = llm_tool_mgr.ToolManager(self)
+                await llm_tool_mgr_inst.initialize()
+                self.tool_mgr = llm_tool_mgr_inst
+
+                runner_mgr_inst = runnermgr.RunnerManager(self)
+                await runner_mgr_inst.initialize()
+                self.runner_mgr = runner_mgr_inst
+            case _:
+                pass

pkg/core/boot.py

@@ -1,32 +1,45 @@
 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
+from .stages import load_config, setup_logger, build_app, migrate, show_notes
 
 
 stage_order = [
     "LoadConfigStage",
     "MigrationStage",
     "SetupLoggerStage",
-    "BuildAppStage"
+    "BuildAppStage",
+    "ShowNotesStage"
 ]
 
 
-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]
         stage_inst = stage_cls()
+
         await stage_inst.run(ap)
 
     await ap.initialize()
@@ -34,6 +47,23 @@ async def make_app() -> app.Application:
     return ap
 
 
-async def main():
-    app_inst = await make_app()
-    await app_inst.run()
+async def main(loop: asyncio.AbstractEventLoop):
+    try:
+
+        # 挂系统信号处理
+        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/config.py

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

pkg/core/bootutils/deps.py

@@ -1,13 +1,14 @@
 import pip
 
+# 检查依赖，防止用户未安装
+# 左边为引入名称，右边为依赖名称
 required_deps = {
     "requests": "requests",
     "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 +16,26 @@ 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",
+    "Crypto": "pycryptodome",
+    "lark_oapi": "lark-oapi",
+    "discord": "discord.py",
+    "cryptography": "cryptography",
+    "gewechat_client": "gewechat-client",
+    "dingtalk_stream": "dingtalk_stream",
+    "dashscope": "dashscope",
+    "telegram": "python-telegram-bot",
+    "certifi": "certifi",
+    "mcp": "mcp",
+    "telegramify_markdown":"telegramify-markdown",
 }
 
 

pkg/core/bootutils/files.py

@@ -24,6 +24,7 @@ required_paths = [
     "data/scenario",
     "data/logs",
     "data/config",
+    "data/labels",
     "plugins"
 ]
 

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,25 @@ 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"
+    PROVIDER = "provider"
 
 
 class LauncherTypes(enum.Enum):
@@ -34,19 +45,19 @@ class Query(pydantic.BaseModel):
     launcher_type: LauncherTypes
     """会话类型，platform处理阶段设置"""
 
-    launcher_id: int
+    launcher_id: typing.Union[int, str]
     """会话ID，platform处理阶段设置"""
 
-    sender_id: int
+    sender_id: typing.Union[int, str]
     """发送者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
+    adapter: msadapter.MessagePlatformAdapter
     """消息平台适配器对象，单个app中可能启用了多个消息平台适配器，此对象表明发起此query的适配器"""
 
     session: typing.Optional[Session] = None
@@ -61,24 +72,51 @@ class Query(pydantic.BaseModel):
     user_message: typing.Optional[llm_entities.Message] = None
     """此次请求的用户消息对象，由前置处理器阶段设置"""
 
+    variables: typing.Optional[dict[str, typing.Any]] = None
+    """变量，由前置处理器阶段设置。在prompt中嵌入或由 Runner 传递到 LLMOps 平台。"""
+
     use_model: typing.Optional[entities.LLMModelInfo] = None
     """使用的模型，由前置处理器阶段设置"""
 
     use_funcs: typing.Optional[list[tools_entities.LLMFunction]] = None
     """使用的函数，由前置处理器阶段设置"""
 
-    resp_messages: typing.Optional[list[llm_entities.Message]] = []
+    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包装而得"""
 
+    # ======= 内部保留 =======
+    current_stage: "pkg.pipeline.stagemgr.StageInstContainer" = None
+    """当前所处阶段"""
+
     class Config:
         arbitrary_types_allowed = True
 
+    # ========== 插件可调用的 API（请求 API） ==========
+
+    def set_variable(self, key: str, value: typing.Any):
+        """设置变量"""
+        if self.variables is None:
+            self.variables = {}
+        self.variables[key] = value
+    
+    def get_variable(self, key: str) -> typing.Any:
+        """获取变量"""
+        if self.variables is None:
+            return None
+        return self.variables.get(key)
+    
+    def get_variables(self) -> dict[str, typing.Any]:
+        """获取所有变量"""
+        if self.variables is None:
+            return {}
+        return self.variables
+
 
 class Conversation(pydantic.BaseModel):
-    """对话，包含于 Session 中，一个 Session 可以有多个历史 Conversation，但只有一个当前使用的 Conversation""" 
+    """对话，包含于 Session 中，一个 Session 可以有多个历史 Conversation，但只有一个当前使用的 Conversation"""
 
     prompt: sysprompt_entities.Prompt
 
@@ -92,20 +130,23 @@ 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}"""
     launcher_type: LauncherTypes
 
-    launcher_id: int
+    launcher_id: typing.Union[int, str]
 
-    sender_id: typing.Optional[int] = 0
+    sender_id: typing.Optional[typing.Union[int, str]] = 0
 
     use_prompt_name: typing.Optional[str] = 'default'
 
     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/migration.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import abc
 import typing
 
-from ..core import app
+from . import app
 
 
 preregistered_migrations: list[typing.Type[Migration]] = []

pkg/core/migrations/m007_qcg_center_url.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("qcg-center-url-config", 7)
+class QCGCenterURLConfigMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        return "qcg-center-url" not in self.ap.system_cfg.data
+
+    async def run(self):
+        """执行迁移"""
+        
+        if "qcg-center-url" not in self.ap.system_cfg.data:
+            self.ap.system_cfg.data["qcg-center-url"] = "https://api.qchatgpt.rockchin.top/api/v2"
+        
+        await self.ap.system_cfg.dump_config()

pkg/core/migrations/m008_ad_fixwin_config_migrate.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("ad-fixwin-cfg-migration", 8)
+class AdFixwinConfigMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        return isinstance(
+            self.ap.pipeline_cfg.data["rate-limit"]["fixwin"]["default"],
+            int
+        )
+
+    async def run(self):
+        """执行迁移"""
+        
+        for session_name in self.ap.pipeline_cfg.data["rate-limit"]["fixwin"]:
+
+            temp_dict = {
+                "window-size": 60,
+                "limit": self.ap.pipeline_cfg.data["rate-limit"]["fixwin"][session_name]
+            }
+            
+            self.ap.pipeline_cfg.data["rate-limit"]["fixwin"][session_name] = temp_dict
+
+        await self.ap.pipeline_cfg.dump_config()

pkg/core/migrations/m009_msg_truncator_cfg.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("msg-truncator-cfg-migration", 9)
+class MsgTruncatorConfigMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        return 'msg-truncate' not in self.ap.pipeline_cfg.data
+
+    async def run(self):
+        """执行迁移"""
+        
+        self.ap.pipeline_cfg.data['msg-truncate'] = {
+            'method': 'round',
+            'round': {
+                'max-round': 10
+            }
+        }
+
+        await self.ap.pipeline_cfg.dump_config()

pkg/core/migrations/m010_ollama_requester_config.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("ollama-requester-config", 10)
+class MsgTruncatorConfigMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        return 'ollama-chat' not in self.ap.provider_cfg.data['requester']
+
+    async def run(self):
+        """执行迁移"""
+        
+        self.ap.provider_cfg.data['requester']['ollama-chat'] = {
+            "base-url": "http://127.0.0.1:11434",
+            "args": {},
+            "timeout": 600
+        }
+
+        await self.ap.provider_cfg.dump_config()

pkg/core/migrations/m011_command_prefix_config.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("command-prefix-config", 11)
+class CommandPrefixConfigMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        return 'command-prefix' not in self.ap.command_cfg.data
+
+    async def run(self):
+        """执行迁移"""
+        
+        self.ap.command_cfg.data['command-prefix'] = [
+            "!", "！"
+        ]
+
+        await self.ap.command_cfg.dump_config()

pkg/core/migrations/m012_runner_config.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("runner-config", 12)
+class RunnerConfigMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        return 'runner' not in self.ap.provider_cfg.data
+
+    async def run(self):
+        """执行迁移"""
+        
+        self.ap.provider_cfg.data['runner'] = 'local-agent'
+
+        await self.ap.provider_cfg.dump_config()

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