📦 release: v3.5.8

✨ feat: 支持微信公众平台

.dockerignore

@@ -0,0 +1,23 @@
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+# github acions
+.github/
+.*ignore
+.git/
+# User-specific stuff
+.idea/
+# Byte-compiled / optimized / DLL files
+__pycache__/
+# Environments
+.env
+.venv
+env/
+venv*/
+ENV/
+.conda/
+README*.md
+dashboard/
+data/
+changelogs/
+tests/
+.ruff_cache/

.github/FUNDING.yml

@@ -0,0 +1,15 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: astrbot
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+polar: # Replace with a single Polar username
+buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
+thanks_dev: # Replace with a single thanks.dev username
+custom: ['https://afdian.com/a/astrbot_team']

.github/ISSUE_TEMPLATE/PLUGIN_PUBLISH.yml

@@ -0,0 +1,40 @@
+name: '🥳 发布插件'
+title: "[Plugin] 插件名"
+description: 提交插件到插件市场
+labels: [ "plugin-publish" ]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        欢迎发布插件到插件市场！请确保您的插件经过**完整的**测试。
+  
+  - type: textarea
+    attributes:
+      label: 插件仓库
+      description: 插件的 GitHub 仓库链接
+      placeholder: >
+        如 https://github.com/Soulter/astrbot-github-cards
+
+  - type: textarea
+    attributes:
+      label: 描述
+      value: |
+        插件名: 
+        插件作者: 
+        插件简介: 
+        支持的消息平台:(必填，如 QQ、微信、飞书)
+        标签:(可选)
+        社交链接:(可选, 将会在插件市场作者名称上作为可点击的链接)
+      description: 必填。请以列表的字段按顺序将插件名、插件作者、插件简介放在这里。如果您不知道支持哪些消息平台，请填写测试过的消息平台。
+
+  - type: checkboxes
+    attributes:
+      label: Code of Conduct
+      options:
+        - label: >
+            我已阅读并同意遵守该项目的 [行为准则](https://docs.github.com/zh/site-policy/github-terms/github-community-code-of-conduct)。
+          required: true
+
+  - type: markdown
+    attributes:
+      value: "❤️"

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -0,0 +1,82 @@
+name: '🐛 报告 Bug'
+title: '[Bug]'
+description: 提交报告帮助我们改进。
+labels: [ 'bug' ]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        感谢您抽出时间报告问题！请准确解释您的问题。如果可能，请提供一个可复现的片段（这有助于更快地解决问题）。
+  - type: textarea
+    attributes:
+      label: 发生了什么
+      description: 描述你遇到的异常
+      placeholder: >
+        一个清晰且具体的描述这个异常是什么。
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: 如何复现？
+      description: >
+        复现该问题的步骤
+      placeholder: >
+        如: 1. 打开 '...'
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: AstrBot 版本、部署方式（如 Windows Docker Desktop 部署）、使用的提供商、使用的消息平台适配器
+      description: >
+        请提供您的 AstrBot 版本和部署方式。
+      placeholder: >
+        如: 3.1.8 Docker, 3.1.7 Windows启动器
+    validations:
+      required: true
+
+  - type: dropdown
+    attributes:
+      label: 操作系统
+      description: |
+        你在哪个操作系统上遇到了这个问题？
+      multiple: false
+      options:
+        - 'Windows'
+        - 'macOS'
+        - 'Linux'
+        - 'Other'
+        - 'Not sure'
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: 报错日志
+      description: >
+        如报错日志、截图等。请提供完整的 Debug 级别的日志，不要介意它很长！
+      placeholder: >
+        请提供完整的报错日志或截图。
+    validations:
+      required: true
+
+  - type: checkboxes
+    attributes:
+      label: 你愿意提交 PR 吗？
+      description: >
+        这不是必需的，但我们很乐意在贡献过程中为您提供指导特别是如果你已经很好地理解了如何实现修复。
+      options:
+        - label: 是的，我愿意提交 PR!
+
+  - type: checkboxes
+    attributes:
+      label: Code of Conduct
+      options:
+        - label: >
+            我已阅读并同意遵守该项目的 [行为准则](https://docs.github.com/zh/site-policy/github-terms/github-community-code-of-conduct)。
+          required: true
+
+  - type: markdown
+    attributes:
+      value: "感谢您填写我们的表单！"

.github/ISSUE_TEMPLATE/feature-request.yml

@@ -0,0 +1,42 @@
+
+name: '🎉 功能建议'
+title: "[Feature]"
+description: 提交建议帮助我们改进。
+labels: [ "enhancement" ]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        感谢您抽出时间提出新功能建议，请准确解释您的想法。
+
+  - type: textarea
+    attributes:
+      label: 描述
+      description: 简短描述您的功能建议。
+
+  - type: textarea
+    attributes:
+      label: 使用场景
+      description: 你想要发生什么？
+      placeholder: >
+        一个清晰且具体的描述这个功能的使用场景。
+
+  - type: checkboxes
+    attributes:
+      label: 你愿意提交PR吗?
+      description: >
+        这不是必须的，但我们欢迎您的贡献。
+      options:
+        - label: 是的, 我愿意提交PR!
+
+  - type: checkboxes
+    attributes:
+      label: Code of Conduct
+      options:
+        - label: >
+            我已阅读并同意遵守该项目的 [行为准则](https://docs.github.com/zh/site-policy/github-terms/github-community-code-of-conduct)。
+          required: true
+
+  - type: markdown
+    attributes:
+      value: "感谢您填写我们的表单！"

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,19 @@
+<!-- 如果有的话，指定这个 PR 要解决的 ISSUE -->
+解决了 #XYZ
+
+### Motivation
+
+<!--解释为什么要改动-->
+
+### Modifications
+
+<!--简单解释你的改动-->
+
+### Check
+
+<!--如果分支被合并，您的代码将服务于数万名用户！在提交前，请核查一下几点内容-->
+
+- [ ] 😊 我的 Commit Message 符合良好的[规范](https://www.conventionalcommits.org/en/v1.0.0/#summary)
+- [ ] 👀 我的更改经过良好的测试
+- [ ] 🤓 我确保没有引入新依赖库，或者引入了新依赖库的同时将其添加到了 `requirements.txt` 和 `pyproject.toml` 文件相应位置。
+- [ ] 😮 我的更改没有引入恶意代码

.github/workflows/auto_release.yml

@@ -0,0 +1,62 @@
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+name: Auto Release
+
+jobs:
+  build-and-publish-to-github-release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Dashboard Build
+        run: |
+          cd dashboard
+          npm install
+          npm run build
+          echo "COMMIT_SHA=$(git rev-parse HEAD)" >> $GITHUB_ENV
+          echo ${{ github.ref_name }} > dist/assets/version
+          zip -r dist.zip dist
+
+      - name: Fetch Changelog
+        run: |
+          echo "changelog=changelogs/${{github.ref_name}}.md" >> "$GITHUB_ENV"
+
+      - name: Create GitHub Release
+        uses: ncipollo/release-action@v1
+        with:
+          bodyFile: ${{ env.changelog }}
+          artifacts: "dashboard/dist.zip"
+      
+  build-and-publish-to-pypi:
+    # 构建并发布到 PyPI
+    runs-on: ubuntu-latest
+    needs: build-and-publish-to-github-release
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.10'
+
+      - name: Install uv
+        run: |
+          python -m pip install uv
+
+      - name: Build package
+        run: |
+          uv build
+
+      - name: Publish to PyPI
+        env:
+          UV_PUBLISH_TOKEN: ${{ secrets.PYPI_TOKEN }}
+        run: |
+          uv publish

.github/workflows/codeql.yml

@@ -0,0 +1,93 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+  schedule:
+    - cron: '21 15 * * 5'
+
+jobs:
+  analyze:
+    name: Analyze (${{ matrix.language }})
+    # Runner size impacts CodeQL analysis time. To learn more, please see:
+    #   - https://gh.io/recommended-hardware-resources-for-running-codeql
+    #   - https://gh.io/supported-runners-and-hardware-resources
+    #   - https://gh.io/using-larger-runners (GitHub.com only)
+    # Consider using larger runners or machines with greater resources for possible analysis time improvements.
+    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
+    timeout-minutes: ${{ (matrix.language == 'swift' && 120) || 360 }}
+    permissions:
+      # required for all workflows
+      security-events: write
+
+      # required to fetch internal or private CodeQL packs
+      packages: read
+
+      # only required for workflows in private repositories
+      actions: read
+      contents: read
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+        - language: python
+          build-mode: none
+        # CodeQL supports the following values keywords for 'language': 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'swift'
+        # Use `c-cpp` to analyze code written in C, C++ or both
+        # Use 'java-kotlin' to analyze code written in Java, Kotlin or both
+        # Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both
+        # To learn more about changing the languages that are analyzed or customizing the build mode for your analysis,
+        # see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning.
+        # If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how
+        # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      with:
+        languages: ${{ matrix.language }}
+        build-mode: ${{ matrix.build-mode }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+
+        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+    # If the analyze step fails for one of the languages you are analyzing with
+    # "We were unable to automatically build your code", modify the matrix above
+    # to set the build mode to "manual" for that language. Then modify this step
+    # to build your code.
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+    - if: matrix.build-mode == 'manual'
+      shell: bash
+      run: |
+        echo 'If you are using a "manual" build mode for one or more of the' \
+          'languages you are analyzing, replace this with the commands to build' \
+          'your code, for example:'
+        echo '  make bootstrap'
+        echo '  make release'
+        exit 1
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3
+      with:
+        category: "/language:${{matrix.language}}"

.github/workflows/coverage_test.yml

@@ -0,0 +1,45 @@
+name: Run tests and upload coverage
+
+on: 
+  push:
+    branches:
+      - master
+    paths-ignore:
+      - 'README.md'
+      - 'changelogs/**'
+      - 'dashboard/**'
+  workflow_dispatch:
+
+jobs:
+  test:
+    name: Run tests and collect coverage
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+      
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+          pip install pytest pytest-cov pytest-asyncio
+
+      - name: Run tests
+        run: |
+          mkdir data
+          mkdir data/plugins
+          mkdir data/config
+          mkdir data/temp
+          export TESTING=true
+          export ZHIPU_API_KEY=${{ secrets.OPENAI_API_KEY }}
+          PYTHONPATH=./ pytest --cov=. tests/ -v -o log_cli=true -o log_level=DEBUG
+
+      - name: Upload results to Codecov
+        uses: codecov/codecov-action@v4
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/dashboard_ci.yml

@@ -0,0 +1,31 @@
+name: AstrBot Dashboard CI
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: npm install, build
+        run: |
+          cd dashboard
+          npm install
+          npm run build
+
+      - name: Inject Commit SHA
+        id: get_sha
+        run: |
+          echo "COMMIT_SHA=$(git rev-parse HEAD)" >> $GITHUB_ENV
+          mkdir -p dashboard/dist/assets
+          echo $COMMIT_SHA > dashboard/dist/assets/version
+
+      - name: Archive production artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist-without-markdown
+          path: |
+            dashboard/dist
+            !dist/**/*.md

.github/workflows/docker-image.yml

@@ -1,23 +1,43 @@
 name: Docker Image CI/CD
 
 on:
-  release:
-    types: [published]
+  push:
+    tags:
+      - 'v*'
   workflow_dispatch:
+
 jobs:
-  publish-latest-docker-image:
+  publish-docker:
     runs-on: ubuntu-latest
-    name: Build and publish docker image
 
     steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Build image
-        run: |
-          git clone https://github.com/Soulter/AstrBot
-          cd AstrBot
-          docker build -t ${{ secrets.DOCKER_HUB_USERNAME }}/astrbot:latest .
-      - name: Publish image
-        run: |
-          docker login -u ${{ secrets.DOCKER_HUB_USERNAME }} -p ${{ secrets.DOCKER_HUB_PASSWORD }}
-          docker push ${{ secrets.DOCKER_HUB_USERNAME }}/astrbot:latest
+      - name: 拉取源码
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 1
+
+      - name: 设置 QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: 设置 Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: 登录到 DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_HUB_USERNAME }}
+          password: ${{ secrets.DOCKER_HUB_PASSWORD }}
+
+      - name: 构建和推送 Docker hub
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            ${{ secrets.DOCKER_HUB_USERNAME }}/astrbot:latest
+            ${{ secrets.DOCKER_HUB_USERNAME }}/astrbot:${{ github.ref_name }}
+
+      - name: Post build notifications
+        run: echo "Docker image has been built and pushed successfully"
+

.gitignore

@@ -1,13 +1,32 @@
 __pycache__
 botpy.log
 .vscode
-data.db
+.venv*
+.idea
+data_v2.db
+data_v3.db
 configs/session
 configs/config.yaml
 **/.DS_Store
 temp
 cmd_config.json
-addons/plugins/
-data/*
+data
 cookies.json
 logs/
+addons/plugins
+.coverage
+
+
+tests/astrbot_plugin_openai
+chroma
+dashboard/node_modules/
+dashboard/dist/
+.DS_Store
+package-lock.json
+package.json
+venv/*
+packages/python_interpreter/workplace
+.venv/*
+.conda/
+.idea
+pytest.ini

.pre-commit-config.yaml

@@ -0,0 +1,13 @@
+default_install_hook_types: [pre-commit, prepare-commit-msg]
+ci:
+  autofix_commit_msg: ":balloon: auto fixes by pre-commit hooks"
+  autofix_prs: true
+  autoupdate_branch: master
+  autoupdate_schedule: weekly
+  autoupdate_commit_msg: ":balloon: pre-commit autoupdate"
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.11.2
+    hooks:
+      - id: ruff
+      - id: ruff-format

.python-version

@@ -0,0 +1 @@
+3.10

Dockerfile

@@ -1,8 +1,35 @@
-FROM python:3.10.13-bullseye
+FROM python:3.10-slim
 WORKDIR /AstrBot
 
 COPY . /AstrBot/
 
-RUN python -m pip install -r requirements.txt
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    nodejs \
+    npm \
+    gcc \
+    build-essential \
+    python3-dev \
+    libffi-dev \
+    libssl-dev \
+    ca-certificates \
+    bash \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN python -m pip install uv
+RUN uv pip install -r requirements.txt --no-cache-dir --system
+RUN uv pip install socksio uv pyffmpeg pilk --no-cache-dir --system
+
+# 释出 ffmpeg
+RUN python -c "from pyffmpeg import FFmpeg; ff = FFmpeg();"
+
+# add /root/.pyffmpeg/bin/ffmpeg to PATH, inorder to use ffmpeg
+RUN echo 'export PATH=$PATH:/root/.pyffmpeg/bin' >> ~/.bashrc
+
+EXPOSE 6185 
+EXPOSE 6186
 
 CMD [ "python", "main.py" ]
+
+
+

Dockerfile_with_node

@@ -0,0 +1,35 @@
+FROM python:3.10-slim
+
+WORKDIR /AstrBot
+
+COPY . /AstrBot/
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    build-essential \
+    python3-dev \
+    libffi-dev \
+    libssl-dev \
+    curl \
+    unzip \
+    ca-certificates \
+    bash \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Installation of Node.js
+ENV NVM_DIR="/root/.nvm"
+RUN curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.2/install.sh | bash && \
+    . "$NVM_DIR/nvm.sh" && \
+    nvm install 22 && \
+    nvm use 22
+RUN /bin/bash -c ". \"$NVM_DIR/nvm.sh\" && node -v && npm -v"
+
+RUN python -m pip install uv
+RUN uv pip install -r requirements.txt --no-cache-dir --system
+RUN uv pip install socksio uv pyffmpeg --no-cache-dir --system
+
+EXPOSE 6185
+EXPOSE 6186
+
+CMD ["python", "main.py"]

LICENSE

@@ -629,8 +629,8 @@ 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>
+    AstrBot is a llm-powered chatbot and develop framework.
+    Copyright (C) 2022-2099 Soulter
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU Affero General Public License as published

README.md

@@ -1,180 +1,215 @@
 <p align="center">
 
-<img src="https://github.com/Soulter/AstrBot/assets/37870767/b1686114-f3aa-4963-b07f-28bf83dc0a10" alt="QQChannelChatGPT" width="200" />
+![yjtp](https://github.com/user-attachments/assets/dcc74009-c57e-4b66-9ae3-0a81fc001255)
+
 </p>
+
 <div align="center">
 
-# AstrBot
+_✨ 易上手的多平台 LLM 聊天机器人及开发框架 ✨_
 
-[![GitHub release (latest by date)](https://img.shields.io/github/v/release/Soulter/AstrBot)](https://github.com/Soulter/AstrBot/releases/latest)
-<img src="https://wakatime.com/badge/user/915e5316-99c6-4563-a483-ef186cf000c9/project/34412545-2e37-400f-bedc-42348713ac1f.svg" alt="wakatime">
-<img src="https://img.shields.io/badge/python-3.9+-blue.svg" alt="python">
-<a href="https://hub.docker.com/r/soulter/astrbot"><img alt="Docker pull" src="https://img.shields.io/docker/pulls/soulter/astrbot.svg"/></a>
-<a href="https://qm.qq.com/cgi-bin/qm/qr?k=EYGsuUTfe00_iOu9JTXS7_TEpMkXOvwv&jump_from=webapi&authKey=uUEMKCROfsseS+8IzqPjzV3y1tzy4AkykwTib2jNkOFdzezF9s9XknqnIaf3CDft">
-<img alt="Static Badge" src="https://img.shields.io/badge/QQ群-322154837-purple">
-</a>
-<img alt="Static Badge" src="https://img.shields.io/badge/频道-x42d56aki2-purple">
+<a href="https://trendshift.io/repositories/12875" target="_blank"><img src="https://trendshift.io/api/badge/repositories/12875" alt="Soulter%2FAstrBot | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
 
-<a href="https://astrbot.soulter.top/center">项目部署</a> ｜
-<a href="https://github.com/Soulter/QQChannelChatGPT/issues">问题提交</a> ｜
-<a href="https://astrbot.soulter.top/center/docs/%E5%BC%80%E5%8F%91/%E6%8F%92%E4%BB%B6%E5%BC%80%E5%8F%91">插件开发（最少只需 25 行）</a>
+[![GitHub release (latest by date)](https://img.shields.io/github/v/release/Soulter/AstrBot?style=for-the-badge&color=76bad9)](https://github.com/Soulter/AstrBot/releases/latest)
+<img src="https://img.shields.io/badge/python-3.10+-blue.svg?style=for-the-badge&color=76bad9" alt="python">
+<a href="https://hub.docker.com/r/soulter/astrbot"><img alt="Docker pull" src="https://img.shields.io/docker/pulls/soulter/astrbot.svg?style=for-the-badge&color=76bad9"/></a>
+<a  href="https://qm.qq.com/cgi-bin/qm/qr?k=wtbaNx7EioxeaqS9z7RQWVXPIxg2zYr7&jump_from=webapi&authKey=vlqnv/AV2DbJEvGIcxdlNSpfxVy+8vVqijgreRdnVKOaydpc+YSw4MctmEbr0k5"><img alt="QQ_community" src="https://img.shields.io/badge/QQ群-775869627-purple?style=for-the-badge&color=76bad9"></a>
+<a  href="https://t.me/+hAsD2Ebl5as3NmY1"><img alt="Telegram_community" src="https://img.shields.io/badge/Telegram-AstrBot-purple?style=for-the-badge&color=76bad9"></a>
+[![wakatime](https://wakatime.com/badge/user/915e5316-99c6-4563-a483-ef186cf000c9/project/018e705a-a1a7-409a-a849-3013485e6c8e.svg?style=for-the-badge&color=76bad9)](https://wakatime.com/badge/user/915e5316-99c6-4563-a483-ef186cf000c9/project/018e705a-a1a7-409a-a849-3013485e6c8e)
+![Dynamic JSON Badge](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.soulter.top%2Fastrbot%2Fstats&query=v&label=7%E6%97%A5%E6%B4%BB%E8%B7%83%E9%87%8F&cacheSeconds=3600&style=for-the-badge&color=3b618e)
+![Dynamic JSON Badge](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.soulter.top%2Fastrbot%2Fplugin-num&query=%24.result&suffix=%E4%B8%AA&style=for-the-badge&label=%E6%8F%92%E4%BB%B6%E5%B8%82%E5%9C%BA&cacheSeconds=3600)
+
+<a href="https://github.com/Soulter/AstrBot/blob/master/README_en.md">English</a> ｜
+<a href="https://github.com/Soulter/AstrBot/blob/master/README_ja.md">日本語</a> ｜
+<a href="https://astrbot.app/">查看文档</a> ｜
+<a href="https://github.com/Soulter/AstrBot/issues">问题提交</a>
 </div>
 
-## 🤔您可能想了解的
-- **如何部署？** [帮助文档](https://astrbot.soulter.top/center/docs/%E9%83%A8%E7%BD%B2/%E9%80%9A%E8%BF%87Docker%E9%83%A8%E7%BD%B2) (部署不成功欢迎进群捞人解决<3)
-- **go-cqhttp启动不成功、报登录失败？** [在这里搜索解决方法](https://github.com/Mrs4s/go-cqhttp/issues)
-- **程序闪退/机器人启动不成功？** [提交issue或加群反馈](https://github.com/Soulter/QQChannelChatGPT/issues)
-- **如何开启 ChatGPT、Claude、HuggingChat 等语言模型？** [查看帮助](https://astrbot.soulter.top/center/docs/%E4%BD%BF%E7%94%A8/%E5%A4%A7%E8%AF%AD%E8%A8%80%E6%A8%A1%E5%9E%8B)
+AstrBot 是一个松耦合、异步、支持多消息平台部署、具有易用的插件系统和完善的大语言模型（LLM）接入功能的聊天机器人及开发框架。
 
-## 🧩功能：
 
-✨ 最近功能：
-1. 可视化面板
-2. Docker 一键部署项目：[链接](https://astrbot.soulter.top/center/docs/%E9%83%A8%E7%BD%B2/%E9%80%9A%E8%BF%87Docker%E9%83%A8%E7%BD%B2)
+<!-- [![codecov](https://img.shields.io/codecov/c/github/soulter/astrbot?style=for-the-badge)](https://codecov.io/gh/Soulter/AstrBot)
+ -->
 
-🌍支持的消息平台/接口
-- go-cqhttp（QQ、QQ频道）
-- QQ 官方机器人接口
-- Telegram（由 [astrbot_plugin_telegram](https://github.com/Soulter/astrbot_plugin_telegram) 插件支持）
+> [!NOTE]
+> 
+> 个人微信接入所依赖的开源项目 Gewechat 近期已停止维护，我们正在评估其他方案（如 xxxbot 等）并将在数日内接入（很快！）。目前推荐微信用户暂时使用**微信官方**推出的企业微信接入方式和微信客服接入方式(版本 >= v3.5.7)。详情请前往 [#1443](https://github.com/AstrBotDevs/AstrBot/issues/1443) 讨论。
 
-🌍支持的AI语言模型一览：
+## ✨ 近期更新
 
-**文字模型/图片理解**
+1. AstrBot 现已支持接入 [MCP](https://modelcontextprotocol.io/) 服务器！
 
-- OpenAI GPT-3（原生支持）
-- OpenAI GPT-3.5（原生支持）
-- OpenAI GPT-4（原生支持）
-- Claude（免费，由[LLMs插件](https://github.com/Soulter/llms)支持）
-- HuggingChat（免费，由[LLMs插件](https://github.com/Soulter/llms)支持）
-- Gemini（免费，由[LLMs插件](https://github.com/Soulter/llms)支持）
+## ✨ 主要功能
 
-**图片生成**
-- OpenAI Dalle 接口
-- NovelAI/Naifu (免费，由[AIDraw插件](https://github.com/Soulter/aidraw)支持)
+> [!NOTE]
+> 🪧 我们正基于前沿科研成果，设计并实现适用于角色扮演和情感陪伴的长短期记忆模型及情绪控制模型，旨在提升对话的真实性与情感表达能力。敬请期待 `v3.6.0` 版本！
 
-🌍机器人支持的能力一览：
-- 可视化面板（beta）
-- 同时部署机器人到 QQ 和 QQ 频道
-- 大模型对话
-- 大模型网页搜索能力 **(目前仅支持OpenAI系模型，最新版本下使用 web on 指令打开)**
-- 插件（在QQ或QQ频道聊天框内输入 `plugin` 了解详情）
-- 回复文字图片渲染（以图片markdown格式回复，**大幅度降低被风控概率**，需手动在`cmd_config.json`内开启qq_pic_mode）
-- 人格设置
-- 关键词回复
-- 热更新（更新本项目时**仅需**在QQ或QQ频道聊天框内输入`update latest r`）
-- Windows一键部署 https://github.com/Soulter/QQChatGPTLauncher/releases/latest
+1. **大语言模型对话**。支持各种大语言模型，包括 OpenAI API、Google Gemini、Llama、Deepseek、ChatGLM 等，支持接入本地部署的大模型，通过 Ollama、LLMTuner。具有多轮对话、人格情境、多模态能力，支持图片理解、语音转文字（Whisper）。
+2. **多消息平台接入**。支持接入 QQ（OneBot）、QQ 频道、微信（Gewechat）、飞书、Telegram。后续将支持钉钉、Discord、WhatsApp、小爱音响。支持速率限制、白名单、关键词过滤、百度内容审核。
+3. **Agent**。原生支持部分 Agent 能力，如代码执行器、自然语言待办、网页搜索。对接 [Dify 平台](https://dify.ai/)，便捷接入 Dify 智能助手、知识库和 Dify 工作流。
+4. **插件扩展**。深度优化的插件机制，支持[开发插件](https://astrbot.app/dev/plugin.html)扩展功能，极简开发。已支持安装多个插件。
+5. **可视化管理面板**。支持可视化修改配置、插件管理、日志查看等功能，降低配置难度。集成 WebChat，可在面板上与大模型对话。
+6. **高稳定性、高模块化**。基于事件总线和流水线的架构设计，高度模块化，低耦合。
 
-<!-- 
-### 基本功能
-<details> 
- <summary>✅ 回复符合上下文</summary>
+> [!TIP]
+> WebUI 在线体验 Demo: [https://demo.astrbot.app/](https://demo.astrbot.app/)
+> 
+> 用户名: `astrbot`, 密码: `astrbot`。
 
-   -  程序向API发送近多次对话内容，模型根据上下文生成回复
+## ✨ 使用方式
 
-   -  你可在`configs/config.yaml`中修改`total_token_limit`来近似控制缓存大小。
- </details> 
+#### Docker 部署
 
-<details> 
- <summary>✅ 超额自动切换</summary>
+请参阅官方文档 [使用 Docker 部署 AstrBot](https://astrbot.app/deploy/astrbot/docker.html#%E4%BD%BF%E7%94%A8-docker-%E9%83%A8%E7%BD%B2-astrbot) 。
 
-   -  超额时，程序自动切换openai的key，方便快捷
+#### Windows 一键安装器部署
+
+请参阅官方文档 [使用 Windows 一键安装器部署 AstrBot](https://astrbot.app/deploy/astrbot/windows.html) 。
+
+#### 宝塔面板部署
+
+请参阅官方文档 [宝塔面板部署](https://astrbot.app/deploy/astrbot/btpanel.html) 。
+
+#### CasaOS 部署
+
+社区贡献的部署方式。
+
+请参阅官方文档 [CasaOS 部署](https://astrbot.app/deploy/astrbot/casaos.html) 。
+
+#### 手动部署
+
+推荐使用 `uv`。
+
+```bash
+git clone https://github.com/AstrBotDevs/AstrBot && cd AstrBot
+pip install uv
+uv run main.py
+```
+
+或者请参阅官方文档 [通过源码部署 AstrBot](https://astrbot.app/deploy/astrbot/cli.html) 。
+
+#### Replit 部署
+
+[![Run on Repl.it](https://repl.it/badge/github/Soulter/AstrBot)](https://repl.it/github/Soulter/AstrBot)
+
+## ⚡ 消息平台支持情况
+
+| 平台    | 支持性 | 详情 | 消息类型 |
+| -------- | ------- | ------- | ------ |
+| QQ(官方机器人接口) | ✔    | 私聊、群聊，QQ 频道私聊、群聊 | 文字、图片 |
+| QQ(OneBot)      | ✔    | 私聊、群聊 | 文字、图片、语音 |
+| 微信个人号    | ✔    | 微信个人号私聊、群聊 | 文字、图片、语音 |
+| Telegram   | ✔    | 私聊、群聊 | 文字、图片 |
+| 企业微信    | ✔    | 私聊 | 文字、图片、语音 |
+| 微信客服    | ✔    | 私聊 | 文字、图片 |
+| 飞书   | ✔    | 私聊、群聊 | 文字、图片 |
+| 钉钉   | ✔    | 私聊、群聊 | 文字、图片 |
+| 微信对话开放平台 | 🚧    | 计划内 | - |
+| Discord   | 🚧    | 计划内 | - |
+| WhatsApp   | 🚧    | 计划内 | - |
+| 小爱音响   | 🚧    | 计划内 | - |
+
+## ⚡ 提供商支持情况
+
+| 名称    | 支持性 | 类型 | 备注 |
+| -------- | ------- | ------- | ------- |
+| OpenAI API | ✔    | 文本生成 | 也支持 DeepSeek、Google Gemini、GLM、Kimi、硅基流动、xAI 等兼容 OpenAI API 的服务 |
+| Claude API | ✔    | 文本生成 |  |
+| Google Gemini API | ✔    | 文本生成 |  |
+| Dify | ✔    | LLMOps |  |
+| DashScope(阿里云百炼应用) | ✔    | LLMOps |  |
+| Ollama | ✔    | 模型加载器 | 本地部署 DeepSeek、Llama 等开源语言模型 |
+| LM Studio | ✔    | 模型加载器 | 本地部署 DeepSeek、Llama 等开源语言模型 |
+| LLMTuner | ✔    | 模型加载器 | 本地加载 lora 等微调模型 |
+| OneAPI | ✔    | LLM 分发系统 |  |
+| Whisper | ✔    | 语音转文本 | 支持 API、本地部署 |
+| SenseVoice | ✔    | 语音转文本 | 本地部署 |
+| OpenAI TTS API | ✔    | 文本转语音 |  |
+| GSVI | ✔    | 文本转语音 | GPT-Sovits-Inference |
+| Fishaudio | ✔    | 文本转语音 | GPT-Sovits 作者参与的项目 |
+| Edge-TTS | ✔    | 文本转语音 | Edge 浏览器的免费 TTS |
+
+## ❤️ 贡献
+
+欢迎任何 Issues/Pull Requests！只需要将你的更改提交到此项目 ：)
+
+### 如何贡献
+
+你可以通过查看问题或帮助审核 PR（拉取请求）来贡献。任何问题或 PR 都欢迎参与，以促进社区贡献。当然，这些只是建议，你可以以任何方式进行贡献。对于新功能的添加，请先通过 Issue 讨论。
+
+### 开发环境
+
+AstrBot 使用 `ruff` 进行代码格式化和检查。
+
+```bash
+git clone https://github.com/Soulter/AstrBot
+pip install pre-commit
+pre-commit install
+```
+
+## 🌟 支持
+
+- Star 这个项目！
+- 在[爱发电](https://afdian.com/a/soulter)支持我！
+- 在[微信](https://drive.soulter.top/f/pYfA/d903f4fa49a496fda3f16d2be9e023b5.png)支持我~
+
+## ✨ Demo
+
+<details><summary>👉 点击展开多张 Demo 截图 👈</summary>
+
+<div align='center'>
+
+<img src="https://github.com/user-attachments/assets/4ee688d9-467d-45c8-99d6-368f9a8a92d8" width="600">
+
+_✨基于 Docker 的沙箱化代码执行器（Beta 测试）✨_
+
+<img src="https://github.com/user-attachments/assets/0378f407-6079-4f64-ae4c-e97ab20611d2" height=500>
+
+_✨ 多模态、网页搜索、长文本转图片（可配置） ✨_
+
+<img src="https://github.com/user-attachments/assets/e137a9e1-340a-4bf2-bb2b-771132780735" height=150>
+<img src="https://github.com/user-attachments/assets/480f5e82-cf6a-4955-a869-0d73137aa6e1" height=150>
+
+_✨ 插件系统——部分插件展示 ✨_
+
+<img src="https://github.com/user-attachments/assets/0cdbf564-2f59-4da5-b524-ce0e7ef3d978" width=600>
+
+_✨ WebUI ✨_
+
+</div>
 
 </details>
 
-<details> 
 
- <summary>✅ 支持统计频道、消息数量等信息</summary> 
+## ❤️ Special Thanks
 
-   -  实现了简单的统计功能
+特别感谢所有 Contributors 和插件开发者对 AstrBot 的贡献 ❤️
 
- </details>
+<a href="https://github.com/AstrBotDevs/AstrBot/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=AstrBotDevs/AstrBot" />
+</a>
 
-<details> 
- <summary>✅ 多并发处理，回复速度快</summary> 
+此外，本项目的诞生离不开以下开源项目：
 
-   -  使用了协程，理论最高可以支持每个子频道每秒回复5条信息
+- [NapNeko/NapCatQQ](https://github.com/NapNeko/NapCatQQ)
+- [wechatpy/wechatpy](https://github.com/wechatpy/wechatpy)
 
- </details>
+## ⭐ Star History
 
-<details>
- <summary>✅ 持久化转储历史记录，重启不丢失</summary> 
+> [!TIP] 
+> 如果本项目对您的生活 / 工作产生了帮助，或者您关注本项目的未来发展，请给项目 Star，这是我维护这个开源项目的动力 <3
 
-   -  使用内置的sqlite数据库存储历史记录到本地
+<div align="center">
     
-   -  方式为定时转储，可在`config.yaml`下修改`dump_history_interval`来修改间隔时间，单位为分钟。
+[![Star History Chart](https://api.star-history.com/svg?repos=soulter/astrbot&type=Date)](https://star-history.com/#soulter/astrbot&Date)
 
- </details>
+</div>
 
-<details> 
- <summary>✅ 支持多种指令控制</summary> 
+## Disclaimer
 
-   -  详见下方`指令功能`
+1. The project is protected under the `AGPL-v3` opensource license.
+2. The deployment of WeChat (personal account) utilizes [Gewechat](https://github.com/Devo919/Gewechat) service. AstrBot only guarantees connectivity with Gewechat and recommends using a WeChat account that is not frequently used. In the event of account risk control, the author of this project shall not bear any responsibility.
+3. Please ensure compliance with local laws and regulations when using this project.
 
- </details>
+_私は、高性能ですから!_
 
-<details>
-<summary>✅ 官方API，稳定</summary>
-
-   -  不使用ChatGPT逆向接口，而使用官方API接口，稳定方便。
-
-   -  QQ频道机器人框架为QQ官方开源的框架，稳定。
-
-</details> -->
-
-<!-- > 关于token：token就相当于是AI中的单词数（但是不等于单词数），`text-davinci-003`模型中最大可以支持`4097`个token。在发送信息时，这个机器人会将用户的历史聊天记录打包发送给ChatGPT，因此，`token`也会相应的累加，为了保证聊天的上下文的逻辑性，就有了缓存token。 -->
-
-### 🛠️ 插件支持
-
-本项目支持接入插件。
-
-> 使用`plugin i 插件GitHub链接`即可安装。
-
-部分插件：
-
-- `LLMS`: https://github.com/Soulter/llms | Claude, HuggingChat 大语言模型接入。
- 
-- `GoodPlugins`: https://github.com/Soulter/goodplugins | 随机动漫图片、搜番、喜报生成器等等
-
-- `sysstat`: https://github.com/Soulter/sysstatqcbot | 查看系统状态
-
-- `BiliMonitor`: https://github.com/Soulter/BiliMonitor | 订阅B站动态
-  
-- `liferestart`: https://github.com/Soulter/liferestart | 人生重开模拟器
-
-
-<img width="900" alt="image" src="https://github.com/Soulter/AstrBot/assets/37870767/824d1ff3-7b85-481c-b795-8e62dedb9fd7">
-
-
-<!-- 
-### 指令
-
-#### OpenAI官方API
-在频道内需要先`@`机器人之后再输入指令；在QQ中暂时需要在消息前加上`ai `，不需要@
-- `/reset`重置prompt
-- `/his`查看历史记录（每个用户都有独立的会话）
-- `/his [页码数]`查看不同页码的历史记录。例如`/his 2`查看第2页
-- `/token`查看当前缓存的总token数
-- `/count` 查看统计
-- `/status` 查看chatGPT的配置
-- `/help` 查看帮助
-- `/key` 动态添加key
-- `/set` 人格设置面板
-- `/keyword nihao 你好` 设置关键词回复。nihao->你好
-- `/画` 画画
-
-#### 逆向ChatGPT库语言模型
-- `/gpt` 切换为OpenAI官方API
-
-* 切换模型指令支持临时回复。如`/a 你好`将会临时使用一次bing模型 -->
-<!--
-## 🙇‍感谢
-
-本项目使用了一下项目:
-
-[ChatGPT by acheong08](https://github.com/acheong08/ChatGPT)
-
-[EdgeGPT by acheong08](https://github.com/acheong08/EdgeGPT)
-
-[go-cqhttp by Mrs4s](https://github.com/Mrs4s/go-cqhttp)
-
-[nakuru-project by Lxns-Network](https://github.com/Lxns-Network/nakuru-project) -->

README_en.md

@@ -0,0 +1,182 @@
+<p align="center">
+    
+![6e1279651f16d7fdf4727558b72bbaf1](https://github.com/user-attachments/assets/ead4c551-fc3c-48f7-a6f7-afbfdb820512)
+
+</p>
+
+<div align="center">
+
+_✨ Easy-to-use Multi-platform LLM Chatbot & Development Framework ✨_
+
+<a href="https://trendshift.io/repositories/12875" target="_blank"><img src="https://trendshift.io/api/badge/repositories/12875" alt="Soulter%2FAstrBot | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+
+[![GitHub release (latest by date)](https://img.shields.io/github/v/release/Soulter/AstrBot)](https://github.com/Soulter/AstrBot/releases/latest)
+<img src="https://img.shields.io/badge/python-3.10+-blue.svg" alt="python">
+<a href="https://hub.docker.com/r/soulter/astrbot"><img alt="Docker pull" src="https://img.shields.io/docker/pulls/soulter/astrbot.svg"/></a>
+<a  href="https://qm.qq.com/cgi-bin/qm/qr?k=wtbaNx7EioxeaqS9z7RQWVXPIxg2zYr7&jump_from=webapi&authKey=vlqnv/AV2DbJEvGIcxdlNSpfxVy+8vVqijgreRdnVKOaydpc+YSw4MctmEbr0k5"><img alt="Static Badge" src="https://img.shields.io/badge/QQ群-630166526-purple"></a>
+[![wakatime](https://wakatime.com/badge/user/915e5316-99c6-4563-a483-ef186cf000c9/project/018e705a-a1a7-409a-a849-3013485e6c8e.svg)](https://wakatime.com/badge/user/915e5316-99c6-4563-a483-ef186cf000c9/project/018e705a-a1a7-409a-a849-3013485e6c8e)
+![Dynamic JSON Badge](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.soulter.top%2Fastrbot%2Fstats&query=v&label=7%E6%97%A5%E6%B6%88%E6%81%AF%E4%B8%8A%E8%A1%8C%E9%87%8F&cacheSeconds=3600)
+[![codecov](https://codecov.io/gh/Soulter/AstrBot/graph/badge.svg?token=FF3P5967B8)](https://codecov.io/gh/Soulter/AstrBot)
+
+<a href="https://astrbot.app/">Documentation</a> ｜
+<a href="https://github.com/Soulter/AstrBot/issues">Issue Tracking</a>
+</div>
+
+AstrBot is a loosely coupled, asynchronous chatbot and development framework that supports multi-platform deployment, featuring an easy-to-use plugin system and comprehensive Large Language Model (LLM) integration capabilities.
+
+## ✨ Key Features
+
+1. **LLM Conversations** - Supports various LLMs including OpenAI API, Google Gemini, Llama, Deepseek, ChatGLM, etc. Enables local model deployment via Ollama/LLMTuner. Features multi-turn dialogues, personality contexts, multimodal capabilities (image understanding), and speech-to-text (Whisper).
+2. **Multi-platform Integration** - Supports QQ (OneBot), QQ Channels, WeChat (Gewechat), Feishu, and Telegram. Planned support for DingTalk, Discord, WhatsApp, and Xiaomi Smart Speakers. Includes rate limiting, whitelisting, keyword filtering, and Baidu content moderation.
+3. **Agent Capabilities** - Native support for code execution, natural language TODO lists, web search. Integrates with [Dify Platform](https://dify.ai/) for easy access to Dify assistants/knowledge bases/workflows.
+4. **Plugin System** - Optimized plugin mechanism with minimal development effort. Supports multiple installed plugins.
+5. **Web Dashboard** - Visual configuration management, plugin controls, logging, and WebChat interface for direct LLM interaction.
+6. **High Stability & Modularity** - Event bus and pipeline architecture ensures high modularization and loose coupling.
+
+> [!TIP]
+> Dashboard Demo: [https://demo.astrbot.app/](https://demo.astrbot.app/)  
+> Username: `astrbot`, Password: `astrbot` (LLM not configured for chat page)
+
+## ✨ Deployment
+
+#### Docker Deployment
+
+See docs: [Deploy with Docker](https://astrbot.app/deploy/astrbot/docker.html#docker-deployment)
+
+#### Windows Installer
+
+Requires Python (>3.10). See docs: [Windows Installer Guide](https://astrbot.app/deploy/astrbot/windows.html)
+
+#### Replit Deployment
+
+[![Run on Repl.it](https://repl.it/badge/github/Soulter/AstrBot)](https://repl.it/github/Soulter/AstrBot)
+
+#### CasaOS Deployment
+
+Community-contributed method.  
+See docs: [CasaOS Deployment](https://astrbot.app/deploy/astrbot/casaos.html)
+
+#### Manual Deployment
+
+See docs: [Source Code Deployment](https://astrbot.app/deploy/astrbot/cli.html)
+
+## ⚡ Platform Support
+
+| Platform                                                       | Status | Details             | Message Types       |
+| -------------------------------------------------------------- | ------ | ------------------- | ------------------- |
+| QQ (Official Bot)                                              | ✔      | Private/Group chats | Text, Images        |
+| QQ (OneBot)                                                    | ✔      | Private/Group chats | Text, Images, Voice |
+| WeChat (Personal)                                              | ✔      | Private/Group chats | Text, Images, Voice |
+| [Telegram](https://github.com/Soulter/astrbot_plugin_telegram) | ✔      | Private/Group chats | Text, Images        |
+| [WeChat Work](https://github.com/Soulter/astrbot_plugin_wecom) | ✔      | Private chats       | Text, Images, Voice |
+| Feishu                                                         | ✔      | Group chats         | Text, Images        |
+| WeChat Open Platform                                           | 🚧      | Planned             | -                   |
+| Discord                                                        | 🚧      | Planned             | -                   |
+| WhatsApp                                                       | 🚧      | Planned             | -                   |
+| Xiaomi Speakers                                                | 🚧      | Planned             | -                   |
+
+## Provider Support Status
+
+| Name                      | Support | Type                   | Notes                                                                 |
+|---------------------------|---------|------------------------|-----------------------------------------------------------------------|
+| OpenAI API                | ✔       | Text Generation        | Supports all OpenAI API-compatible services including DeepSeek, Google Gemini, GLM, Moonshot, Alibaba Cloud Bailian, Silicon Flow, xAI, etc. |
+| Claude API                | ✔       | Text Generation        |                                                                       |
+| Google Gemini API         | ✔       | Text Generation        |                                                                       |
+| Dify                      | ✔       | LLMOps                 |                                                                       |
+| DashScope (Alibaba Cloud) | ✔       | LLMOps                 |                                                                       |
+| Ollama                    | ✔       | Model Loader           | Local deployment for open-source LLMs (DeepSeek, Llama, etc.)         |
+| LM Studio                 | ✔       | Model Loader           | Local deployment for open-source LLMs (DeepSeek, Llama, etc.)         |
+| LLMTuner                  | ✔       | Model Loader           | Local loading of fine-tuned models (e.g. LoRA)                        |
+| OneAPI                    | ✔       | LLM Distribution       |                                                                       |
+| Whisper                   | ✔       | Speech-to-Text         | Supports API and local deployment                                    |
+| SenseVoice                | ✔       | Speech-to-Text         | Local deployment                                                     |
+| OpenAI TTS API            | ✔       | Text-to-Speech         |                                                                       |
+| Fishaudio                 | ✔       | Text-to-Speech         | Project involving GPT-Sovits author                                  |
+
+# 🦌 Roadmap
+
+> [!TIP]
+> Suggestions welcome via Issues <3
+
+- [ ] Ensure feature parity across all platform adapters
+- [ ] Optimize plugin APIs
+- [ ] Add default TTS services (e.g., GPT-Sovits)
+- [ ] Enhance chat features with persistent memory
+- [ ] i18n Planning
+
+## ❤️ Contributions
+
+All Issues/PRs welcome! Simply submit your changes to this project :)
+
+For major features, please discuss via Issues first.
+
+## 🌟 Support
+
+- Star this project!
+- Support via [Afdian](https://afdian.com/a/soulter)
+- WeChat support: [QR Code](https://drive.soulter.top/f/pYfA/d903f4fa49a496fda3f16d2be9e023b5.png)
+
+## ✨ Demos
+
+> [!NOTE]
+> Code executor file I/O currently tested with Napcat(QQ)/Lagrange(QQ)
+
+<div align='center'>
+
+<img src="https://github.com/user-attachments/assets/4ee688d9-467d-45c8-99d6-368f9a8a92d8" width="600">
+
+_✨ Docker-based Sandboxed Code Executor (Beta) ✨_
+
+<img src="https://github.com/user-attachments/assets/0378f407-6079-4f64-ae4c-e97ab20611d2" height=500>
+
+_✨ Multimodal Input, Web Search, Text-to-Image ✨_
+
+<img src="https://github.com/user-attachments/assets/8ec12797-e70f-460a-959e-48eca39ca2bb" height=100>
+
+_✨ Natural Language TODO Lists ✨_
+
+<img src="https://github.com/user-attachments/assets/e137a9e1-340a-4bf2-bb2b-771132780735" height=150>
+<img src="https://github.com/user-attachments/assets/480f5e82-cf6a-4955-a869-0d73137aa6e1" height=150>
+
+_✨ Plugin System Showcase ✨_
+
+<img src="https://github.com/user-attachments/assets/592a8630-14c7-4e06-b496-9c0386e4f36c" width=600>
+
+_✨ Web Dashboard ✨_
+
+![webchat](https://drive.soulter.top/f/vlsA/ezgif-5-fb044b2542.gif)
+
+_✨ Built-in Web Chat Interface ✨_
+
+</div>
+
+## ⭐ Star History
+
+> [!TIP] 
+> If this project helps you, please give it a star <3
+
+<div align="center">
+    
+[![Star History Chart](https://api.star-history.com/svg?repos=soulter/astrbot&type=Date)](https://star-history.com/#soulter/astrbot&Date)
+
+</div>
+
+## Disclaimer
+
+1. Licensed under `AGPL-v3`.
+2. WeChat integration uses [Gewechat](https://github.com/Devo919/Gewechat). Use at your own risk with non-critical accounts.
+3. Users must comply with local laws and regulations.
+
+<!-- ## ✨ ATRI [Beta]
+
+Available as plugin: [astrbot_plugin_atri](https://github.com/Soulter/astrbot_plugin_atri)
+
+1. Qwen1.5-7B-Chat Lora model fine-tuned with ATRI character data
+2. Long-term memory
+3. Meme understanding & responses
+4. TTS integration
+    -->
+
+
+_私は、高性能ですから!_
+

README_ja.md

@@ -0,0 +1,170 @@
+<p align="center">
+    
+![6e1279651f16d7fdf4727558b72bbaf1](https://github.com/user-attachments/assets/ead4c551-fc3c-48f7-a6f7-afbfdb820512)
+
+</p>
+
+<div align="center">
+
+_✨ 簡単に使えるマルチプラットフォーム LLM チャットボットおよび開発フレームワーク ✨_
+
+<a href="https://trendshift.io/repositories/12875" target="_blank"><img src="https://trendshift.io/api/badge/repositories/12875" alt="Soulter%2FAstrBot | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+
+[![GitHub release (latest by date)](https://img.shields.io/github/v/release/Soulter/AstrBot)](https://github.com/Soulter/AstrBot/releases/latest)
+<img src="https://img.shields.io/badge/python-3.10+-blue.svg" alt="python">
+<a href="https://hub.docker.com/r/soulter/astrbot"><img alt="Docker pull" src="https://img.shields.io/docker/pulls/soulter/astrbot.svg"/></a>
+<img alt="Static Badge" src="https://img.shields.io/badge/QQ群-630166526-purple">
+[![wakatime](https://wakatime.com/badge/user/915e5316-99c6-4563-a483-ef186cf000c9/project/018e705a-a1a7-409a-a849-3013485e6c8e.svg)](https://wakatime.com/badge/user/915e5316-99c6-4563-a483-ef186cf000c9/project/018e705a-a1a7-409a-a849-3013485e6c8e)
+![Dynamic JSON Badge](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.soulter.top%2Fastrbot%2Fstats&query=v&label=7%E6%97%A5%E6%B6%88%E6%81%AF%E4%B8%8A%E8%A1%8C%E9%87%8F&cacheSeconds=3600)
+[![codecov](https://codecov.io/gh/Soulter/AstrBot/graph/badge.svg?token=FF3P5967B8)](https://codecov.io/gh/Soulter/AstrBot)
+
+<a href="https://astrbot.app/">ドキュメントを見る</a> ｜
+<a href="https://github.com/Soulter/AstrBot/issues">問題を報告する</a>
+</div>
+
+AstrBot は、疎結合、非同期、複数のメッセージプラットフォームに対応したデプロイ、使いやすいプラグインシステム、および包括的な大規模言語モデル（LLM）接続機能を備えたチャットボットおよび開発フレームワークです。
+
+## ✨ 主な機能
+
+1. **大規模言語モデルの対話**。OpenAI API、Google Gemini、Llama、Deepseek、ChatGLM など、さまざまな大規模言語モデルをサポートし、Ollama、LLMTuner を介してローカルにデプロイされた大規模モデルをサポートします。多輪対話、人格シナリオ、多モーダル機能を備え、画像理解、音声からテキストへの変換（Whisper）をサポートします。
+2. **複数のメッセージプラットフォームの接続**。QQ（OneBot）、QQ チャンネル、WeChat（Gewechat）、Feishu、Telegram への接続をサポートします。今後、DingTalk、Discord、WhatsApp、Xiaoai 音響をサポートする予定です。レート制限、ホワイトリスト、キーワードフィルタリング、Baidu コンテンツ監査をサポートします。
+3. **エージェント**。一部のエージェント機能をネイティブにサポートし、コードエグゼキューター、自然言語タスク、ウェブ検索などを提供します。[Dify プラットフォーム](https://dify.ai/)と連携し、Dify スマートアシスタント、ナレッジベース、Dify ワークフローを簡単に接続できます。
+4. **プラグインの拡張**。深く最適化されたプラグインメカニズムを備え、[プラグインの開発](https://astrbot.app/dev/plugin.html)をサポートし、機能を拡張できます。複数のプラグインのインストールをサポートします。
+5. **ビジュアル管理パネル**。設定の視覚的な変更、プラグイン管理、ログの表示などをサポートし、設定の難易度を低減します。WebChat を統合し、パネル上で大規模モデルと対話できます。
+6. **高い安定性と高いモジュール性**。イベントバスとパイプラインに基づくアーキテクチャ設計により、高度にモジュール化され、低結合です。
+
+> [!TIP]
+> 管理パネルのオンラインデモを体験する: [https://demo.astrbot.app/](https://demo.astrbot.app/)
+> 
+> ユーザー名: `astrbot`, パスワード: `astrbot`。LLM が設定されていないため、チャットページで大規模モデルを使用することはできません。（デモのログインパスワードを変更しないでください 😭）
+
+## ✨ 使用方法
+
+#### Docker デプロイ
+
+公式ドキュメント [Docker を使用して AstrBot をデプロイする](https://astrbot.app/deploy/astrbot/docker.html#%E4%BD%BF%E7%94%A8-docker-%E9%83%A8%E7%BD%B2-astrbot) を参照してください。
+
+#### Windows ワンクリックインストーラーのデプロイ
+
+コンピュータに Python（>3.10）がインストールされている必要があります。公式ドキュメント [Windows ワンクリックインストーラーを使用して AstrBot をデプロイする](https://astrbot.app/deploy/astrbot/windows.html) を参照してください。
+
+#### Replit デプロイ
+
+[![Run on Repl.it](https://repl.it/badge/github/Soulter/AstrBot)](https://repl.it/github/Soulter/AstrBot)
+
+#### CasaOS デプロイ
+
+コミュニティが提供するデプロイ方法です。
+
+公式ドキュメント [ソースコードを使用して AstrBot をデプロイする](https://astrbot.app/deploy/astrbot/casaos.html) を参照してください。
+
+#### 手動デプロイ
+
+公式ドキュメント [ソースコードを使用して AstrBot をデプロイする](https://astrbot.app/deploy/astrbot/cli.html) を参照してください。
+
+## ⚡ メッセージプラットフォームのサポート状況
+
+| プラットフォーム    | サポート状況 | 詳細 | メッセージタイプ |
+| -------- | ------- | ------- | ------ |
+| QQ(公式ロボットインターフェース) | ✔    | プライベートチャット、グループチャット、QQ チャンネルプライベートチャット、グループチャット | テキスト、画像 |
+| QQ(OneBot)      | ✔    | プライベートチャット、グループチャット | テキスト、画像、音声 |
+| WeChat(個人アカウント)    | ✔    | WeChat 個人アカウントのプライベートチャット、グループチャット | テキスト、画像、音声 |
+| [Telegram](https://github.com/Soulter/astrbot_plugin_telegram)   | ✔    | プライベートチャット、グループチャット | テキスト、画像 |
+| [WeChat(企業 WeChat)](https://github.com/Soulter/astrbot_plugin_wecom)    | ✔    | プライベートチャット | テキスト、画像、音声 |
+| Feishu   | ✔    | グループチャット | テキスト、画像 |
+| WeChat 対話オープンプラットフォーム | 🚧    | 計画中 | - |
+| Discord   | 🚧    | 計画中 | - |
+| WhatsApp   | 🚧    | 計画中 | - |
+| Xiaoai 音響   | 🚧    | 計画中 | - |
+
+# 🦌 今後のロードマップ
+
+> [!TIP]
+> Issue でさらに多くの提案を歓迎します <3
+
+- [ ] 現在のすべてのプラットフォームアダプターの機能の一貫性を確保し、改善する
+- [ ] プラグインインターフェースの最適化
+- [ ] GPT-Sovits などの TTS サービスをデフォルトでサポート
+- [ ] "チャット強化" 部分を完成させ、永続的な記憶をサポート
+- [ ] i18n の計画
+
+## ❤️ 貢献
+
+Issue や Pull Request を歓迎します！このプロジェクトに変更を加えるだけです :)
+
+新機能の追加については、まず Issue で議論してください。
+
+## 🌟 サポート
+
+- このプロジェクトに Star を付けてください！
+- [愛発電](https://afdian.com/a/soulter)で私をサポートしてください！
+- [WeChat](https://drive.soulter.top/f/pYfA/d903f4fa49a496fda3f16d2be9e023b5.png)で私をサポートしてください~
+
+## ✨ デモ
+
+> [!NOTE]
+> コードエグゼキューターのファイル入力/出力は現在 Napcat(QQ)、Lagrange(QQ) でのみテストされています
+
+<div align='center'>
+
+<img src="https://github.com/user-attachments/assets/4ee688d9-467d-45c8-99d6-368f9a8a92d8" width="600">
+
+_✨ Docker ベースのサンドボックス化されたコードエグゼキューター（ベータテスト中）✨_
+
+<img src="https://github.com/user-attachments/assets/0378f407-6079-4f64-ae4c-e97ab20611d2" height=500>
+
+_✨ 多モーダル、ウェブ検索、長文の画像変換（設定可能）✨_
+
+<img src="https://github.com/user-attachments/assets/8ec12797-e70f-460a-959e-48eca39ca2bb" height=100>
+
+_✨ 自然言語タスク ✨_
+
+<img src="https://github.com/user-attachments/assets/e137a9e1-340a-4bf2-bb2b-771132780735" height=150>
+<img src="https://github.com/user-attachments/assets/480f5e82-cf6a-4955-a869-0d73137aa6e1" height=150>
+
+_✨ プラグインシステム - 一部のプラグインの展示 ✨_
+
+<img src="https://github.com/user-attachments/assets/592a8630-14c7-4e06-b496-9c0386e4f36c" width="600">
+
+_✨ 管理パネル ✨_
+
+![webchat](https://drive.soulter.top/f/vlsA/ezgif-5-fb044b2542.gif)
+
+_✨ 内蔵 Web Chat、オンラインでボットと対話 ✨_
+
+</div>
+
+## ⭐ Star History
+
+> [!TIP] 
+> このプロジェクトがあなたの生活や仕事に役立った場合、またはこのプロジェクトの将来の発展に関心がある場合は、プロジェクトに Star を付けてください。これはこのオープンソースプロジェクトを維持するためのモチベーションです <3
+
+<div align="center">
+    
+[![Star History Chart](https://api.star-history.com/svg?repos=soulter/astrbot&type=Date)](https://star-history.com/#soulter/astrbot&Date)
+
+</div>
+
+## スポンサー
+
+[<img src="https://api.gitsponsors.com/api/badge/img?id=575865240" height="20">](https://api.gitsponsors.com/api/badge/link?p=XEpbdGxlitw/RbcwiTX93UMzNK/jgDYC8NiSzamIPMoKvG2lBFmyXhSS/b0hFoWlBBMX2L5X5CxTDsUdyvcIEHTOfnkXz47UNOZvMwyt5CzbYpq0SEzsSV1OJF1cCo90qC/ZyYKYOWedal3MhZ3ikw==)
+
+## 免責事項
+
+1. このプロジェクトは `AGPL-v3` オープンソースライセンスの下で保護されています。
+2. WeChat（個人アカウント）のデプロイメントには [Gewechat](https://github.com/Devo919/Gewechat) サービスを利用しています。AstrBot は Gewechat との接続を保証するだけであり、アカウントのリスク管理に関しては、このプロジェクトの著者は一切の責任を負いません。
+3. このプロジェクトを使用する際は、現地の法律および規制を遵守してください。
+
+<!-- ## ✨ ATRI [ベータテスト]
+
+この機能はプラグインとしてロードされます。プラグインリポジトリのアドレス：[astrbot_plugin_atri](https://github.com/Soulter/astrbot_plugin_atri)
+
+1. 《ATRI ~ My Dear Moments》の主人公 ATRI のキャラクターセリフを微調整データセットとして使用した `Qwen1.5-7B-Chat Lora` 微調整モデル。
+2. 長期記憶
+3. ミームの理解と返信
+4. TTS
+    -->
+
+
+_私は、高性能ですから!_
+

addons/baidu_aip_judge.py

@@ -1,29 +0,0 @@
-from aip import AipContentCensor
-
-
-class BaiduJudge:
-    def __init__(self, baidu_configs) -> None:
-        if 'app_id' in baidu_configs and 'api_key' in baidu_configs and 'secret_key' in baidu_configs:
-            self.app_id = str(baidu_configs['app_id'])
-            self.api_key = baidu_configs['api_key']
-            self.secret_key = baidu_configs['secret_key']
-            self.client = AipContentCensor(
-                self.app_id, self.api_key, self.secret_key)
-        else:
-            raise ValueError("Baidu configs error! 请填写百度内容审核服务相关配置！")
-
-    def judge(self, text):
-        res = self.client.textCensorUserDefined(text)
-        if 'conclusionType' not in res:
-            return False, "百度审核服务未知错误"
-        if res['conclusionType'] == 1:
-            return True, "合规"
-        else:
-            if 'data' not in res:
-                return False, "百度审核服务未知错误"
-            count = len(res['data'])
-            info = f"百度审核服务发现 {count} 处违规：\n"
-            for i in res['data']:
-                info += f"{i['msg']}；\n"
-            info += "\n判断结果："+res['conclusion']
-            return False, info

addons/dashboard/dist/assets/BaseBreadcrumb-4d676ba5.css

@@ -1 +0,0 @@
-.page-breadcrumb .v-toolbar{background:transparent}

addons/dashboard/dist/assets/BaseBreadcrumb.vue_vue_type_style_index_0_lang-e31f96f8.js

@@ -1 +0,0 @@
-import{x as i,o as l,c as _,w as s,a as e,f as a,J as m,V as c,b as t,t as u,ad as p,B as n,ae as o,j as f}from"./index-dc96e1be.js";const b={class:"text-h3"},h={class:"d-flex align-center"},g={class:"d-flex align-center"},V=i({__name:"BaseBreadcrumb",props:{title:String,breadcrumbs:Array,icon:String},setup(d){const r=d;return(x,B)=>(l(),_(c,{class:"page-breadcrumb mb-1 mt-1"},{default:s(()=>[e(a,{cols:"12",md:"12"},{default:s(()=>[e(m,{variant:"outlined",elevation:"0",class:"px-4 py-3 withbg"},{default:s(()=>[e(c,{"no-gutters":"",class:"align-center"},{default:s(()=>[e(a,{md:"5"},{default:s(()=>[t("h3",b,u(r.title),1)]),_:1}),e(a,{md:"7",sm:"12",cols:"12"},{default:s(()=>[e(p,{items:r.breadcrumbs,class:"text-h5 justify-md-end pa-1"},{divider:s(()=>[t("div",h,[e(n(o),{size:"17"})])]),prepend:s(()=>[e(f,{size:"small",icon:"mdi-home",class:"text-secondary mr-2"}),t("div",g,[e(n(o),{size:"17"})])]),_:1},8,["items"])]),_:1})]),_:1})]),_:1})]),_:1})]),_:1}))}});export{V as _};

addons/dashboard/dist/assets/BlankLayout-1694b31c.js

@@ -1 +0,0 @@
-import{x as e,o as a,c as t,w as o,a as s,B as n,Z as r,W as c}from"./index-dc96e1be.js";const f=e({__name:"BlankLayout",setup(p){return(u,_)=>(a(),t(c,null,{default:o(()=>[s(n(r))]),_:1}))}});export{f as default};

addons/dashboard/dist/assets/ColorPage-757221a5.js

@@ -1 +0,0 @@
-import{_ as m}from"./BaseBreadcrumb.vue_vue_type_style_index_0_lang-e31f96f8.js";import{_}from"./UiParentCard.vue_vue_type_script_setup_true_lang-f2b2db58.js";import{x as p,D as a,o as r,s,a as e,w as t,f as o,V as i,F as n,u as g,c as h,a0 as b,e as x,t as y}from"./index-dc96e1be.js";const P=p({__name:"ColorPage",setup(C){const c=a({title:"Colors Page"}),d=a([{title:"Utilities",disabled:!1,href:"#"},{title:"Colors",disabled:!0,href:"#"}]),u=a(["primary","lightprimary","secondary","lightsecondary","info","success","accent","warning","error","darkText","lightText","borderLight","inputBorder","containerBg"]);return(V,k)=>(r(),s(n,null,[e(m,{title:c.value.title,breadcrumbs:d.value},null,8,["title","breadcrumbs"]),e(i,null,{default:t(()=>[e(o,{cols:"12",md:"12"},{default:t(()=>[e(_,{title:"Color Palette"},{default:t(()=>[e(i,null,{default:t(()=>[(r(!0),s(n,null,g(u.value,(l,f)=>(r(),h(o,{md:"3",cols:"12",key:f},{default:t(()=>[e(b,{rounded:"md",class:"align-center justify-center d-flex",height:"100",width:"100%",color:l},{default:t(()=>[x("class: "+y(l),1)]),_:2},1032,["color"])]),_:2},1024))),128))]),_:1})]),_:1})]),_:1})]),_:1})],64))}});export{P as default};

addons/dashboard/dist/assets/ConfigDetailCard-8467c848.js

@@ -1 +0,0 @@
-import{o as l,s as o,u as c,c as n,w as u,Q as g,b as s,R as k,F as t,ab as h,O as p,t as m,a as V,ac as f,i as C,q as x,k as v,A as U}from"./index-dc96e1be.js";import{_ as w}from"./UiParentCard.vue_vue_type_script_setup_true_lang-f2b2db58.js";const S={__name:"ConfigDetailCard",props:{config:Array},setup(d){return(y,B)=>(l(!0),o(t,null,c(d.config,r=>(l(),n(w,{key:r.name,title:r.name,style:{"margin-bottom":"16px"}},{default:u(()=>[g(s("a",null,"No data",512),[[k,d.config.length===0]]),(l(!0),o(t,null,c(r.body,e=>(l(),o(t,null,[e.config_type==="item"?(l(),o(t,{key:0},[e.val_type==="bool"?(l(),n(h,{key:0,modelValue:e.value,"onUpdate:modelValue":a=>e.value=a,label:e.name,hint:e.description,color:"primary",inset:""},null,8,["modelValue","onUpdate:modelValue","label","hint"])):e.val_type==="str"?(l(),n(p,{key:1,modelValue:e.value,"onUpdate:modelValue":a=>e.value=a,label:e.name,hint:e.description,style:{"margin-bottom":"8px"},variant:"outlined"},null,8,["modelValue","onUpdate:modelValue","label","hint"])):e.val_type==="int"?(l(),n(p,{key:2,modelValue:e.value,"onUpdate:modelValue":a=>e.value=a,label:e.name,hint:e.description,style:{"margin-bottom":"8px"},variant:"outlined"},null,8,["modelValue","onUpdate:modelValue","label","hint"])):e.val_type==="list"?(l(),o(t,{key:3},[s("span",null,m(e.name),1),V(f,{modelValue:e.value,"onUpdate:modelValue":a=>e.value=a,chips:"",clearable:"",label:"请添加",multiple:"","prepend-icon":"mdi-tag-multiple-outline"},{selection:u(({attrs:a,item:i,select:b,selected:_})=>[V(C,x(a,{"model-value":_,closable:"",onClick:b,"onClick:close":D=>y.remove(i)}),{default:u(()=>[s("strong",null,m(i),1)]),_:2},1040,["model-value","onClick","onClick:close"])]),_:2},1032,["modelValue","onUpdate:modelValue"])],64)):v("",!0)],64)):e.config_type==="divider"?(l(),n(U,{key:1,style:{"margin-top":"8px","margin-bottom":"8px"}})):v("",!0)],64))),256))]),_:2},1032,["title"]))),128))}};export{S as _};

addons/dashboard/dist/assets/ConfigPage-164b73e7.js

@@ -1 +0,0 @@
-import{_ as y}from"./UiParentCard.vue_vue_type_script_setup_true_lang-f2b2db58.js";import{x as h,o,c as u,w as t,a,a8 as b,b as c,K as x,e as f,t as g,G as V,A as w,L as S,a9 as $,J as B,s as _,d as v,F as d,u as p,f as G,V as T,aa as j,T as l}from"./index-dc96e1be.js";import{_ as m}from"./ConfigDetailCard-8467c848.js";const D={class:"d-sm-flex align-center justify-space-between"},C=h({__name:"ConfigGroupCard",props:{title:String},setup(e){const s=e;return(i,n)=>(o(),u(B,{variant:"outlined",elevation:"0",class:"withbg",style:{width:"50%"}},{default:t(()=>[a(b,{style:{padding:"10px 20px"}},{default:t(()=>[c("div",D,[a(x,null,{default:t(()=>[f(g(s.title),1)]),_:1}),a(V)])]),_:1}),a(w),a(S,null,{default:t(()=>[$(i.$slots,"default")]),_:3})]),_:3}))}}),I={style:{display:"flex","flex-direction":"row","justify-content":"space-between","align-items":"center","margin-bottom":"12px"}},N={style:{display:"flex","flex-direction":"row"}},R={style:{"margin-right":"10px",color:"black"}},F={style:{color:"#222"}},k=h({__name:"ConfigGroupItem",props:{title:String,desc:String,btnRoute:String,namespace:String},setup(e){const s=e;return(i,n)=>(o(),_("div",I,[c("div",N,[c("h3",R,g(s.title),1),c("p",F,g(s.desc),1)]),a(v,{to:s.btnRoute,color:"primary",class:"ml-2",style:{"border-radius":"10px"}},{default:t(()=>[f("配置")]),_:1},8,["to"])]))}}),L={style:{display:"flex","flex-direction":"row",padding:"16px",gap:"16px",width:"100%"}},P={name:"ConfigPage",components:{UiParentCard:y,ConfigGroupCard:C,ConfigGroupItem:k,ConfigDetailCard:m},data(){return{config_data:[],config_base:[],save_message_snack:!1,save_message:"",save_message_success:"",config_outline:[],namespace:""}},mounted(){this.getConfig()},methods:{switchConfig(e){l.get("/api/configs?namespace="+e).then(s=>{this.namespace=e,this.config_data=s.data.data,console.log(this.config_data)}).catch(s=>{save_message=s,save_message_snack=!0,save_message_success="error"})},getConfig(){l.get("/api/config_outline").then(e=>{this.config_outline=e.data.data,console.log(this.config_outline)}).catch(e=>{save_message=e,save_message_snack=!0,save_message_success="error"}),l.get("/api/configs").then(e=>{this.config_base=e.data.data,console.log(this.config_data)}).catch(e=>{save_message=e,save_message_snack=!0,save_message_success="error"})},updateConfig(){l.post("/api/configs",{base_config:this.config_base,config:this.config_data,namespace:this.namespace}).then(e=>{e.data.status==="success"?(this.save_message=e.data.message,this.save_message_snack=!0,this.save_message_success="success"):(this.save_message=e.data.message,this.save_message_snack=!0,this.save_message_success="error")}).catch(e=>{this.save_message=e,this.save_message_snack=!0,this.save_message_success="error"})}}},J=Object.assign(P,{setup(e){return(s,i)=>(o(),_(d,null,[a(T,null,{default:t(()=>[c("div",L,[(o(!0),_(d,null,p(s.config_outline,n=>(o(),u(C,{key:n.name,title:n.name},{default:t(()=>[(o(!0),_(d,null,p(n.body,r=>(o(),u(k,{title:r.title,desc:r.desc,namespace:r.namespace,onClick:U=>s.switchConfig(r.namespace)},null,8,["title","desc","namespace","onClick"]))),256))]),_:2},1032,["title"]))),128))]),a(G,{cols:"12",md:"12"},{default:t(()=>[a(m,{config:s.config_data},null,8,["config"]),a(m,{config:s.config_base},null,8,["config"])]),_:1})]),_:1}),a(v,{icon:"mdi-content-save",size:"x-large",style:{position:"fixed",right:"52px",bottom:"52px"},color:"darkprimary",onClick:s.updateConfig},null,8,["onClick"]),a(j,{timeout:2e3,elevation:"24",color:s.save_message_success,modelValue:s.save_message_snack,"onUpdate:modelValue":i[0]||(i[0]=n=>s.save_message_snack=n)},{default:t(()=>[f(g(s.save_message),1)]),_:1},8,["color","modelValue"])],64))}});export{J as default};

addons/dashboard/dist/assets/ConsolePage-ff373be6.css

@@ -1,32 +0,0 @@
-/**
- * Copyright (c) 2014 The xterm.js authors. All rights reserved.
- * Copyright (c) 2012-2013, Christopher Jeffrey (MIT License)
- * https://github.com/chjj/term.js
- * @license MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- *
- * Originally forked from (with the author's permission):
- *   Fabrice Bellard's javascript vt100 for jslinux:
- *   http://bellard.org/jslinux/
- *   Copyright (c) 2011 Fabrice Bellard
- *   The original design remains. The terminal itself
- *   has been extended to include xterm CSI codes, among
- *   other features.
- */.xterm{cursor:text;position:relative;user-select:none;-ms-user-select:none;-webkit-user-select:none}.xterm.focus,.xterm:focus{outline:none}.xterm .xterm-helpers{position:absolute;top:0;z-index:5}.xterm .xterm-helper-textarea{padding:0;border:0;margin:0;position:absolute;opacity:0;left:-9999em;top:0;width:0;height:0;z-index:-5;white-space:nowrap;overflow:hidden;resize:none}.xterm .composition-view{background:#000;color:#fff;display:none;position:absolute;white-space:nowrap;z-index:1}.xterm .composition-view.active{display:block}.xterm .xterm-viewport{background-color:#000;overflow-y:scroll;cursor:default;position:absolute;right:0;left:0;top:0;bottom:0}.xterm .xterm-screen{position:relative}.xterm .xterm-screen canvas{position:absolute;left:0;top:0}.xterm .xterm-scroll-area{visibility:hidden}.xterm-char-measure-element{display:inline-block;visibility:hidden;position:absolute;top:0;left:-9999em;line-height:normal}.xterm.enable-mouse-events{cursor:default}.xterm.xterm-cursor-pointer,.xterm .xterm-cursor-pointer{cursor:pointer}.xterm.column-select.focus{cursor:crosshair}.xterm .xterm-accessibility,.xterm .xterm-message{position:absolute;left:0;top:0;bottom:0;right:0;z-index:10;color:transparent;pointer-events:none}.xterm .live-region{position:absolute;left:-9999px;width:1px;height:1px;overflow:hidden}.xterm-dim{opacity:1!important}.xterm-underline-1{text-decoration:underline}.xterm-underline-2{text-decoration:double underline}.xterm-underline-3{text-decoration:wavy underline}.xterm-underline-4{text-decoration:dotted underline}.xterm-underline-5{text-decoration:dashed underline}.xterm-overline{text-decoration:overline}.xterm-overline.xterm-underline-1{text-decoration:overline underline}.xterm-overline.xterm-underline-2{text-decoration:overline double underline}.xterm-overline.xterm-underline-3{text-decoration:overline wavy underline}.xterm-overline.xterm-underline-4{text-decoration:overline dotted underline}.xterm-overline.xterm-underline-5{text-decoration:overline dashed underline}.xterm-strikethrough{text-decoration:line-through}.xterm-screen .xterm-decoration-container .xterm-decoration{z-index:6;position:absolute}.xterm-screen .xterm-decoration-container .xterm-decoration.xterm-decoration-top-layer{z-index:7}.xterm-decoration-overview-ruler{z-index:8;position:absolute;top:0;right:0;pointer-events:none}.xterm-decoration-top{z-index:2;position:relative}

addons/dashboard/dist/assets/Error404Page-06f6396d.js

@@ -1 +0,0 @@
-import{_ as t}from"./_plugin-vue_export-helper-c27b6911.js";import{o,c,w as s,V as i,a as r,b as e,d as l,e as a,f as d}from"./index-dc96e1be.js";const n="/assets/img-error-bg-ab6474a0.svg",_="/assets/img-error-blue-2675a7a9.svg",m="/assets/img-error-text-a6aebfa0.svg",g="/assets/img-error-purple-edee3fbc.svg";const p={},u={class:"text-center"},f=e("div",{class:"CardMediaWrapper"},[e("img",{src:n,alt:"grid",class:"w-100"}),e("img",{src:_,alt:"grid",class:"CardMediaParts"}),e("img",{src:m,alt:"build",class:"CardMediaBuild"}),e("img",{src:g,alt:"build",class:"CardMediaBuild"})],-1),h=e("h1",{class:"text-h1"},"Something is wrong",-1),v=e("p",null,[e("small",null,[a("The page you are looking was moved, removed, "),e("br"),a("renamed, or might never exist! ")])],-1);function x(b,V){return o(),c(i,{"no-gutters":"",class:"h-100vh"},{default:s(()=>[r(d,{class:"d-flex align-center justify-center"},{default:s(()=>[e("div",u,[f,h,v,r(l,{variant:"flat",color:"primary",class:"mt-4",to:"/","prepend-icon":"mdi-home"},{default:s(()=>[a(" Home")]),_:1})])]),_:1})]),_:1})}const C=t(p,[["render",x]]);export{C as default};

addons/dashboard/dist/assets/Error404Page-11cf087a.css

@@ -1 +0,0 @@
-.CardMediaWrapper{max-width:720px;margin:0 auto;position:relative}.CardMediaBuild{position:absolute;top:0;left:0;width:100%;animation:5s bounce ease-in-out infinite}.CardMediaParts{position:absolute;top:0;left:0;width:100%;animation:10s blink ease-in-out infinite}

addons/dashboard/dist/assets/LoginPage-74e85ca7.css

@@ -1 +0,0 @@
-.custom-devider{border-color:#00000014!important}.googleBtn{border-color:#00000014;margin:30px 0 20px}.outlinedInput .v-field{border:1px solid rgba(0,0,0,.08);box-shadow:none}.orbtn{padding:2px 40px;border-color:#00000014;margin:20px 15px}.pwdInput{position:relative}.pwdInput .v-input__append{position:absolute;right:10px;top:50%;transform:translateY(-50%)}.loginForm .v-text-field .v-field--active input{font-weight:500}.loginBox{max-width:475px;margin:0 auto}

addons/dashboard/dist/assets/LogoDark.vue_vue_type_script_setup_true_lang-7df35c25.js

@@ -1 +0,0 @@
-import{av as _,x as d,D as n,o as c,s as m,a as f,w as p,Q as r,b as a,R as o,B as t,aw as h}from"./index-dc96e1be.js";const s={Sidebar_drawer:!0,Customizer_drawer:!1,mini_sidebar:!1,fontTheme:"Roboto",inputBg:!1},l=_({id:"customizer",state:()=>({Sidebar_drawer:s.Sidebar_drawer,Customizer_drawer:s.Customizer_drawer,mini_sidebar:s.mini_sidebar,fontTheme:"Poppins",inputBg:s.inputBg}),getters:{},actions:{SET_SIDEBAR_DRAWER(){this.Sidebar_drawer=!this.Sidebar_drawer},SET_MINI_SIDEBAR(e){this.mini_sidebar=e},SET_FONT(e){this.fontTheme=e}}}),u={class:"logo",style:{display:"flex","align-items":"center"}},b={style:{"font-size":"24px","font-weight":"1000"}},w={style:{"font-size":"20px","font-weight":"1000"}},S={style:{"font-size":"20px"}},z=d({__name:"LogoDark",setup(e){n("rgb(var(--v-theme-primary))"),n("rgb(var(--v-theme-secondary))");const i=l();return(g,B)=>(c(),m("div",u,[f(t(h),{to:"/",style:{"text-decoration":"none",color:"black"}},{default:p(()=>[r(a("span",b,"AstrBot 仪表盘",512),[[o,!t(i).mini_sidebar]]),r(a("span",w,"Astr",512),[[o,t(i).mini_sidebar]]),r(a("span",S,"Bot",512),[[o,t(i).mini_sidebar]])]),_:1})]))}});export{z as _,l as u};

addons/dashboard/dist/assets/MaterialIcons-fc2671ff.js

@@ -1 +0,0 @@
-import{_ as o}from"./BaseBreadcrumb.vue_vue_type_style_index_0_lang-e31f96f8.js";import{_ as i}from"./UiParentCard.vue_vue_type_script_setup_true_lang-f2b2db58.js";import{x as n,D as a,o as c,s as m,a as e,w as t,f as d,b as f,V as _,F as u}from"./index-dc96e1be.js";const p=["innerHTML"],v=n({__name:"MaterialIcons",setup(b){const s=a({title:"Material Icons"}),r=a('<iframe src="https://materialdesignicons.com/" frameborder="0"  width="100%" height="1000"></iframe>'),l=a([{title:"Icons",disabled:!1,href:"#"},{title:"Material Icons",disabled:!0,href:"#"}]);return(h,M)=>(c(),m(u,null,[e(o,{title:s.value.title,breadcrumbs:l.value},null,8,["title","breadcrumbs"]),e(_,null,{default:t(()=>[e(d,{cols:"12",md:"12"},{default:t(()=>[e(i,{title:"Material Icons"},{default:t(()=>[f("div",{innerHTML:r.value},null,8,p)]),_:1})]),_:1})]),_:1})],64))}});export{v as default};

addons/dashboard/dist/assets/RegisterPage-03654257.js

@@ -1 +0,0 @@
-import{_ as B}from"./LogoDark.vue_vue_type_script_setup_true_lang-7df35c25.js";import{x as y,D as o,o as b,s as U,a as e,w as a,b as n,B as $,d as u,f as d,A as _,e as f,V as r,O as m,ap as A,au as E,F,c as T,N as q,J as V,L as P}from"./index-dc96e1be.js";const z="/assets/social-google-a359a253.svg",N=["src"],S=n("span",{class:"ml-2"},"Sign up with Google",-1),D=n("h5",{class:"text-h5 text-center my-4 mb-8"},"Sign up with Email address",-1),G={class:"d-sm-inline-flex align-center mt-2 mb-7 mb-sm-0 font-weight-bold"},L=n("a",{href:"#",class:"ml-1 text-lightText"},"Terms and Condition",-1),O={class:"mt-5 text-right"},j=y({__name:"AuthRegister",setup(w){const c=o(!1),i=o(!1),p=o(""),v=o(""),g=o(),h=o(""),x=o(""),k=o([s=>!!s||"Password is required",s=>s&&s.length<=10||"Password must be less than 10 characters"]),C=o([s=>!!s||"E-mail is required",s=>/.+@.+\..+/.test(s)||"E-mail must be valid"]);function R(){g.value.validate()}return(s,l)=>(b(),U(F,null,[e(u,{block:"",color:"primary",variant:"outlined",class:"text-lightText googleBtn"},{default:a(()=>[n("img",{src:$(z),alt:"google"},null,8,N),S]),_:1}),e(r,null,{default:a(()=>[e(d,{class:"d-flex align-center"},{default:a(()=>[e(_,{class:"custom-devider"}),e(u,{variant:"outlined",class:"orbtn",rounded:"md",size:"small"},{default:a(()=>[f("OR")]),_:1}),e(_,{class:"custom-devider"})]),_:1})]),_:1}),D,e(E,{ref_key:"Regform",ref:g,"lazy-validation":"",action:"/dashboards/analytical",class:"mt-7 loginForm"},{default:a(()=>[e(r,null,{default:a(()=>[e(d,{cols:"12",sm:"6"},{default:a(()=>[e(m,{modelValue:h.value,"onUpdate:modelValue":l[0]||(l[0]=t=>h.value=t),density:"comfortable","hide-details":"auto",variant:"outlined",color:"primary",label:"Firstname"},null,8,["modelValue"])]),_:1}),e(d,{cols:"12",sm:"6"},{default:a(()=>[e(m,{modelValue:x.value,"onUpdate:modelValue":l[1]||(l[1]=t=>x.value=t),density:"comfortable","hide-details":"auto",variant:"outlined",color:"primary",label:"Lastname"},null,8,["modelValue"])]),_:1})]),_:1}),e(m,{modelValue:v.value,"onUpdate:modelValue":l[2]||(l[2]=t=>v.value=t),rules:C.value,label:"Email Address / Username",class:"mt-4 mb-4",required:"",density:"comfortable","hide-details":"auto",variant:"outlined",color:"primary"},null,8,["modelValue","rules"]),e(m,{modelValue:p.value,"onUpdate:modelValue":l[3]||(l[3]=t=>p.value=t),rules:k.value,label:"Password",required:"",density:"comfortable",variant:"outlined",color:"primary","hide-details":"auto","append-icon":i.value?"mdi-eye":"mdi-eye-off",type:i.value?"text":"password","onClick:append":l[4]||(l[4]=t=>i.value=!i.value),class:"pwdInput"},null,8,["modelValue","rules","append-icon","type"]),n("div",G,[e(A,{modelValue:c.value,"onUpdate:modelValue":l[5]||(l[5]=t=>c.value=t),rules:[t=>!!t||"You must agree to continue!"],label:"Agree with?",required:"",color:"primary",class:"ms-n2","hide-details":""},null,8,["modelValue","rules"]),L]),e(u,{color:"secondary",block:"",class:"mt-2",variant:"flat",size:"large",onClick:l[6]||(l[6]=t=>R())},{default:a(()=>[f("Sign Up")]),_:1})]),_:1},512),n("div",O,[e(_),e(u,{variant:"plain",to:"/auth/login",class:"mt-2 text-capitalize mr-n2"},{default:a(()=>[f("Already have an account?")]),_:1})])],64))}});const I={class:"pa-7 pa-sm-12"},J=n("h2",{class:"text-secondary text-h2 mt-8"},"Sign up",-1),Y=n("h4",{class:"text-disabled text-h4 mt-3"},"Enter credentials to continue",-1),M=y({__name:"RegisterPage",setup(w){return(c,i)=>(b(),T(r,{class:"h-100vh","no-gutters":""},{default:a(()=>[e(d,{cols:"12",class:"d-flex align-center bg-lightprimary"},{default:a(()=>[e(q,null,{default:a(()=>[n("div",I,[e(r,{justify:"center"},{default:a(()=>[e(d,{cols:"12",lg:"10",xl:"6",md:"7"},{default:a(()=>[e(V,{elevation:"0",class:"loginBox"},{default:a(()=>[e(V,{variant:"outlined"},{default:a(()=>[e(P,{class:"pa-9"},{default:a(()=>[e(r,null,{default:a(()=>[e(d,{cols:"12",class:"text-center"},{default:a(()=>[e(B),J,Y]),_:1})]),_:1}),e(j)]),_:1})]),_:1})]),_:1})]),_:1})]),_:1})])]),_:1})]),_:1})]),_:1}))}});export{M as default};

addons/dashboard/dist/assets/RegisterPage-799ed804.css

@@ -1 +0,0 @@
-.custom-devider{border-color:#00000014!important}.googleBtn{border-color:#00000014;margin:30px 0 20px}.outlinedInput .v-field{border:1px solid rgba(0,0,0,.08);box-shadow:none}.orbtn{padding:2px 40px;border-color:#00000014;margin:20px 15px}.pwdInput{position:relative}.pwdInput .v-input__append{position:absolute;right:10px;top:50%;transform:translateY(-50%)}.loginBox{max-width:475px;margin:0 auto}

addons/dashboard/dist/assets/ShadowPage-fb617452.js

@@ -1 +0,0 @@
-import{_ as c}from"./BaseBreadcrumb.vue_vue_type_style_index_0_lang-e31f96f8.js";import{_ as f}from"./UiParentCard.vue_vue_type_script_setup_true_lang-f2b2db58.js";import{x as m,D as s,o as l,s as r,a as e,w as a,f as i,V as o,F as d,u as _,J as p,X as b,b as h,t as g}from"./index-dc96e1be.js";const v=m({__name:"ShadowPage",setup(w){const n=s({title:"Shadow Page"}),u=s([{title:"Utilities",disabled:!1,href:"#"},{title:"Shadow",disabled:!0,href:"#"}]);return(V,x)=>(l(),r(d,null,[e(c,{title:n.value.title,breadcrumbs:u.value},null,8,["title","breadcrumbs"]),e(o,null,{default:a(()=>[e(i,{cols:"12",md:"12"},{default:a(()=>[e(f,{title:"Basic Shadow"},{default:a(()=>[e(o,{justify:"center"},{default:a(()=>[(l(),r(d,null,_(25,t=>e(i,{key:t,cols:"auto"},{default:a(()=>[e(p,{height:"100",width:"100",class:b(["mb-5",["d-flex justify-center align-center bg-primary",`elevation-${t}`]])},{default:a(()=>[h("div",null,g(t-1),1)]),_:2},1032,["class"])]),_:2},1024)),64))]),_:1})]),_:1})]),_:1})]),_:1})],64))}});export{v as default};

addons/dashboard/dist/assets/TablerIcons-3ae5dd43.js

@@ -1 +0,0 @@
-import{_ as o}from"./BaseBreadcrumb.vue_vue_type_style_index_0_lang-e31f96f8.js";import{_ as n}from"./UiParentCard.vue_vue_type_script_setup_true_lang-f2b2db58.js";import{x as c,D as a,o as i,s as m,a as e,w as t,f as d,b as f,V as _,F as u}from"./index-dc96e1be.js";const b=["innerHTML"],w=c({__name:"TablerIcons",setup(p){const s=a({title:"Tabler Icons"}),r=a('<iframe src="https://tablericons.com/" frameborder="0"  width="100%" height="600"></iframe>'),l=a([{title:"Icons",disabled:!1,href:"#"},{title:"Tabler Icons",disabled:!0,href:"#"}]);return(h,T)=>(i(),m(u,null,[e(o,{title:s.value.title,breadcrumbs:l.value},null,8,["title","breadcrumbs"]),e(_,null,{default:t(()=>[e(d,{cols:"12",md:"12"},{default:t(()=>[e(n,{title:"Tabler Icons"},{default:t(()=>[f("div",{innerHTML:r.value},null,8,b)]),_:1})]),_:1})]),_:1})],64))}});export{w as default};

addons/dashboard/dist/assets/TypographyPage-7d559339.js

@@ -1 +0,0 @@
-import{_ as m}from"./BaseBreadcrumb.vue_vue_type_style_index_0_lang-e31f96f8.js";import{_ as v}from"./UiParentCard.vue_vue_type_script_setup_true_lang-f2b2db58.js";import{x as f,o as i,c as g,w as e,a,a8 as y,K as b,e as w,t as d,A as C,L as V,a9 as L,J as _,D as o,s as h,f as k,b as t,F as x,u as B,X as H,V as T}from"./index-dc96e1be.js";const s=f({__name:"UiChildCard",props:{title:String},setup(r){const l=r;return(n,c)=>(i(),g(_,{variant:"outlined"},{default:e(()=>[a(y,{class:"py-3"},{default:e(()=>[a(b,{class:"text-h5"},{default:e(()=>[w(d(l.title),1)]),_:1})]),_:1}),a(C),a(V,null,{default:e(()=>[L(n.$slots,"default")]),_:3})]),_:3}))}}),D={class:"d-flex flex-column gap-1"},S={class:"text-caption pa-2 bg-lightprimary"},z=t("div",{class:"text-grey"},"Class",-1),N={class:"font-weight-medium"},$=t("div",null,[t("p",{class:"text-left"},"Left aligned on all viewport sizes."),t("p",{class:"text-center"},"Center aligned on all viewport sizes."),t("p",{class:"text-right"},"Right aligned on all viewport sizes."),t("p",{class:"text-sm-left"},"Left aligned on viewports SM (small) or wider."),t("p",{class:"text-right text-md-left"},"Left aligned on viewports MD (medium) or wider."),t("p",{class:"text-right text-lg-left"},"Left aligned on viewports LG (large) or wider."),t("p",{class:"text-right text-xl-left"},"Left aligned on viewports XL (extra-large) or wider.")],-1),M=t("div",{class:"d-flex justify-space-between flex-row"},[t("a",{href:"#",class:"text-decoration-none"},"Non-underlined link"),t("div",{class:"text-decoration-line-through"},"Line-through text"),t("div",{class:"text-decoration-overline"},"Overline text"),t("div",{class:"text-decoration-underline"},"Underline text")],-1),O=t("div",null,[t("p",{class:"text-high-emphasis"},"High-emphasis has an opacity of 87% in light theme and 100% in dark."),t("p",{class:"text-medium-emphasis"},"Medium-emphasis text and hint text have opacities of 60% in light theme and 70% in dark."),t("p",{class:"text-disabled"},"Disabled text has an opacity of 38% in light theme and 50% in dark.")],-1),j=f({__name:"TypographyPage",setup(r){const l=o({title:"Typography Page"}),n=o([["Heading 1","text-h1"],["Heading 2","text-h2"],["Heading 3","text-h3"],["Heading 4","text-h4"],["Heading 5","text-h5"],["Heading 6","text-h6"],["Subtitle 1","text-subtitle-1"],["Subtitle 2","text-subtitle-2"],["Body 1","text-body-1"],["Body 2","text-body-2"],["Button","text-button"],["Caption","text-caption"],["Overline","text-overline"]]),c=o([{title:"Utilities",disabled:!1,href:"#"},{title:"Typography",disabled:!0,href:"#"}]);return(U,F)=>(i(),h(x,null,[a(m,{title:l.value.title,breadcrumbs:c.value},null,8,["title","breadcrumbs"]),a(T,null,{default:e(()=>[a(k,{cols:"12",md:"12"},{default:e(()=>[a(v,{title:"Basic Typography"},{default:e(()=>[a(s,{title:"Heading"},{default:e(()=>[t("div",D,[(i(!0),h(x,null,B(n.value,([p,u])=>(i(),g(_,{variant:"outlined",key:p,class:"my-4"},{default:e(()=>[t("div",{class:H([u,"pa-2"])},d(p),3),t("div",S,[z,t("div",N,d(u),1)])]),_:2},1024))),128))])]),_:1}),a(s,{title:"Text-alignment",class:"mt-8"},{default:e(()=>[$]),_:1}),a(s,{title:"Decoration",class:"mt-8"},{default:e(()=>[M]),_:1}),a(s,{title:"Opacity",class:"mt-8"},{default:e(()=>[O]),_:1})]),_:1})]),_:1})]),_:1})],64))}});export{j as default};

addons/dashboard/dist/assets/UiParentCard.vue_vue_type_script_setup_true_lang-f2b2db58.js

@@ -1 +0,0 @@
-import{x as n,o,c as i,w as e,a,a8 as d,b as c,K as u,e as p,t as _,a9 as s,A as f,L as V,J as m}from"./index-dc96e1be.js";const C={class:"d-sm-flex align-center justify-space-between"},h=n({__name:"UiParentCard",props:{title:String},setup(l){const r=l;return(t,x)=>(o(),i(m,{variant:"outlined",elevation:"0",class:"withbg"},{default:e(()=>[a(d,null,{default:e(()=>[c("div",C,[a(u,null,{default:e(()=>[p(_(r.title),1)]),_:1}),s(t.$slots,"action")])]),_:3}),a(f),a(V,null,{default:e(()=>[s(t.$slots,"default")]),_:3})]),_:3}))}});export{h as _};

addons/dashboard/dist/assets/_plugin-vue_export-helper-c27b6911.js

@@ -1 +0,0 @@
-const s=(t,r)=>{const o=t.__vccOpts||t;for(const[c,e]of r)o[c]=e;return o};export{s as _};

addons/dashboard/helper.py

@@ -1,533 +0,0 @@
-from addons.dashboard.server import AstrBotDashBoard, DashBoardData
-from pydantic import BaseModel
-from typing import Union, Optional
-import uuid
-from util import general_utils as gu
-from util.cmd_config import CmdConfig
-from dataclasses import dataclass
-import sys
-import os
-import threading
-import time
-import asyncio
-from util.plugin_dev.api.v1.config import update_config
-from SparkleLogging.utils.core import LogManager
-from logging import Logger
-
-logger: Logger = LogManager.GetLogger(log_name='astrbot-core')
-
-
-@dataclass
-class DashBoardConfig():
-    config_type: str
-    name: Optional[str] = None
-    description: Optional[str] = None
-    path: Optional[str] = None  # 仅 item 才需要
-    body: Optional[list['DashBoardConfig']] = None  # 仅 group 才需要
-    value: Optional[Union[list, dict, str, int, bool]] = None  # 仅 item 才需要
-    val_type: Optional[str] = None  # 仅 item 才需要
-
-
-class DashBoardHelper():
-    def __init__(self, global_object, config: dict):
-        self.loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(self.loop)
-        dashboard_data = global_object.dashboard_data
-        dashboard_data.configs = {
-            "data": []
-        }
-        self.parse_default_config(dashboard_data, config)
-        self.dashboard_data: DashBoardData = dashboard_data
-        self.dashboard = AstrBotDashBoard(global_object)
-        self.key_map = {}  # key: uuid, value: config key name
-        self.cc = CmdConfig()
-
-        @self.dashboard.register("post_configs")
-        def on_post_configs(post_configs: dict):
-            try:
-                if 'base_config' in post_configs:
-                    self.save_config(
-                        post_configs['base_config'], namespace='')  # 基础配置
-                self.save_config(
-                    post_configs['config'], namespace=post_configs['namespace'])  # 选定配置
-                self.parse_default_config(
-                    self.dashboard_data, self.cc.get_all())
-                # 重启
-                threading.Thread(target=self.dashboard.shutdown_bot,
-                                 args=(2,), daemon=True).start()
-            except Exception as e:
-                raise e
-
-    # 将 config.yaml、 中的配置解析到 dashboard_data.configs 中
-    def parse_default_config(self, dashboard_data: DashBoardData, config: dict):
-
-        try:
-            qq_official_platform_group = DashBoardConfig(
-                config_type="group",
-                name="QQ_OFFICIAL 平台配置",
-                description="",
-                body=[
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="bool",
-                        name="启用 QQ_OFFICIAL 平台",
-                        description="官方的接口，仅支持 QQ 频道。详见 q.qq.com",
-                        value=config['qqbot']['enable'],
-                        path="qqbot.enable",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="str",
-                        name="QQ机器人APPID",
-                        description="详见 q.qq.com",
-                        value=config['qqbot']['appid'],
-                        path="qqbot.appid",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="str",
-                        name="QQ机器人令牌",
-                        description="详见 q.qq.com",
-                        value=config['qqbot']['token'],
-                        path="qqbot.token",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="str",
-                        name="QQ机器人 Secret",
-                        description="详见 q.qq.com",
-                        value=config['qqbot_secret'],
-                        path="qqbot_secret",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="bool",
-                        name="是否允许 QQ 频道私聊",
-                        description="如果启用，机器人会响应私聊消息。",
-                        value=config['direct_message_mode'],
-                        path="direct_message_mode",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="bool",
-                        name="是否接收QQ群消息",
-                        description="需要机器人有相应的群消息接收权限。在 q.qq.com 上查看。",
-                        value=config['qqofficial_enable_group_message'],
-                        path="qqofficial_enable_group_message",
-                    ),
-                ]
-            )
-            qq_gocq_platform_group = DashBoardConfig(
-                config_type="group",
-                name="OneBot协议平台配置",
-                description="",
-                body=[
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="bool",
-                        name="启用",
-                        description="支持cq-http、shamrock等（目前仅支持QQ平台）",
-                        value=config['gocqbot']['enable'],
-                        path="gocqbot.enable",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="str",
-                        name="HTTP 服务器地址",
-                        description="",
-                        value=config['gocq_host'],
-                        path="gocq_host",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="int",
-                        name="HTTP 服务器端口",
-                        description="",
-                        value=config['gocq_http_port'],
-                        path="gocq_http_port",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="int",
-                        name="WebSocket 服务器端口",
-                        description="目前仅支持正向 WebSocket",
-                        value=config['gocq_websocket_port'],
-                        path="gocq_websocket_port",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="bool",
-                        name="是否响应群消息",
-                        description="",
-                        value=config['gocq_react_group'],
-                        path="gocq_react_group",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="bool",
-                        name="是否响应私聊消息",
-                        description="",
-                        value=config['gocq_react_friend'],
-                        path="gocq_react_friend",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="bool",
-                        name="是否响应群成员增加消息",
-                        description="",
-                        value=config['gocq_react_group_increase'],
-                        path="gocq_react_group_increase",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="bool",
-                        name="是否响应频道消息",
-                        description="",
-                        value=config['gocq_react_guild'],
-                        path="gocq_react_guild",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="int",
-                        name="转发阈值（字符数）",
-                        description="机器人回复的消息长度超出这个值后，会被折叠成转发卡片发出以减少刷屏。",
-                        value=config['qq_forward_threshold'],
-                        path="qq_forward_threshold",
-                    ),
-                ]
-            )
-
-            general_platform_detail_group = DashBoardConfig(
-                config_type="group",
-                name="通用平台配置",
-                description="",
-                body=[
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="bool",
-                        name="启动消息文字转图片",
-                        description="启动后，机器人会将消息转换为图片发送，以降低风控风险。",
-                        value=config['qq_pic_mode'],
-                        path="qq_pic_mode",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="int",
-                        name="消息限制时间",
-                        description="在此时间内，机器人不会回复同一个用户的消息。单位：秒",
-                        value=config['limit']['time'],
-                        path="limit.time",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="int",
-                        name="消息限制次数",
-                        description="在上面的时间内，如果用户发送消息超过此次数，则机器人不会回复。单位：次",
-                        value=config['limit']['count'],
-                        path="limit.count",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="str",
-                        name="回复前缀",
-                        description="[xxxx] 你好！ 其中xxxx是你可以填写的前缀。如果为空则不显示。",
-                        value=config['reply_prefix'],
-                        path="reply_prefix",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="list",
-                        name="通用管理员用户 ID（支持多个管理员）。通过 !myid 指令获取。",
-                        description="",
-                        value=config['other_admins'],
-                        path="other_admins",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="bool",
-                        name="独立会话",
-                        description="是否启用独立会话模式，即 1 个用户自然账号 1 个会话。",
-                        value=config['uniqueSessionMode'],
-                        path="uniqueSessionMode",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="str",
-                        name="LLM 唤醒词",
-                        description="如果不为空, 那么只有当消息以此词开头时，才会调用大语言模型进行回复。如设置为 /chat，那么只有当消息以 /chat 开头时，才会调用大语言模型进行回复。",
-                        value=config['llm_wake_prefix'],
-                        path="llm_wake_prefix",
-                    )
-                ]
-            )
-
-            openai_official_llm_group = DashBoardConfig(
-                config_type="group",
-                name="OpenAI 官方接口类设置",
-                description="",
-                body=[
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="list",
-                        name="OpenAI API Key",
-                        description="OpenAI API 的 Key。支持使用非官方但兼容的 API（第三方中转key）。",
-                        value=config['openai']['key'],
-                        path="openai.key",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="str",
-                        name="OpenAI API 节点地址(api base)",
-                        description="OpenAI API 的节点地址，配合非官方 API 使用。如果不想填写，那么请填写 none",
-                        value=config['openai']['api_base'],
-                        path="openai.api_base",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="str",
-                        name="OpenAI model",
-                        description="OpenAI LLM 模型。详见 https://platform.openai.com/docs/api-reference/chat",
-                        value=config['openai']['chatGPTConfigs']['model'],
-                        path="openai.chatGPTConfigs.model",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="int",
-                        name="OpenAI max_tokens",
-                        description="OpenAI 最大生成长度。详见 https://platform.openai.com/docs/api-reference/chat",
-                        value=config['openai']['chatGPTConfigs']['max_tokens'],
-                        path="openai.chatGPTConfigs.max_tokens",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="float",
-                        name="OpenAI temperature",
-                        description="OpenAI 温度。详见 https://platform.openai.com/docs/api-reference/chat",
-                        value=config['openai']['chatGPTConfigs']['temperature'],
-                        path="openai.chatGPTConfigs.temperature",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="float",
-                        name="OpenAI top_p",
-                        description="OpenAI top_p。详见 https://platform.openai.com/docs/api-reference/chat",
-                        value=config['openai']['chatGPTConfigs']['top_p'],
-                        path="openai.chatGPTConfigs.top_p",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="float",
-                        name="OpenAI frequency_penalty",
-                        description="OpenAI frequency_penalty。详见 https://platform.openai.com/docs/api-reference/chat",
-                        value=config['openai']['chatGPTConfigs']['frequency_penalty'],
-                        path="openai.chatGPTConfigs.frequency_penalty",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="float",
-                        name="OpenAI presence_penalty",
-                        description="OpenAI presence_penalty。详见 https://platform.openai.com/docs/api-reference/chat",
-                        value=config['openai']['chatGPTConfigs']['presence_penalty'],
-                        path="openai.chatGPTConfigs.presence_penalty",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="int",
-                        name="OpenAI 总生成长度限制",
-                        description="OpenAI 总生成长度限制。详见 https://platform.openai.com/docs/api-reference/chat",
-                        value=config['openai']['total_tokens_limit'],
-                        path="openai.total_tokens_limit",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="str",
-                        name="OpenAI 图像生成模型",
-                        description="OpenAI 图像生成模型。",
-                        value=config['openai_image_generate']['model'],
-                        path="openai_image_generate.model",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="str",
-                        name="OpenAI 图像生成大小",
-                        description="OpenAI 图像生成大小。",
-                        value=config['openai_image_generate']['size'],
-                        path="openai_image_generate.size",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="str",
-                        name="OpenAI 图像生成风格",
-                        description="OpenAI 图像生成风格。修改前请参考 OpenAI 官方文档",
-                        value=config['openai_image_generate']['style'],
-                        path="openai_image_generate.style",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="str",
-                        name="OpenAI 图像生成质量",
-                        description="OpenAI 图像生成质量。修改前请参考 OpenAI 官方文档",
-                        value=config['openai_image_generate']['quality'],
-                        path="openai_image_generate.quality",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="str",
-                        name="问题题首提示词",
-                        description="如果填写了此项，在每个对大语言模型的请求中，都会在问题前加上此提示词。",
-                        value=config['llm_env_prompt'],
-                        path="llm_env_prompt",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="str",
-                        name="默认人格文本",
-                        description="默认人格文本",
-                        value=config['default_personality_str'],
-                        path="default_personality_str",
-                    ),
-                ]
-            )
-
-            baidu_aip_group = DashBoardConfig(
-                config_type="group",
-                name="百度内容审核",
-                description="需要去申请",
-                body=[
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="bool",
-                        name="启动百度内容审核服务",
-                        description="",
-                        value=config['baidu_aip']['enable'],
-                        path="baidu_aip.enable"
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="str",
-                        name="APP ID",
-                        description="",
-                        value=config['baidu_aip']['app_id'],
-                        path="baidu_aip.app_id"
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="str",
-                        name="API KEY",
-                        description="",
-                        value=config['baidu_aip']['api_key'],
-                        path="baidu_aip.api_key"
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="str",
-                        name="SECRET KEY",
-                        description="",
-                        value=config['baidu_aip']['secret_key'],
-                        path="baidu_aip.secret_key"
-                    )
-                ]
-            )
-
-            other_group = DashBoardConfig(
-                config_type="group",
-                name="其他配置",
-                description="其他配置描述",
-                body=[
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="str",
-                        name="HTTP 代理地址",
-                        description="建议上下一致",
-                        value=config['http_proxy'],
-                        path="http_proxy",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="str",
-                        name="HTTPS 代理地址",
-                        description="建议上下一致",
-                        value=config['https_proxy'],
-                        path="https_proxy",
-                    ),
-                    DashBoardConfig(
-                        config_type="item",
-                        val_type="str",
-                        name="面板用户名",
-                        description="是的，就是你理解的这个面板的用户名",
-                        value=config['dashboard_username'],
-                        path="dashboard_username",
-                    ),
-                ]
-            )
-
-            dashboard_data.configs['data'] = [
-                qq_official_platform_group,
-                qq_gocq_platform_group,
-                general_platform_detail_group,
-                openai_official_llm_group,
-                other_group,
-                baidu_aip_group
-            ]
-
-        except Exception as e:
-            logger.error(f"配置文件解析错误：{e}")
-            raise e
-
-    def save_config(self, post_config: list, namespace: str):
-        '''
-        根据 path 解析并保存配置
-        '''
-
-        queue = post_config
-        while len(queue) > 0:
-            config = queue.pop(0)
-            if config['config_type'] == "group":
-                for item in config['body']:
-                    queue.append(item)
-            elif config['config_type'] == "item":
-                if config['path'] is None or config['path'] == "":
-                    continue
-
-                path = config['path'].split('.')
-                if len(path) == 0:
-                    continue
-
-                if config['val_type'] == "bool":
-                    self._write_config(
-                        namespace, config['path'], config['value'])
-                elif config['val_type'] == "str":
-                    self._write_config(
-                        namespace, config['path'], config['value'])
-                elif config['val_type'] == "int":
-                    try:
-                        self._write_config(
-                            namespace, config['path'], int(config['value']))
-                    except:
-                        raise ValueError(f"配置项 {config['name']} 的值必须是整数")
-                elif config['val_type'] == "float":
-                    try:
-                        self._write_config(
-                            namespace, config['path'], float(config['value']))
-                    except:
-                        raise ValueError(f"配置项 {config['name']} 的值必须是浮点数")
-                elif config['val_type'] == "list":
-                    if config['value'] is None:
-                        self._write_config(namespace, config['path'], [])
-                    elif not isinstance(config['value'], list):
-                        raise ValueError(f"配置项 {config['name']} 的值必须是列表")
-                    self._write_config(
-                        namespace, config['path'], config['value'])
-                else:
-                    raise NotImplementedError(
-                        f"未知或者未实现的配置项类型：{config['val_type']}")
-
-    def _write_config(self, namespace: str, key: str, value):
-        if namespace == "" or namespace.startswith("internal_"):
-            # 机器人自带配置，存到 config.yaml
-            self.cc.put_by_dot_str(key, value)
-        else:
-            update_config(namespace, key, value)
-
-    def run(self):
-        self.dashboard.run()

addons/dashboard/server.py

@@ -1,476 +0,0 @@
-import util.plugin_util as putil
-import websockets
-import json
-import threading
-import asyncio
-import os
-import sys
-import time
-
-from flask import Flask, request
-from flask.logging import default_handler
-from werkzeug.serving import make_server
-from util import general_utils as gu
-from dataclasses import dataclass
-from persist.session import dbConn
-from type.register import RegisteredPlugin
-from typing import List
-from util.cmd_config import CmdConfig
-from util.updator import check_update, update_project, request_release_info
-from SparkleLogging.utils.core import LogManager
-from logging import Logger
-logger: Logger = LogManager.GetLogger(log_name='astrbot-core')
-
-@dataclass
-class DashBoardData():
-    stats: dict
-    configs: dict
-    logs: dict
-    plugins: List[RegisteredPlugin]
-
-
-@dataclass
-class Response():
-    status: str
-    message: str
-    data: dict
-
-
-class AstrBotDashBoard():
-    def __init__(self, global_object: 'gu.GlobalObject'):
-        self.global_object = global_object
-        self.loop = asyncio.get_event_loop()
-        asyncio.set_event_loop(self.loop)
-        self.dashboard_data: DashBoardData = global_object.dashboard_data
-        self.dashboard_be = Flask(
-            __name__, static_folder="dist", static_url_path="/")
-        self.funcs = {}
-        self.cc = CmdConfig()
-        self.ws_clients = {}  # remote_ip: ws
-        # 启动 websocket 服务器
-        self.ws_server = websockets.serve(self.__handle_msg, "0.0.0.0", 6186)
-
-        @self.dashboard_be.get("/")
-        def index():
-            # 返回页面
-            return self.dashboard_be.send_static_file("index.html")
-
-        @self.dashboard_be.get("/config")
-        def rt_config():
-            return self.dashboard_be.send_static_file("index.html")
-
-        @self.dashboard_be.get("/logs")
-        def rt_logs():
-            return self.dashboard_be.send_static_file("index.html")
-        
-        @self.dashboard_be.get("/extension")
-        def rt_extension():
-            return self.dashboard_be.send_static_file("index.html")
-
-        @self.dashboard_be.get("/dashboard/default")
-        def rt_dashboard():
-            return self.dashboard_be.send_static_file("index.html")
-
-        @self.dashboard_be.post("/api/authenticate")
-        def authenticate():
-            username = self.cc.get("dashboard_username", "")
-            password = self.cc.get("dashboard_password", "")
-            # 获得请求体
-            post_data = request.json
-            if post_data["username"] == username and post_data["password"] == password:
-                return Response(
-                    status="success",
-                    message="登录成功。",
-                    data={
-                        "token": "astrbot-test-token",
-                        "username": username
-                    }
-                ).__dict__
-            else:
-                return Response(
-                    status="error",
-                    message="用户名或密码错误。",
-                    data=None
-                ).__dict__
-
-        @self.dashboard_be.post("/api/change_password")
-        def change_password():
-            password = self.cc.get("dashboard_password", "")
-            # 获得请求体
-            post_data = request.json
-            if post_data["password"] == password:
-                self.cc.put("dashboard_password", post_data["new_password"])
-                return Response(
-                    status="success",
-                    message="修改成功。",
-                    data=None
-                ).__dict__
-            else:
-                return Response(
-                    status="error",
-                    message="原密码错误。",
-                    data=None
-                ).__dict__
-
-        @self.dashboard_be.get("/api/stats")
-        def get_stats():
-            db_inst = dbConn()
-            all_session = db_inst.get_all_stat_session()
-            last_24_message = db_inst.get_last_24h_stat_message()
-            # last_24_platform = db_inst.get_last_24h_stat_platform()
-            platforms = db_inst.get_platform_cnt_total()
-            self.dashboard_data.stats["session"] = []
-            self.dashboard_data.stats["session_total"] = db_inst.get_session_cnt_total(
-            )
-            self.dashboard_data.stats["message"] = last_24_message
-            self.dashboard_data.stats["message_total"] = db_inst.get_message_cnt_total(
-            )
-            self.dashboard_data.stats["platform"] = platforms
-
-            return Response(
-                status="success",
-                message="",
-                data=self.dashboard_data.stats
-            ).__dict__
-
-        @self.dashboard_be.get("/api/configs")
-        def get_configs():
-            # 如果params中有namespace，则返回该namespace下的配置
-            # 否则返回所有配置
-            namespace = "" if "namespace" not in request.args else request.args["namespace"]
-            conf = self._get_configs(namespace)
-            return Response(
-                status="success",
-                message="",
-                data=conf
-            ).__dict__
-
-        @self.dashboard_be.get("/api/config_outline")
-        def get_config_outline():
-            outline = self._generate_outline()
-            return Response(
-                status="success",
-                message="",
-                data=outline
-            ).__dict__
-
-        @self.dashboard_be.post("/api/configs")
-        def post_configs():
-            post_configs = request.json
-            try:
-                self.funcs["post_configs"](post_configs)
-                return Response(
-                    status="success",
-                    message="保存成功~ 机器人将在 2 秒内重启以应用新的配置。",
-                    data=None
-                ).__dict__
-            except Exception as e:
-                return Response(
-                    status="error",
-                    message=e.__str__(),
-                    data=self.dashboard_data.configs
-                ).__dict__
-
-        @self.dashboard_be.get("/api/extensions")
-        def get_plugins():
-            _plugin_resp = []
-            for plugin in self.dashboard_data.plugins:
-                _p = plugin.metadata
-                _t = {
-                    "name": _p.plugin_name,
-                    "repo": '' if _p.repo is None else _p.repo,
-                    "author": _p.author,
-                    "desc": _p.desc,
-                    "version": _p.version
-                }
-                _plugin_resp.append(_t)
-            return Response(
-                status="success",
-                message="",
-                data=_plugin_resp
-            ).__dict__
-
-        @self.dashboard_be.post("/api/extensions/install")
-        def install_plugin():
-            post_data = request.json
-            repo_url = post_data["url"]
-            try:
-                logger.info(f"正在安装插件 {repo_url}")
-                putil.install_plugin(repo_url, self.dashboard_data.plugins)
-                logger.info(f"安装插件 {repo_url} 成功")
-                return Response(
-                    status="success",
-                    message="安装成功~",
-                    data=None
-                ).__dict__
-            except Exception as e:
-                return Response(
-                    status="error",
-                    message=e.__str__(),
-                    data=None
-                ).__dict__
-
-        @self.dashboard_be.post("/api/extensions/uninstall")
-        def uninstall_plugin():
-            post_data = request.json
-            plugin_name = post_data["name"]
-            try:
-                logger.info(f"正在卸载插件 {plugin_name}")
-                putil.uninstall_plugin(
-                    plugin_name, self.dashboard_data.plugins)
-                logger.info(f"卸载插件 {plugin_name} 成功")
-                return Response(
-                    status="success",
-                    message="卸载成功~",
-                    data=None
-                ).__dict__
-            except Exception as e:
-                return Response(
-                    status="error",
-                    message=e.__str__(),
-                    data=None
-                ).__dict__
-
-        @self.dashboard_be.post("/api/extensions/update")
-        def update_plugin():
-            post_data = request.json
-            plugin_name = post_data["name"]
-            try:
-                logger.info(f"正在更新插件 {plugin_name}")
-                putil.update_plugin(plugin_name, self.dashboard_data.plugins)
-                logger.info(f"更新插件 {plugin_name} 成功")
-                return Response(
-                    status="success",
-                    message="更新成功~",
-                    data=None
-                ).__dict__
-            except Exception as e:
-                return Response(
-                    status="error",
-                    message=e.__str__(),
-                    data=None
-                ).__dict__
-
-        @self.dashboard_be.post("/api/log")
-        def log():
-            for item in self.ws_clients:
-                try:
-                    asyncio.run_coroutine_threadsafe(
-                        self.ws_clients[item].send(request.data.decode()), self.loop)
-                except Exception as e:
-                    pass
-            return 'ok'
-
-        @self.dashboard_be.get("/api/check_update")
-        def get_update_info():
-            try:
-                ret = check_update()
-                return Response(
-                    status="success",
-                    message=ret,
-                    data={
-                        "has_new_version": ret != "当前已经是最新版本。"  # 先这样吧，累了=.=
-                    }
-                ).__dict__
-            except Exception as e:
-                return Response(
-                    status="error",
-                    message=e.__str__(),
-                    data=None
-                ).__dict__
-
-        @self.dashboard_be.post("/api/update_project")
-        def update_project_api():
-            version = request.json['version']
-            if version == "" or version == "latest":
-                latest = True
-                version = ''
-            else:
-                latest = False
-            try:
-                update_project(request_release_info(latest),
-                               latest=latest, version=version)
-                threading.Thread(target=self.shutdown_bot, args=(3,)).start()
-                return Response(
-                    status="success",
-                    message="更新成功，机器人将在 3 秒内重启。",
-                    data=None
-                ).__dict__
-            except Exception as e:
-                return Response(
-                    status="error",
-                    message=e.__str__(),
-                    data=None
-                ).__dict__
-
-        @self.dashboard_be.get("/api/llm/list")
-        def llm_list():
-            ret = []
-            for llm in self.global_object.llms:
-                ret.append(llm.llm_name)
-            return Response(
-                status="success",
-                message="",
-                data=ret
-            ).__dict__
-
-        @self.dashboard_be.get("/api/llm")
-        def llm():
-            text = request.args["text"]
-            llm = request.args["llm"]
-            for llm_ in self.global_object.llms:
-                if llm_.llm_name == llm:
-                    try:
-                        # ret = await llm_.llm_instance.text_chat(text)
-                        ret = asyncio.run_coroutine_threadsafe(
-                            llm_.llm_instance.text_chat(text), self.loop).result()
-                        return Response(
-                            status="success",
-                            message="",
-                            data=ret
-                        ).__dict__
-                    except Exception as e:
-                        return Response(
-                            status="error",
-                            message=e.__str__(),
-                            data=None
-                        ).__dict__
-
-            return Response(
-                status="error",
-                message="LLM not found.",
-                data=None
-            ).__dict__
-
-    def shutdown_bot(self, delay_s: int):
-        time.sleep(delay_s)
-        py = sys.executable
-        os.execl(py, py, *sys.argv)
-
-    def _get_configs(self, namespace: str):
-        if namespace == "":
-            ret = [self.dashboard_data.configs['data'][4],
-                   self.dashboard_data.configs['data'][5],]
-        elif namespace == "internal_platform_qq_official":
-            ret = [self.dashboard_data.configs['data'][0],]
-        elif namespace == "internal_platform_qq_gocq":
-            ret = [self.dashboard_data.configs['data'][1],]
-        elif namespace == "internal_platform_general":  # 全局平台配置
-            ret = [self.dashboard_data.configs['data'][2],]
-        elif namespace == "internal_llm_openai_official":
-            ret = [self.dashboard_data.configs['data'][3],]
-        else:
-            path = f"data/config/{namespace}.json"
-            if not os.path.exists(path):
-                return []
-            with open(path, "r", encoding="utf-8-sig") as f:
-                ret = [{
-                    "config_type": "group",
-                    "name": namespace + " 插件配置",
-                    "description": "",
-                    "body": list(json.load(f).values())
-                },]
-        return ret
-
-    def _generate_outline(self):
-        '''
-        生成配置大纲。目前分为 platform(消息平台配置) 和 llm(语言模型配置) 两大类。
-        插件的info函数中如果带了plugin_type字段，则会被归类到对应的大纲中。目前仅支持 platform 和 llm 两种类型。
-        '''
-        outline = [
-            {
-                "type": "platform",
-                "name": "配置通用消息平台",
-                "body": [
-                    {
-                        "title": "通用",
-                        "desc": "通用平台配置",
-                        "namespace": "internal_platform_general",
-                        "tag": ""
-                    },
-                    {
-                        "title": "QQ_OFFICIAL",
-                        "desc": "QQ官方API，仅支持频道",
-                        "namespace": "internal_platform_qq_official",
-                        "tag": ""
-                    },
-                    {
-                        "title": "OneBot协议",
-                        "desc": "支持cq-http、shamrock等（目前仅支持QQ平台）",
-                        "namespace": "internal_platform_qq_gocq",
-                        "tag": ""
-                    }
-                ]
-            },
-            {
-                "type": "llm",
-                "name": "配置 LLM",
-                "body": [
-                    {
-                        "title": "OpenAI Official",
-                        "desc": "也支持使用官方接口的中转服务",
-                        "namespace": "internal_llm_openai_official",
-                        "tag": ""
-                    }
-                ]
-            }
-        ]
-        for plugin in self.global_object.cached_plugins:
-            for item in outline:
-                if item['type'] == plugin.metadata.plugin_type:
-                    item['body'].append({
-                        "title": plugin.metadata.plugin_name,
-                        "desc": plugin.metadata.desc,
-                        "namespace": plugin.metadata.plugin_name,
-                        "tag": plugin.metadata.plugin_name
-                    })
-        return outline
-
-    def register(self, name: str):
-        def decorator(func):
-            self.funcs[name] = func
-            return func
-        return decorator
-
-    async def get_log_history(self):
-        try:
-            with open("logs/astrbot-core/astrbot-core.log", "r", encoding="utf-8") as f:
-                return f.readlines()[-100:]
-        except Exception as e:
-            logger.warning(f"读取日志历史失败: {e.__str__()}")
-            return []
-
-    async def __handle_msg(self, websocket, path):
-        address = websocket.remote_address
-        self.ws_clients[address] = websocket
-        data = await self.get_log_history()
-        data = ''.join(data).replace('\n', '\r\n')
-        await websocket.send(data)
-        while True:
-            try:
-                msg = await websocket.recv()
-            except websockets.exceptions.ConnectionClosedError:
-                # logger.info(f"和 {address} 的 websocket 连接已断开")
-                del self.ws_clients[address]
-                break
-            except Exception as e:
-                # logger.info(f"和 {path} 的 websocket 连接发生了错误: {e.__str__()}")
-                del self.ws_clients[address]
-                break
-
-    def run_ws_server(self, loop):
-        asyncio.set_event_loop(loop)
-        loop.run_until_complete(self.ws_server)
-        loop.run_forever()
-
-    def run(self):
-        threading.Thread(target=self.run_ws_server, args=(self.loop,)).start()
-        logger.info("已启动 websocket 服务器")
-        ip_address = gu.get_local_ip_addresses()
-        ip_str = f"http://{ip_address}:6185\n\thttp://localhost:6185"
-        logger.info(
-            f"\n==================\n您可访问:\n\n\t{ip_str}\n\n来登录可视化面板，默认账号密码为空。\n注意: 所有配置项现已全量迁移至 cmd_config.json 文件下，可登录可视化面板在线修改配置。\n==================\n")
-        
-        http_server = make_server(
-            '0.0.0.0', 6185, self.dashboard_be, threaded=True)
-        http_server.serve_forever()

addons/plugins/helloworld/helloworld.py

@@ -1,168 +0,0 @@
-import os
-import shutil
-from nakuru.entities.components import *
-flag_not_support = False
-try:
-    from util.plugin_dev.api.v1.config import *
-    from util.plugin_dev.api.v1.bot import (
-        AstrMessageEvent,
-        CommandResult,
-    )
-except ImportError:
-    flag_not_support = True
-    print("导入接口失败。请升级到 AstrBot 最新版本。")
-
-
-'''
-注意改插件名噢！格式：XXXPlugin 或 Main
-小提示：把此模板仓库 fork 之后 clone 到机器人文件夹下的 addons/plugins/ 目录下，然后用 Pycharm/VSC 等工具打开可获更棒的编程体验（自动补全等）
-'''
-
-
-class HelloWorldPlugin:
-    """
-    初始化函数, 可以选择直接pass
-    """
-
-    def __init__(self) -> None:
-        # 复制旧配置文件到 data 目录下。
-        if os.path.exists("keyword.json"):
-            shutil.move("keyword.json", "data/keyword.json")
-        self.keywords = {}
-        if os.path.exists("data/keyword.json"):
-            self.keywords = json.load(open("data/keyword.json", "r"))
-        else:
-            self.save_keyword()
-
-    """
-    机器人程序会调用此函数。
-    返回规范: bool: 插件是否响应该消息 (所有的消息均会调用每一个载入的插件, 如果不响应, 则应返回 False)
-             Tuple: Non e或者长度为 3 的元组。如果不响应, 返回 None； 如果响应, 第 1 个参数为指令是否调用成功, 第 2 个参数为返回的消息链列表, 第 3 个参数为指令名称
-    例子：一个名为"yuanshen"的插件；当接收到消息为“原神 可莉”, 如果不想要处理此消息，则返回False, None；如果想要处理，但是执行失败了，返回True, tuple([False, "请求失败。", "yuanshen"]) ；执行成功了，返回True, tuple([True, "结果文本", "yuanshen"])
-    """
-
-    def run(self, ame: AstrMessageEvent):
-        if ame.message_str == "helloworld":
-            return CommandResult(
-                hit=True,
-                success=True,
-                message_chain=[Plain("Hello World!!")],
-                command_name="helloworld"
-            )
-        if ame.message_str.startswith("/keyword") or ame.message_str.startswith("keyword"):
-            return self.handle_keyword_command(ame)
-
-        ret = self.check_keyword(ame.message_str)
-        if ret:
-            return ret
-
-        return CommandResult(
-            hit=False,
-            success=False,
-            message_chain=None,
-            command_name=None
-        )
-
-    def handle_keyword_command(self, ame: AstrMessageEvent):
-        l = ame.message_str.split(" ")
-
-        # 获取图片
-        image_url = ""
-        for comp in ame.message_obj.message:
-            if isinstance(comp, Image) and image_url == "":
-                if comp.url is None:
-                    image_url = comp.file
-                else:
-                    image_url = comp.url
-
-        command_result = CommandResult(
-            hit=True,
-            success=False,
-            message_chain=None,
-            command_name="keyword"
-        )
-        if len(l) == 1 or (len(l) == 2 and image_url == ""):
-            ret = """【设置关键词回复】
-示例：
-1. keyword <触发词> <回复词>
-keyword hi 你好
-发送 hi 回复你好
-* 回复词支持图片
-
-2. keyword d <触发词>
-keyword d hi
-删除 hi 触发词产生的回复"""
-            command_result.success = True
-            command_result.message_chain = [Plain(ret)]
-            return command_result
-        elif len(l) == 3 and l[1] == "d":
-            if l[2] not in self.keywords:
-                command_result.message_chain = [Plain(f"关键词 {l[2]} 不存在")]
-                return command_result
-            self.keywords.pop(l[2])
-            self.save_keyword()
-            command_result.success = True
-            command_result.message_chain = [Plain("删除成功")]
-            return command_result
-        else:
-            self.keywords[l[1]] = {
-                "plain_text": " ".join(l[2:]),
-                "image_url": image_url
-            }
-            self.save_keyword()
-            command_result.success = True
-            command_result.message_chain = [Plain("设置成功")]
-            return command_result
-
-    def save_keyword(self):
-        json.dump(self.keywords, open(
-            "data/keyword.json", "w"), ensure_ascii=False)
-
-    def check_keyword(self, message_str: str):
-        for k in self.keywords:
-            if message_str == k:
-                plain_text = ""
-                if 'plain_text' in self.keywords[k]:
-                    plain_text = self.keywords[k]['plain_text']
-                else:
-                    plain_text = self.keywords[k]
-                image_url = ""
-                if 'image_url' in self.keywords[k]:
-                    image_url = self.keywords[k]['image_url']
-                if image_url != "":
-                    res = [Plain(plain_text), Image.fromURL(image_url)]
-                    return CommandResult(
-                        hit=True,
-                        success=True,
-                        message_chain=res,
-                        command_name="keyword"
-                    )
-                return CommandResult(
-                    hit=True,
-                    success=True,
-                    message_chain=[Plain(plain_text)],
-                    command_name="keyword"
-                )
-
-    """
-    插件元信息。
-    当用户输入 plugin v 插件名称 时，会调用此函数，返回帮助信息。
-    返回参数要求(必填)：dict{
-        "name": str, # 插件名称
-        "desc": str, # 插件简短描述
-        "help": str, # 插件帮助信息
-        "version": str, # 插件版本
-        "author": str, # 插件作者
-        "repo": str, # 插件仓库地址 [ 可选 ]
-        "homepage": str, # 插件主页  [ 可选 ]
-    }
-    """
-
-    def info(self):
-        return {
-            "name": "helloworld",
-            "desc": "这是 AstrBot 的默认插件，支持关键词回复。",
-            "help": "输入 /keyword 查看关键词回复帮助。",
-            "version": "v1.3",
-            "author": "Soulter"
-        }

astrbot/__init__.py

@@ -0,0 +1,3 @@
+from .core.log import LogManager
+
+logger = LogManager.GetLogger(log_name="astrbot")

astrbot/api/__init__.py

@@ -0,0 +1,7 @@
+from astrbot.core.config.astrbot_config import AstrBotConfig
+from astrbot import logger
+from astrbot.core import html_renderer
+from astrbot.core import sp
+from astrbot.core.star.register import register_llm_tool as llm_tool
+
+__all__ = ["AstrBotConfig", "logger", "html_renderer", "llm_tool", "sp"]

astrbot/api/all.py

@@ -0,0 +1,53 @@
+from astrbot.core.config.astrbot_config import AstrBotConfig
+from astrbot import logger
+from astrbot.core import html_renderer
+from astrbot.core.star.register import register_llm_tool as llm_tool
+
+# event
+from astrbot.core.message.message_event_result import (
+    MessageEventResult,
+    MessageChain,
+    CommandResult,
+    EventResultType,
+)
+from astrbot.core.platform import AstrMessageEvent
+
+# star register
+from astrbot.core.star.register import (
+    register_command as command,
+    register_command_group as command_group,
+    register_event_message_type as event_message_type,
+    register_regex as regex,
+    register_platform_adapter_type as platform_adapter_type,
+)
+from astrbot.core.star.filter.event_message_type import (
+    EventMessageTypeFilter,
+    EventMessageType,
+)
+from astrbot.core.star.filter.platform_adapter_type import (
+    PlatformAdapterTypeFilter,
+    PlatformAdapterType,
+)
+from astrbot.core.star.register import (
+    register_star as register,  # 注册插件（Star）
+)
+from astrbot.core.star import Context, Star
+from astrbot.core.star.config import *
+
+
+# provider
+from astrbot.core.provider import Provider, Personality, ProviderMetaData
+
+# platform
+from astrbot.core.platform import (
+    AstrMessageEvent,
+    Platform,
+    AstrBotMessage,
+    MessageMember,
+    MessageType,
+    PlatformMetadata,
+)
+
+from astrbot.core.platform.register import register_platform_adapter
+
+from .message_components import *

astrbot/api/event/__init__.py

@@ -0,0 +1,18 @@
+from astrbot.core.message.message_event_result import (
+    MessageEventResult,
+    MessageChain,
+    CommandResult,
+    EventResultType,
+    ResultContentType,
+)
+
+from astrbot.core.platform import AstrMessageEvent
+
+__all__ = [
+    "MessageEventResult",
+    "MessageChain",
+    "CommandResult",
+    "EventResultType",
+    "AstrMessageEvent",
+    "ResultContentType",
+]

astrbot/api/event/filter/__init__.py

@@ -0,0 +1,49 @@
+from astrbot.core.star.register import (
+    register_command as command,
+    register_command_group as command_group,
+    register_event_message_type as event_message_type,
+    register_regex as regex,
+    register_platform_adapter_type as platform_adapter_type,
+    register_permission_type as permission_type,
+    register_custom_filter as custom_filter,
+    register_on_astrbot_loaded as on_astrbot_loaded,
+    register_on_llm_request as on_llm_request,
+    register_on_llm_response as on_llm_response,
+    register_llm_tool as llm_tool,
+    register_on_decorating_result as on_decorating_result,
+    register_after_message_sent as after_message_sent,
+)
+
+from astrbot.core.star.filter.event_message_type import (
+    EventMessageTypeFilter,
+    EventMessageType,
+)
+from astrbot.core.star.filter.platform_adapter_type import (
+    PlatformAdapterTypeFilter,
+    PlatformAdapterType,
+)
+from astrbot.core.star.filter.permission import PermissionTypeFilter, PermissionType
+from astrbot.core.star.filter.custom_filter import CustomFilter
+
+__all__ = [
+    "command",
+    "command_group",
+    "event_message_type",
+    "regex",
+    "platform_adapter_type",
+    "permission_type",
+    "EventMessageTypeFilter",
+    "EventMessageType",
+    "PlatformAdapterTypeFilter",
+    "PlatformAdapterType",
+    "PermissionTypeFilter",
+    "CustomFilter",
+    "custom_filter",
+    "PermissionType",
+    "on_astrbot_loaded",
+    "on_llm_request",
+    "llm_tool",
+    "on_decorating_result",
+    "after_message_sent",
+    "on_llm_response",
+]

astrbot/api/message_components.py

@@ -0,0 +1 @@
+from astrbot.core.message.components import *

astrbot/api/platform/__init__.py

@@ -0,0 +1,23 @@
+from astrbot.core.platform import (
+    AstrMessageEvent,
+    Platform,
+    AstrBotMessage,
+    MessageMember,
+    MessageType,
+    PlatformMetadata,
+    Group,
+)
+
+from astrbot.core.platform.register import register_platform_adapter
+from astrbot.core.message.components import *
+
+__all__ = [
+    "AstrMessageEvent",
+    "Platform",
+    "AstrBotMessage",
+    "MessageMember",
+    "MessageType",
+    "PlatformMetadata",
+    "register_platform_adapter",
+    "Group",
+]

astrbot/api/provider/__init__.py

@@ -0,0 +1,17 @@
+from astrbot.core.provider import Provider, STTProvider, Personality
+from astrbot.core.provider.entities import (
+    ProviderRequest,
+    ProviderType,
+    ProviderMetaData,
+    LLMResponse,
+)
+
+__all__ = [
+    "Provider",
+    "STTProvider",
+    "Personality",
+    "ProviderRequest",
+    "ProviderType",
+    "ProviderMetaData",
+    "LLMResponse",
+]

astrbot/api/star/__init__.py

@@ -0,0 +1,8 @@
+from astrbot.core.star.register import (
+    register_star as register,  # 注册插件（Star）
+)
+
+from astrbot.core.star import Context, Star, StarTools
+from astrbot.core.star.config import *
+
+__all__ = ["register", "Context", "Star", "StarTools"]

astrbot/api/util/__init__.py

@@ -0,0 +1,7 @@
+from astrbot.core.utils.session_waiter import (
+    SessionWaiter,
+    SessionController,
+    session_waiter,
+)
+
+__all__ = ["SessionWaiter", "SessionController", "session_waiter"]

astrbot/cli/__main__.py

@@ -0,0 +1,238 @@
+import asyncio
+import os
+import shutil
+import sys
+import click
+from pathlib import Path
+from astrbot.core.config.default import VERSION
+
+
+logo_tmpl = r"""
+     ___           _______.___________..______      .______     ______   .___________.
+    /   \         /       |           ||   _  \     |   _  \   /  __  \  |           |
+   /  ^  \       |   (----`---|  |----`|  |_)  |    |  |_)  | |  |  |  | `---|  |----`
+  /  /_\  \       \   \       |  |     |      /     |   _  <  |  |  |  |     |  |
+ /  _____  \  .----)   |      |  |     |  |\  \----.|  |_)  | |  `--'  |     |  |
+/__/     \__\ |_______/       |__|     | _| `._____||______/   \______/      |__|
+
+"""
+
+
+# utils
+def _get_astrbot_root(path: str | None) -> Path:
+    """获取astrbot根目录"""
+    match path:
+        case None:
+            match ASTRBOT_ROOT := os.getenv("ASTRBOT_ROOT"):
+                case None:
+                    astrbot_root = Path.cwd() / "data"
+                case _:
+                    astrbot_root = Path(ASTRBOT_ROOT).resolve()
+        case str():
+            astrbot_root = Path(path).resolve()
+
+    dot_astrbot = astrbot_root / ".astrbot"
+    if not dot_astrbot.exists():
+        if click.confirm(
+            f"运行前必须先执行初始化！请检查当前目录是否正确，回车以继续: {astrbot_root}",
+            default=True,
+            abort=True,
+        ):
+            dot_astrbot.touch()
+            astrbot_root.mkdir(parents=True, exist_ok=True)
+            click.echo(f"Created {dot_astrbot}")
+
+    return astrbot_root
+
+
+# 通过类型来验证先后，必须先获取 Path 对象才能对该目录进行检查
+def _check_astrbot_root(astrbot_root: Path) -> None:
+    """验证"""
+    dot_astrbot = astrbot_root / ".astrbot"
+    if not astrbot_root.exists():
+        click.echo(f"AstrBot root directory does not exist: {astrbot_root}")
+        click.echo("Please run 'astrbot init' to create the directory.")
+        sys.exit(1)
+    else:
+        click.echo(f"AstrBot root directory exists: {astrbot_root}")
+        if not dot_astrbot.exists():
+            click.echo(
+                "如果你确认这是 Astrbot root directory, 你需要在当前目录下创建一个 .astrbot 文件标记该目录为 AstrBot 的数据目录。"
+            )
+            if click.confirm(
+                f"请检查当前目录是否正确，确认正确请回车: {astrbot_root}",
+                default=True,
+                abort=True,
+            ):
+                dot_astrbot.touch()
+                click.echo(f"Created {dot_astrbot}")
+        else:
+            click.echo(f"Welcome back! AstrBot root directory: {astrbot_root}")
+
+
+async def _check_dashboard(astrbot_root: Path) -> None:
+    """检查是否安装了dashboard"""
+    try:
+        from ..core.utils.io import get_dashboard_version, download_dashboard
+    except ImportError:
+        from astrbot.core.utils.io import get_dashboard_version, download_dashboard
+
+    try:
+        # 添加 create=True 参数以确保在初始化时不会抛出异常
+        dashboard_version = await get_dashboard_version()
+        match dashboard_version:
+            case None:
+                click.echo("未安装管理面板")
+                if click.confirm(
+                    "是否安装管理面板？",
+                    default=True,
+                    abort=True,
+                ):
+                    click.echo("正在安装管理面板...")
+                    # 确保使用 create=True 参数
+                    await download_dashboard(
+                        path="data/dashboard.zip", extract_path=str(astrbot_root)
+                    )
+                    click.echo("管理面板安装完成")
+
+            case str():
+                if dashboard_version == f"v{VERSION}":
+                    click.echo("无需更新")
+                else:
+                    try:
+                        version = dashboard_version.split("v")[1]
+                        click.echo(f"管理面板版本: {version}")
+                        # 确保使用 create=True 参数
+                        await download_dashboard(
+                            path="data/dashboard.zip", extract_path=str(astrbot_root)
+                        )
+                    except Exception as e:
+                        click.echo(f"下载管理面板失败: {e}")
+                        return
+    except FileNotFoundError:
+        click.echo("初始化管理面板目录...")
+        # 初始化模式下，下载到指定位置
+        try:
+            await download_dashboard(
+                path=str(astrbot_root / "dashboard.zip"), extract_path=str(astrbot_root)
+            )
+            click.echo("管理面板初始化完成")
+        except Exception as e:
+            click.echo(f"下载管理面板失败: {e}")
+            return
+
+
+@click.group(name="astrbot")
+def cli() -> None:
+    """The AstrBot CLI"""
+    click.echo(logo_tmpl)
+    click.echo("Welcome to AstrBot CLI!")
+    click.echo(f"AstrBot version: {VERSION}")
+
+
+# region init
+@cli.command()
+@click.option("--path", "-p", help="AstrBot 数据目录")
+@click.option("--force", "-f", is_flag=True, help="强制初始化")
+def init(path: str | None, force: bool) -> None:
+    """Initialize AstrBot"""
+    click.echo("Initializing AstrBot...")
+    astrbot_root = _get_astrbot_root(path)
+    if force:
+        if click.confirm(
+            "强制初始化会删除当前目录下的所有文件，是否继续？",
+            default=False,
+            abort=True,
+        ):
+            click.echo("正在删除当前目录下的所有文件...")
+            shutil.rmtree(astrbot_root, ignore_errors=True)
+
+    _check_astrbot_root(astrbot_root)
+
+    click.echo(f"AstrBot root directory: {astrbot_root}")
+
+    if not astrbot_root.exists():
+        # 创建目录
+        astrbot_root.mkdir(parents=True, exist_ok=True)
+        click.echo(f"Created directory: {astrbot_root}")
+    else:
+        click.echo(f"Directory already exists: {astrbot_root}")
+
+    config_path: Path = astrbot_root / "config"
+    plugins_path: Path = astrbot_root / "plugins"
+    temp_path: Path = astrbot_root / "temp"
+    config_path.mkdir(parents=True, exist_ok=True)
+    plugins_path.mkdir(parents=True, exist_ok=True)
+    temp_path.mkdir(parents=True, exist_ok=True)
+
+    click.echo(f"Created directories: {config_path}, {plugins_path}, {temp_path}")
+
+    # 检查是否安装了dashboard
+    asyncio.run(_check_dashboard(astrbot_root))
+
+
+# region run
+@cli.command()
+@click.option("--path", "-p", help="AstrBot 数据目录")
+def run(path: str | None = None) -> None:
+    """Run AstrBot"""
+    # 解析为绝对路径
+    try:
+        from ..core.log import LogBroker
+        from ..core import db_helper
+        from ..core.initial_loader import InitialLoader
+    except ImportError:
+        from astrbot.core.log import LogBroker
+        from astrbot.core import db_helper
+        from astrbot.core.initial_loader import InitialLoader
+
+    astrbot_root = _get_astrbot_root(path)
+
+    _check_astrbot_root(astrbot_root)
+
+    asyncio.run(_check_dashboard(astrbot_root))
+
+    log_broker = LogBroker()
+    db = db_helper
+
+    core_lifecycle = InitialLoader(db, log_broker)
+    try:
+        asyncio.run(core_lifecycle.start())
+    except KeyboardInterrupt:
+        click.echo("接收到退出信号，正在关闭 AstrBot...")
+    except Exception as e:
+        click.echo(f"运行时出现错误: {e}")
+
+
+# region Basic
+@cli.command(name="version")
+def version() -> None:
+    """Show the version of AstrBot"""
+    click.echo(f"AstrBot version: {VERSION}")
+
+
+@cli.command()
+@click.argument("command_name", required=False, type=str)
+def help(command_name: str | None) -> None:
+    """Show help information for commands
+
+    If COMMAND_NAME is provided, show detailed help for that command.
+    Otherwise, show general help information.
+    """
+    ctx = click.get_current_context()
+    if command_name:
+        # 查找指定命令
+        command = cli.get_command(ctx, command_name)
+        if command:
+            # 显示特定命令的帮助信息
+            click.echo(command.get_help(ctx))
+        else:
+            click.echo(f"Unknown command: {command_name}")
+            sys.exit(1)
+    else:
+        # 显示通用帮助信息
+        click.echo(cli.get_help(ctx))
+
+
+if __name__ == "__main__":
+    cli()

astrbot/core.py

@@ -1,491 +0,0 @@
-import re
-import threading
-import asyncio
-import time
-import util.unfit_words as uw
-import os
-import sys
-import traceback
-
-import util.agent.web_searcher as web_searcher
-import util.plugin_util as putil
-
-from nakuru.entities.components import Plain, At, Image
-
-from addons.baidu_aip_judge import BaiduJudge
-from model.provider.provider import Provider
-from model.command.command import Command
-from util import general_utils as gu
-from util.general_utils import upload, run_monitor
-from util.cmd_config import CmdConfig as cc
-from util.cmd_config import init_astrbot_config_items
-from type.types import GlobalObject
-from type.register import *
-from type.message import AstrBotMessage
-from addons.dashboard.helper import DashBoardHelper
-from addons.dashboard.server import DashBoardData
-from persist.session import dbConn
-from model.platform._message_result import MessageResult
-from SparkleLogging.utils.core import LogManager
-from logging import Logger
-
-logger: Logger = LogManager.GetLogger(log_name='astrbot-core')
-
-# 用户发言频率
-user_frequency = {}
-# 时间默认值
-frequency_time = 60
-# 计数默认值
-frequency_count = 10
-
-# 版本
-version = '3.1.13'
-
-# 语言模型
-OPENAI_OFFICIAL = 'openai_official'
-NONE_LLM = 'none_llm'
-chosen_provider = None
-# 语言模型对象
-llm_instance: dict[str, Provider] = {}
-llm_command_instance: dict[str, Command] = {}
-llm_wake_prefix = ""
-
-# 百度内容审核实例
-baidu_judge = None
-
-# CLI
-PLATFORM_CLI = 'cli'
-
-init_astrbot_config_items()
-
-# 全局对象
-_global_object: GlobalObject = None
-
-# 语言模型选择
-
-
-def privider_chooser(cfg):
-    l = []
-    if 'openai' in cfg and len(cfg['openai']['key']) > 0 and cfg['openai']['key'][0] is not None:
-        l.append('openai_official')
-    return l
-
-
-'''
-初始化机器人
-'''
-
-
-def init():
-    global llm_instance, llm_command_instance
-    global baidu_judge, chosen_provider
-    global frequency_count, frequency_time
-    global _global_object
-
-    # 迁移旧配置
-    gu.try_migrate_config()
-    # 使用新配置
-    cfg = cc.get_all()
-
-    _event_loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(_event_loop)
-
-    # 初始化 global_object
-    _global_object = GlobalObject()
-    _global_object.version = version
-    _global_object.base_config = cfg
-    logger.info("AstrBot v"+version)
-
-    if 'reply_prefix' in cfg:
-        # 适配旧版配置
-        if isinstance(cfg['reply_prefix'], dict):
-            _global_object.reply_prefix = ""
-            cfg['reply_prefix'] = ""
-            cc.put("reply_prefix", "")
-        else:
-            _global_object.reply_prefix = cfg['reply_prefix']
-    
-    default_personality_str = cc.get("default_personality_str", "")
-    if default_personality_str == "":
-        _global_object.default_personality = None
-    else:
-        _global_object.default_personality = {
-            "name": "default",
-            "prompt": default_personality_str,
-        }
-
-    # 语言模型提供商
-    logger.info("正在载入语言模型...")
-    prov = privider_chooser(cfg)
-    if OPENAI_OFFICIAL in prov:
-        logger.info("初始化：OpenAI官方")
-        if cfg['openai']['key'] is not None and cfg['openai']['key'] != [None]:
-            from model.provider.openai_official import ProviderOpenAIOfficial
-            from model.command.openai_official import CommandOpenAIOfficial
-            llm_instance[OPENAI_OFFICIAL] = ProviderOpenAIOfficial(
-                cfg['openai'])
-            llm_command_instance[OPENAI_OFFICIAL] = CommandOpenAIOfficial(
-                llm_instance[OPENAI_OFFICIAL], _global_object)
-            _global_object.llms.append(RegisteredLLM(
-                llm_name=OPENAI_OFFICIAL, llm_instance=llm_instance[OPENAI_OFFICIAL], origin="internal"))
-            chosen_provider = OPENAI_OFFICIAL
-
-            instance = llm_instance[OPENAI_OFFICIAL]
-            assert isinstance(instance, ProviderOpenAIOfficial)
-            instance.DEFAULT_PERSONALITY = _global_object.default_personality
-            instance.curr_personality = instance.DEFAULT_PERSONALITY
-
-    # 检查provider设置偏好
-    p = cc.get("chosen_provider", None)
-    if p is not None and p in llm_instance:
-        chosen_provider = p
-
-    # 百度内容审核
-    if 'baidu_aip' in cfg and 'enable' in cfg['baidu_aip'] and cfg['baidu_aip']['enable']:
-        try:
-            baidu_judge = BaiduJudge(cfg['baidu_aip'])
-            logger.info("百度内容审核初始化成功")
-        except BaseException as e:
-            logger.info("百度内容审核初始化失败")
-
-    threading.Thread(target=upload, args=(
-        _global_object, ), daemon=True).start()
-
-    # 得到发言频率配置
-    if 'limit' in cfg:
-        if 'count' in cfg['limit']:
-            frequency_count = cfg['limit']['count']
-        if 'time' in cfg['limit']:
-            frequency_time = cfg['limit']['time']
-
-    try:
-        if 'uniqueSessionMode' in cfg and cfg['uniqueSessionMode']:
-            _global_object.unique_session = True
-        else:
-            _global_object.unique_session = False
-    except BaseException as e:
-        logger.info("独立会话配置错误: "+str(e))
-
-    nick_qq = cc.get("nick_qq", None)
-    if nick_qq == None:
-        nick_qq = ("ai", "!", "！")
-    if isinstance(nick_qq, str):
-        nick_qq = (nick_qq,)
-    if isinstance(nick_qq, list):
-        nick_qq = tuple(nick_qq)
-    _global_object.nick = nick_qq
-
-    # 语言模型唤醒词
-    global llm_wake_prefix
-    llm_wake_prefix = cc.get("llm_wake_prefix", "")
-
-    logger.info("正在载入插件...")
-    # 加载插件
-    _command = Command(None, _global_object)
-    ok, err = putil.plugin_reload(_global_object.cached_plugins)
-    if ok:
-        logger.info(
-            f"成功载入 {len(_global_object.cached_plugins)} 个插件")
-    else:
-        logger.info(err)
-
-    if chosen_provider is None:
-        llm_command_instance[NONE_LLM] = _command
-        chosen_provider = NONE_LLM
-
-    logger.info("正在载入机器人消息平台")
-    # logger.info("提示：需要添加管理员 ID 才能使用 update/plugin 等指令)，可在可视化面板添加。（如已添加可忽略）")
-    platform_str = ""
-    # GOCQ
-    if 'gocqbot' in cfg and cfg['gocqbot']['enable']:
-        logger.info("启用 QQ_GOCQ 机器人消息平台")
-        threading.Thread(target=run_gocq_bot, args=(
-            cfg, _global_object), daemon=True).start()
-        platform_str += "QQ_GOCQ,"
-
-    # QQ频道
-    if 'qqbot' in cfg and cfg['qqbot']['enable'] and cfg['qqbot']['appid'] != None:
-        logger.info("启用 QQ_OFFICIAL 机器人消息平台")
-        threading.Thread(target=run_qqchan_bot, args=(
-            cfg, _global_object), daemon=True).start()
-        platform_str += "QQ_OFFICIAL,"
-
-    # 初始化dashboard
-    _global_object.dashboard_data = DashBoardData(
-        stats={},
-        configs={},
-        logs={},
-        plugins=_global_object.cached_plugins,
-    )
-    dashboard_helper = DashBoardHelper(_global_object, config=cc.get_all())
-    dashboard_thread = threading.Thread(
-        target=dashboard_helper.run, daemon=True)
-    dashboard_thread.start()
-
-    # 运行 monitor
-    threading.Thread(target=run_monitor, args=(
-        _global_object,), daemon=True).start()
-
-    logger.info(
-        "如果有任何问题, 请在 https://github.com/Soulter/AstrBot 上提交 issue 或加群 322154837。")
-    logger.info("请给 https://github.com/Soulter/AstrBot 点个 star。")
-    if platform_str == '':
-        platform_str = "(未启动任何平台，请前往面板添加)"
-    logger.info(f"🎉 项目启动完成")
-
-    dashboard_thread.join()
-
-
-'''
-运行 QQ_OFFICIAL 机器人
-'''
-
-
-def run_qqchan_bot(cfg: dict, global_object: GlobalObject):
-    try:
-        from model.platform.qq_official import QQOfficial
-        qqchannel_bot = QQOfficial(
-            cfg=cfg, message_handler=oper_msg, global_object=global_object)
-        global_object.platforms.append(RegisteredPlatform(
-            platform_name="qqchan", platform_instance=qqchannel_bot, origin="internal"))
-        qqchannel_bot.run()
-    except BaseException as e:
-        logger.error("启动 QQ 频道机器人时出现错误, 原因如下: " + str(e))
-        logger.error(r"如果您是初次启动，请前往可视化面板填写配置。详情请看：https://astrbot.soulter.top/center/。")
-
-
-'''
-运行 QQ_GOCQ 机器人
-'''
-
-
-def run_gocq_bot(cfg: dict, _global_object: GlobalObject):
-    from model.platform.qq_gocq import QQGOCQ
-
-    noticed = False
-    host = cc.get("gocq_host", "127.0.0.1")
-    port = cc.get("gocq_websocket_port", 6700)
-    http_port = cc.get("gocq_http_port", 5700)
-    logger.info(
-        f"正在检查连接...host: {host}, ws port: {port}, http port: {http_port}")
-    while True:
-        if not gu.port_checker(port=port, host=host) or not gu.port_checker(port=http_port, host=host):
-            if not noticed:
-                noticed = True
-                logger.warning(
-                    f"连接到{host}:{port}（或{http_port}）失败。程序会每隔 5s 自动重试。")
-            time.sleep(5)
-        else:
-            logger.info("已连接到 gocq。")
-            break
-    try:
-        qq_gocq = QQGOCQ(cfg=cfg, message_handler=oper_msg,
-                         global_object=_global_object)
-        _global_object.platforms.append(RegisteredPlatform(
-            platform_name="gocq", platform_instance=qq_gocq, origin="internal"))
-        qq_gocq.run()
-    except BaseException as e:
-        input("启动QQ机器人出现错误"+str(e))
-
-
-'''
-检查发言频率
-'''
-
-
-def check_frequency(id) -> bool:
-    ts = int(time.time())
-    if id in user_frequency:
-        if ts-user_frequency[id]['time'] > frequency_time:
-            user_frequency[id]['time'] = ts
-            user_frequency[id]['count'] = 1
-            return True
-        else:
-            if user_frequency[id]['count'] >= frequency_count:
-                return False
-            else:
-                user_frequency[id]['count'] += 1
-                return True
-    else:
-        t = {'time': ts, 'count': 1}
-        user_frequency[id] = t
-        return True
-
-
-async def record_message(platform: str, session_id: str):
-    # TODO: 这里会非常吃资源。然而 sqlite3 不支持多线程，所以暂时这样写。
-    curr_ts = int(time.time())
-    db_inst = dbConn()
-    db_inst.increment_stat_session(platform, session_id, 1)
-    db_inst.increment_stat_message(curr_ts, 1)
-    db_inst.increment_stat_platform(curr_ts, platform, 1)
-    _global_object.cnt_total += 1
-
-
-async def oper_msg(message: AstrBotMessage,
-                   session_id: str,
-                   role: str = 'member',
-                   platform: str = None,
-                   ) -> MessageResult:
-    """
-    处理消息。
-    message: 消息对象
-    session_id: 该消息源的唯一识别号
-    role: member | admin
-    platform: str 所注册的平台的名称。如果没有注册，将抛出一个异常。
-    """
-    global chosen_provider, _global_object
-    message_str = ''
-    session_id = session_id
-    role = role
-    hit = False  # 是否命中指令
-    command_result = ()  # 调用指令返回的结果
-
-    # 获取平台实例
-    reg_platform: RegisteredPlatform = None
-    for p in _global_object.platforms:
-        if p.platform_name == platform:
-            reg_platform = p
-            break
-    if not reg_platform:
-        raise Exception(f"未找到平台 {platform} 的实例。")
-
-    # 统计数据，如频道消息量
-    await record_message(platform, session_id)
-
-    for i in message.message:
-        if isinstance(i, Plain):
-            message_str += i.text.strip()
-    if message_str == "":
-        return MessageResult("Hi~")
-
-    # 检查发言频率
-    if not check_frequency(message.sender.user_id):
-        return MessageResult(f'你的发言超过频率限制(╯▔皿▔)╯。\n管理员设置{frequency_time}秒内只能提问{frequency_count}次。')
-
-    # 检查是否是更换语言模型的请求
-    temp_switch = ""
-    if message_str.startswith('/gpt'):
-        target = chosen_provider
-        if message_str.startswith('/gpt'):
-            target = OPENAI_OFFICIAL
-        l = message_str.split(' ')
-        if len(l) > 1 and l[1] != "":
-            # 临时对话模式，先记录下之前的语言模型，回答完毕后再切回
-            temp_switch = chosen_provider
-            chosen_provider = target
-            message_str = l[1]
-        else:
-            chosen_provider = target
-            cc.put("chosen_provider", chosen_provider)
-            return MessageResult(f"已切换至【{chosen_provider}】")
-
-    llm_result_str = ""
-
-    # check commands and plugins
-    message_str_no_wake_prefix = message_str
-    for wake_prefix in _global_object.nick: # nick: tuple
-        if message_str.startswith(wake_prefix):
-            message_str_no_wake_prefix = message_str.removeprefix(wake_prefix)
-            break
-    hit, command_result = await llm_command_instance[chosen_provider].check_command(
-        message_str_no_wake_prefix,
-        session_id,
-        role,
-        reg_platform,
-        message,
-    )
-
-    # 没触发指令
-    if not hit:
-        # 关键词拦截
-        for i in uw.unfit_words_q:
-            matches = re.match(i, message_str.strip(), re.I | re.M)
-            if matches:
-                return MessageResult(f"你的提问得到的回复未通过【默认关键词拦截】服务, 不予回复。")
-        if baidu_judge != None:
-            check, msg = await asyncio.to_thread(baidu_judge.judge, message_str)
-            if not check:
-                return MessageResult(f"你的提问得到的回复未通过【百度AI内容审核】服务, 不予回复。\n\n{msg}")
-        if chosen_provider == NONE_LLM:
-            logger.info("一条消息由于 Bot 未启动任何语言模型并且未触发指令而将被忽略。")
-            return
-        try:
-            if llm_wake_prefix != "" and not message_str.startswith(llm_wake_prefix):
-                return
-            # check image url
-            image_url = None
-            for comp in message.message:
-                if isinstance(comp, Image):
-                    if comp.url is None:
-                        image_url = comp.file
-                        break
-                    else:
-                        image_url = comp.url
-                        break
-            # web search keyword
-            web_sch_flag = False
-            if message_str.startswith("ws ") and message_str != "ws ":
-                message_str = message_str[3:]
-                web_sch_flag = True
-            else:
-                message_str += " " + cc.get("llm_env_prompt", "")
-            if chosen_provider == OPENAI_OFFICIAL:
-                if _global_object.web_search or web_sch_flag:
-                    official_fc = chosen_provider == OPENAI_OFFICIAL
-                    llm_result_str = await web_searcher.web_search(message_str, llm_instance[chosen_provider], session_id, official_fc)
-                else:
-                    llm_result_str = await llm_instance[chosen_provider].text_chat(message_str, session_id, image_url)
-
-            llm_result_str = _global_object.reply_prefix + llm_result_str
-        except BaseException as e:
-            logger.error(f"调用异常：{traceback.format_exc()}")
-            return MessageResult(f"调用异常。详细原因：{str(e)}")
-
-    # 切换回原来的语言模型
-    if temp_switch != "":
-        chosen_provider = temp_switch
-
-    if hit:
-        # 有指令或者插件触发
-        # command_result 是一个元组：(指令调用是否成功, 指令返回的文本结果, 指令类型)
-        if command_result == None:
-            return
-        command = command_result[2]
-
-        if command == "update latest r":
-            def update_restart():
-                py = sys.executable
-                os.execl(py, py, *sys.argv)
-            return MessageResult(command_result[1] + "\n\n即将自动重启。", callback=update_restart)
-
-        if not command_result[0]:
-            return MessageResult(f"指令调用错误: \n{str(command_result[1])}")
-
-        # 画图指令
-        if command == 'draw':
-            # 保存到本地
-            path = await gu.download_image_by_url(command_result[1])
-            return MessageResult([Image.fromFileSystem(path)])
-        # 其他指令
-        else:
-            try:
-                return MessageResult(command_result[1])
-            except BaseException as e:
-                return MessageResult(f"回复消息出错: {str(e)}")
-        return
-
-    # 敏感过滤
-    # 过滤不合适的词
-    for i in uw.unfit_words:
-        llm_result_str = re.sub(i, "***", llm_result_str)
-    # 百度内容审核服务二次审核
-    if baidu_judge != None:
-        check, msg = await asyncio.to_thread(baidu_judge.judge, llm_result_str)
-        if not check:
-            return MessageResult(f"你的提问得到的回复【百度内容审核】未通过，不予回复。\n\n{msg}")
-    # 发送信息
-    try:
-        return MessageResult(llm_result_str)
-    except BaseException as e:
-        logger.info("回复消息错误: \n"+str(e))

astrbot/core/__init__.py

@@ -0,0 +1,33 @@
+import os
+import asyncio
+from .log import LogManager, LogBroker  # noqa
+from astrbot.core.utils.t2i.renderer import HtmlRenderer
+from astrbot.core.utils.shared_preferences import SharedPreferences
+from astrbot.core.utils.pip_installer import PipInstaller
+from astrbot.core.db.sqlite import SQLiteDatabase
+from astrbot.core.config.default import DB_PATH
+from astrbot.core.config import AstrBotConfig
+
+# 初始化数据存储文件夹
+os.makedirs("data", exist_ok=True)
+
+astrbot_config = AstrBotConfig()
+t2i_base_url = astrbot_config.get("t2i_endpoint", "https://t2i.soulter.top/text2img")
+html_renderer = HtmlRenderer(t2i_base_url)
+logger = LogManager.GetLogger(log_name="astrbot")
+
+if os.environ.get("TESTING", ""):
+    logger.setLevel("DEBUG")
+
+db_helper = SQLiteDatabase(DB_PATH)
+sp = (
+    SharedPreferences()
+)  # 简单的偏好设置存储, 这里后续应该存储到数据库中, 一些部分可以存储到配置中
+pip_installer = PipInstaller(
+    astrbot_config.get("pip_install_arg", ""),
+    astrbot_config.get("pypi_index_url", None),
+)
+web_chat_queue = asyncio.Queue(maxsize=32)
+web_chat_back_queue = asyncio.Queue(maxsize=32)
+WEBUI_SK = "Advanced_System_for_Text_Response_and_Bot_Operations_Tool"
+DEMO_MODE = os.getenv("DEMO_MODE", False)

astrbot/core/config/__init__.py

@@ -0,0 +1,9 @@
+from .default import DEFAULT_CONFIG, VERSION, DB_PATH
+from .astrbot_config import *
+
+__all__ = [
+    "DEFAULT_CONFIG",
+    "VERSION",
+    "DB_PATH",
+    "AstrBotConfig",
+]

astrbot/core/config/astrbot_config.py

@@ -0,0 +1,132 @@
+import os
+import json
+import logging
+import enum
+from .default import DEFAULT_CONFIG, DEFAULT_VALUE_MAP
+from typing import Dict
+
+ASTRBOT_CONFIG_PATH = "data/cmd_config.json"
+logger = logging.getLogger("astrbot")
+
+
+class RateLimitStrategy(enum.Enum):
+    STALL = "stall"
+    DISCARD = "discard"
+
+
+class AstrBotConfig(dict):
+    """从配置文件中加载的配置，支持直接通过点号操作符访问根配置项。
+
+    - 初始化时会将传入的 default_config 与配置文件进行比对，如果配置文件中缺少配置项则会自动插入默认值并进行一次写入操作。会递归检查配置项。
+    - 如果配置文件路径对应的文件不存在，则会自动创建并写入默认配置。
+    - 如果传入了 schema，将会通过 schema 解析出 default_config，此时传入的 default_config 会被忽略。
+    """
+
+    def __init__(
+        self,
+        config_path: str = ASTRBOT_CONFIG_PATH,
+        default_config: dict = DEFAULT_CONFIG,
+        schema: dict = None,
+    ):
+        super().__init__()
+
+        # 调用父类的 __setattr__ 方法，防止保存配置时将此属性写入配置文件
+        object.__setattr__(self, "config_path", config_path)
+        object.__setattr__(self, "default_config", default_config)
+        object.__setattr__(self, "schema", schema)
+
+        if schema:
+            default_config = self._config_schema_to_default_config(schema)
+
+        if not self.check_exist():
+            """不存在时载入默认配置"""
+            with open(config_path, "w", encoding="utf-8-sig") as f:
+                json.dump(default_config, f, indent=4, ensure_ascii=False)
+
+        with open(config_path, "r", encoding="utf-8-sig") as f:
+            conf_str = f.read()
+            if conf_str.startswith("/ufeff"):  # remove BOM
+                conf_str = conf_str.encode("utf8")[3:].decode("utf8")
+            conf = json.loads(conf_str)
+
+        # 检查配置完整性，并插入
+        has_new = self.check_config_integrity(default_config, conf)
+        self.update(conf)
+        if has_new:
+            self.save_config()
+
+        self.update(conf)
+
+    def _config_schema_to_default_config(self, schema: dict) -> dict:
+        """将 Schema 转换成 Config"""
+        conf = {}
+
+        def _parse_schema(schema: dict, conf: dict):
+            for k, v in schema.items():
+                if v["type"] not in DEFAULT_VALUE_MAP:
+                    raise TypeError(
+                        f"不受支持的配置类型 {v['type']}。支持的类型有：{DEFAULT_VALUE_MAP.keys()}"
+                    )
+                if "default" in v:
+                    default = v["default"]
+                else:
+                    default = DEFAULT_VALUE_MAP[v["type"]]
+
+                if v["type"] == "object":
+                    conf[k] = {}
+                    _parse_schema(v["items"], conf[k])
+                else:
+                    conf[k] = default
+
+        _parse_schema(schema, conf)
+
+        return conf
+
+    def check_config_integrity(self, refer_conf: Dict, conf: Dict, path=""):
+        """检查配置完整性，如果有新的配置项则返回 True"""
+        has_new = False
+        for key, value in refer_conf.items():
+            if key not in conf:
+                # logger.info(f"检查到配置项 {path + "." + key if path else key} 不存在，已插入默认值 {value}")
+                path_ = path + "." + key if path else key
+                logger.info(f"检查到配置项 {path_} 不存在，已插入默认值 {value}")
+                conf[key] = value
+                has_new = True
+            else:
+                if conf[key] is None:
+                    conf[key] = value
+                    has_new = True
+                elif isinstance(value, dict):
+                    has_new |= self.check_config_integrity(
+                        value, conf[key], path + "." + key if path else key
+                    )
+        return has_new
+
+    def save_config(self, replace_config: Dict = None):
+        """将配置写入文件
+
+        如果传入 replace_config，则将配置替换为 replace_config
+        """
+        if replace_config:
+            self.update(replace_config)
+        with open(self.config_path, "w", encoding="utf-8-sig") as f:
+            json.dump(self, f, indent=2, ensure_ascii=False)
+
+    def __getattr__(self, item):
+        try:
+            return self[item]
+        except KeyError:
+            return None
+
+    def __delattr__(self, key):
+        try:
+            del self[key]
+            self.save_config()
+        except KeyError:
+            raise AttributeError(f"没有找到 Key: '{key}'")
+
+    def __setattr__(self, key, value):
+        self[key] = value
+
+    def check_exist(self) -> bool:
+        return os.path.exists(self.config_path)

astrbot/core/conversation_mgr.py

@@ -0,0 +1,199 @@
+"""
+AstrBot 会话-对话管理器, 维护两个本地存储, 其中一个是 json 格式的shared_preferences, 另外一个是数据库
+
+在 AstrBot 中, 会话和对话是独立的, 会话用于标记对话窗口, 例如群聊"123456789"可以建立一个会话,
+在一个会话中可以建立多个对话, 并且支持对话的切换和删除
+"""
+
+import uuid
+import json
+import asyncio
+from astrbot.core import sp
+from typing import Dict, List
+from astrbot.core.db import BaseDatabase
+from astrbot.core.db.po import Conversation
+
+
+class ConversationManager:
+    """负责管理会话与 LLM 的对话，某个会话当前正在用哪个对话。"""
+
+    def __init__(self, db_helper: BaseDatabase):
+        # session_conversations 字典记录会话ID-对话ID 映射关系
+        self.session_conversations: Dict[str, str] = sp.get("session_conversation", {})
+        self.db = db_helper
+        self.save_interval = 60  # 每 60 秒保存一次
+        self._start_periodic_save()
+
+    def _start_periodic_save(self):
+        """启动定时保存任务"""
+        asyncio.create_task(self._periodic_save())
+
+    async def _periodic_save(self):
+        """定时保存会话对话映射关系到存储中"""
+        while True:
+            await asyncio.sleep(self.save_interval)
+            self._save_to_storage()
+
+    def _save_to_storage(self):
+        """保存会话对话映射关系到存储中"""
+        sp.put("session_conversation", self.session_conversations)
+
+    async def new_conversation(self, unified_msg_origin: str) -> str:
+        """新建对话，并将当前会话的对话转移到新对话
+
+        Args:
+            unified_msg_origin (str): 统一的消息来源字符串。格式为 platform_name:message_type:session_id
+        Returns:
+            conversation_id (str): 对话 ID, 是 uuid 格式的字符串
+        """
+        conversation_id = str(uuid.uuid4())
+        self.db.new_conversation(user_id=unified_msg_origin, cid=conversation_id)
+        self.session_conversations[unified_msg_origin] = conversation_id
+        sp.put("session_conversation", self.session_conversations)
+        return conversation_id
+
+    async def switch_conversation(self, unified_msg_origin: str, conversation_id: str):
+        """切换会话的对话
+
+        Args:
+            unified_msg_origin (str): 统一的消息来源字符串。格式为 platform_name:message_type:session_id
+            conversation_id (str): 对话 ID, 是 uuid 格式的字符串
+        """
+        self.session_conversations[unified_msg_origin] = conversation_id
+        sp.put("session_conversation", self.session_conversations)
+
+    async def delete_conversation(
+        self, unified_msg_origin: str, conversation_id: str = None
+    ):
+        """删除会话的对话，当 conversation_id 为 None 时删除会话当前的对话
+
+        Args:
+            unified_msg_origin (str): 统一的消息来源字符串。格式为 platform_name:message_type:session_id
+            conversation_id (str): 对话 ID, 是 uuid 格式的字符串
+        """
+        conversation_id = self.session_conversations.get(unified_msg_origin)
+        if conversation_id:
+            self.db.delete_conversation(user_id=unified_msg_origin, cid=conversation_id)
+            del self.session_conversations[unified_msg_origin]
+            sp.put("session_conversation", self.session_conversations)
+
+    async def get_curr_conversation_id(self, unified_msg_origin: str) -> str:
+        """获取会话当前的对话 ID
+
+        Args:
+            unified_msg_origin (str): 统一的消息来源字符串。格式为 platform_name:message_type:session_id
+        Returns:
+            conversation_id (str): 对话 ID, 是 uuid 格式的字符串
+        """
+        return self.session_conversations.get(unified_msg_origin, None)
+
+    async def get_conversation(
+        self, unified_msg_origin: str, conversation_id: str
+    ) -> Conversation:
+        """获取会话的对话
+
+        Args:
+            unified_msg_origin (str): 统一的消息来源字符串。格式为 platform_name:message_type:session_id
+            conversation_id (str): 对话 ID, 是 uuid 格式的字符串
+        Returns:
+            conversation (Conversation): 对话对象
+        """
+        return self.db.get_conversation_by_user_id(unified_msg_origin, conversation_id)
+
+    async def get_conversations(self, unified_msg_origin: str) -> List[Conversation]:
+        """获取会话的所有对话
+
+        Args:
+            unified_msg_origin (str): 统一的消息来源字符串。格式为 platform_name:message_type:session_id
+        Returns:
+            conversations (List[Conversation]): 对话对象列表
+        """
+        return self.db.get_conversations(unified_msg_origin)
+
+    async def update_conversation(
+        self, unified_msg_origin: str, conversation_id: str, history: List[Dict]
+    ):
+        """更新会话的对话
+
+        Args:
+            unified_msg_origin (str): 统一的消息来源字符串。格式为 platform_name:message_type:session_id
+            conversation_id (str): 对话 ID, 是 uuid 格式的字符串
+            history (List[Dict]): 对话历史记录, 是一个字典列表, 每个字典包含 role 和 content 字段
+        """
+        if conversation_id:
+            self.db.update_conversation(
+                user_id=unified_msg_origin,
+                cid=conversation_id,
+                history=json.dumps(history),
+            )
+
+    async def update_conversation_title(self, unified_msg_origin: str, title: str):
+        """更新会话的对话标题
+
+        Args:
+            unified_msg_origin (str): 统一的消息来源字符串。格式为 platform_name:message_type:session_id
+            title (str): 对话标题
+        """
+        conversation_id = self.session_conversations.get(unified_msg_origin)
+        if conversation_id:
+            self.db.update_conversation_title(
+                user_id=unified_msg_origin, cid=conversation_id, title=title
+            )
+
+    async def update_conversation_persona_id(
+        self, unified_msg_origin: str, persona_id: str
+    ):
+        """更新会话的对话 Persona ID
+
+        Args:
+            unified_msg_origin (str): 统一的消息来源字符串。格式为 platform_name:message_type:session_id
+            persona_id (str): 对话 Persona ID
+        """
+        conversation_id = self.session_conversations.get(unified_msg_origin)
+        if conversation_id:
+            self.db.update_conversation_persona_id(
+                user_id=unified_msg_origin, cid=conversation_id, persona_id=persona_id
+            )
+
+    async def get_human_readable_context(
+        self, unified_msg_origin, conversation_id, page=1, page_size=10
+    ):
+        """获取人类可读的上下文
+
+        Args:
+            unified_msg_origin (str): 统一的消息来源字符串。格式为 platform_name:message_type:session_id
+            conversation_id (str): 对话 ID, 是 uuid 格式的字符串
+            page (int): 页码
+            page_size (int): 每页大小
+        """
+        conversation = await self.get_conversation(unified_msg_origin, conversation_id)
+        history = json.loads(conversation.history)
+
+        contexts = []
+        temp_contexts = []
+        for record in history:
+            if record["role"] == "user":
+                temp_contexts.append(f"User: {record['content']}")
+            elif record["role"] == "assistant":
+                if "content" in record and record["content"]:
+                    temp_contexts.append(f"Assistant: {record['content']}")
+                elif "tool_calls" in record:
+                    tool_calls_str = json.dumps(
+                        record["tool_calls"], ensure_ascii=False
+                    )
+                    temp_contexts.append(f"Assistant: [函数调用] {tool_calls_str}")
+                else:
+                    temp_contexts.append("Assistant: [未知的内容]")
+                contexts.insert(0, temp_contexts)
+                temp_contexts = []
+
+        # 展平 contexts 列表
+        contexts = [item for sublist in contexts for item in sublist]
+
+        # 计算分页
+        paged_contexts = contexts[(page - 1) * page_size : page * page_size]
+        total_pages = len(contexts) // page_size
+        if len(contexts) % page_size != 0:
+            total_pages += 1
+
+        return paged_contexts, total_pages

astrbot/core/core_lifecycle.py

@@ -0,0 +1,231 @@
+"""
+Astrbot 核心生命周期管理类, 负责管理 AstrBot 的启动、停止、重启等操作。
+该类负责初始化各个组件, 包括 ProviderManager、PlatformManager、KnowledgeDBManager、ConversationManager、PluginManager、PipelineScheduler、EventBus等。
+该类还负责加载和执行插件, 以及处理事件总线的分发。
+
+工作流程:
+1. 初始化所有组件
+2. 启动事件总线和任务, 所有任务都在这里运行
+3. 执行启动完成事件钩子
+"""
+
+import traceback
+import asyncio
+import time
+import threading
+import os
+from .event_bus import EventBus
+from . import astrbot_config
+from asyncio import Queue
+from typing import List
+from astrbot.core.pipeline.scheduler import PipelineScheduler, PipelineContext
+from astrbot.core.star import PluginManager
+from astrbot.core.platform.manager import PlatformManager
+from astrbot.core.star.context import Context
+from astrbot.core.provider.manager import ProviderManager
+from astrbot.core import LogBroker
+from astrbot.core.db import BaseDatabase
+from astrbot.core.updator import AstrBotUpdator
+from astrbot.core import logger
+from astrbot.core.config.default import VERSION
+from astrbot.core.rag.knowledge_db_mgr import KnowledgeDBManager
+from astrbot.core.conversation_mgr import ConversationManager
+from astrbot.core.star.star_handler import star_handlers_registry, EventType
+from astrbot.core.star.star_handler import star_map
+
+
+class AstrBotCoreLifecycle:
+    """
+    AstrBot 核心生命周期管理类, 负责管理 AstrBot 的启动、停止、重启等操作。
+    该类负责初始化各个组件, 包括 ProviderManager、PlatformManager、KnowledgeDBManager、ConversationManager、PluginManager、PipelineScheduler、
+    EventBus 等。
+    该类还负责加载和执行插件, 以及处理事件总线的分发。
+    """
+
+    def __init__(self, log_broker: LogBroker, db: BaseDatabase):
+        self.log_broker = log_broker  # 初始化日志代理
+        self.astrbot_config = astrbot_config  # 初始化配置
+        self.db = db  # 初始化数据库
+
+        # 根据环境变量设置代理
+        os.environ["https_proxy"] = self.astrbot_config["http_proxy"]
+        os.environ["http_proxy"] = self.astrbot_config["http_proxy"]
+        os.environ["no_proxy"] = "localhost"
+
+    async def initialize(self):
+        """
+        初始化 AstrBot 核心生命周期管理类, 负责初始化各个组件, 包括 ProviderManager、PlatformManager、KnowledgeDBManager、ConversationManager、PluginManager、PipelineScheduler、EventBus、AstrBotUpdator等。
+        """
+
+        # 初始化日志代理
+        logger.info("AstrBot v" + VERSION)
+        if os.environ.get("TESTING", ""):
+            logger.setLevel("DEBUG")  # 测试模式下设置日志级别为 DEBUG
+        else:
+            logger.setLevel(self.astrbot_config["log_level"])  # 设置日志级别
+
+        # 初始化事件队列
+        self.event_queue = Queue()
+
+        # 初始化供应商管理器
+        self.provider_manager = ProviderManager(self.astrbot_config, self.db)
+
+        # 初始化平台管理器
+        self.platform_manager = PlatformManager(self.astrbot_config, self.event_queue)
+
+        # 初始化知识库管理器
+        self.knowledge_db_manager = KnowledgeDBManager(self.astrbot_config)
+
+        # 初始化对话管理器
+        self.conversation_manager = ConversationManager(self.db)
+
+        # 初始化提供给插件的上下文
+        self.star_context = Context(
+            self.event_queue,
+            self.astrbot_config,
+            self.db,
+            self.provider_manager,
+            self.platform_manager,
+            self.conversation_manager,
+            self.knowledge_db_manager,
+        )
+
+        # 初始化插件管理器
+        self.plugin_manager = PluginManager(self.star_context, self.astrbot_config)
+
+        # 扫描、注册插件、实例化插件类
+        await self.plugin_manager.reload()
+
+        # 根据配置实例化各个 Provider
+        await self.provider_manager.initialize()
+
+        # 初始化消息事件流水线调度器
+        self.pipeline_scheduler = PipelineScheduler(
+            PipelineContext(self.astrbot_config, self.plugin_manager)
+        )
+        await self.pipeline_scheduler.initialize()
+
+        # 初始化更新器
+        self.astrbot_updator = AstrBotUpdator()
+
+        # 初始化事件总线
+        self.event_bus = EventBus(self.event_queue, self.pipeline_scheduler)
+
+        # 记录启动时间
+        self.start_time = int(time.time())
+
+        # 初始化当前任务列表
+        self.curr_tasks: List[asyncio.Task] = []
+
+        # 根据配置实例化各个平台适配器
+        await self.platform_manager.initialize()
+
+        # 初始化关闭控制面板的事件
+        self.dashboard_shutdown_event = asyncio.Event()
+
+    def _load(self):
+        """加载事件总线和任务并初始化"""
+
+        # 创建一个异步任务来执行事件总线的 dispatch() 方法
+        # dispatch是一个无限循环的协程, 从事件队列中获取事件并处理
+        event_bus_task = asyncio.create_task(
+            self.event_bus.dispatch(), name="event_bus"
+        )
+
+        # 把插件中注册的所有协程函数注册到事件总线中并执行
+        extra_tasks = []
+        for task in self.star_context._register_tasks:
+            extra_tasks.append(asyncio.create_task(task, name=task.__name__))
+
+        tasks_ = [event_bus_task, *extra_tasks]
+        for task in tasks_:
+            self.curr_tasks.append(
+                asyncio.create_task(self._task_wrapper(task), name=task.get_name())
+            )
+
+        self.start_time = int(time.time())
+
+    async def _task_wrapper(self, task: asyncio.Task):
+        """异步任务包装器, 用于处理异步任务执行中出现的各种异常
+
+        Args:
+            task (asyncio.Task): 要执行的异步任务
+        """
+        try:
+            await task
+        except asyncio.CancelledError:
+            pass  # 任务被取消, 静默处理
+        except Exception as e:
+            # 获取完整的异常堆栈信息, 按行分割并记录到日志中
+            logger.error(f"------- 任务 {task.get_name()} 发生错误: {e}")
+            for line in traceback.format_exc().split("\n"):
+                logger.error(f"|    {line}")
+            logger.error("-------")
+
+    async def start(self):
+        """启动 AstrBot 核心生命周期管理类, 用load加载事件总线和任务并初始化, 执行启动完成事件钩子"""
+        self._load()
+        logger.info("AstrBot 启动完成。")
+
+        # 执行启动完成事件钩子
+        handlers = star_handlers_registry.get_handlers_by_event_type(
+            EventType.OnAstrBotLoadedEvent
+        )
+        for handler in handlers:
+            try:
+                logger.info(
+                    f"hook(on_astrbot_loaded) -> {star_map[handler.handler_module_path].name} - {handler.handler_name}"
+                )
+                await handler.handler()
+            except BaseException:
+                logger.error(traceback.format_exc())
+
+        # 同时运行curr_tasks中的所有任务
+        await asyncio.gather(*self.curr_tasks, return_exceptions=True)
+
+    async def stop(self):
+        """停止 AstrBot 核心生命周期管理类, 取消所有当前任务并终止各个管理器"""
+        # 请求停止所有正在运行的异步任务
+        for task in self.curr_tasks:
+            task.cancel()
+
+        for plugin in self.plugin_manager.context.get_all_stars():
+            try:
+                await self.plugin_manager._terminate_plugin(plugin)
+            except Exception as e:
+                logger.warning(traceback.format_exc())
+                logger.warning(
+                    f"插件 {plugin.name} 未被正常终止 {e!s}, 可能会导致资源泄露等问题。"
+                )
+
+        await self.provider_manager.terminate()
+        await self.platform_manager.terminate()
+        self.dashboard_shutdown_event.set()
+
+        # 再次遍历curr_tasks等待每个任务真正结束
+        for task in self.curr_tasks:
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+            except Exception as e:
+                logger.error(f"任务 {task.get_name()} 发生错误: {e}")
+
+    async def restart(self):
+        """重启 AstrBot 核心生命周期管理类, 终止各个管理器并重新加载平台实例"""
+        await self.provider_manager.terminate()
+        await self.platform_manager.terminate()
+        self.dashboard_shutdown_event.set()
+        threading.Thread(
+            target=self.astrbot_updator._reboot, name="restart", daemon=True
+        ).start()
+
+    def load_platform(self) -> List[asyncio.Task]:
+        """加载平台实例并返回所有平台实例的异步任务列表"""
+        tasks = []
+        platform_insts = self.platform_manager.get_insts()
+        for platform_inst in platform_insts:
+            tasks.append(
+                asyncio.create_task(platform_inst.run(), name=platform_inst.meta().name)
+            )
+        return tasks

astrbot/core/db/__init__.py

@@ -0,0 +1,161 @@
+import abc
+from dataclasses import dataclass
+from typing import List, Dict, Any, Tuple
+from astrbot.core.db.po import Stats, LLMHistory, ATRIVision, Conversation
+
+
+@dataclass
+class BaseDatabase(abc.ABC):
+    """
+    数据库基类
+    """
+
+    def __init__(self) -> None:
+        pass
+
+    def insert_base_metrics(self, metrics: dict):
+        """插入基础指标数据"""
+        self.insert_platform_metrics(metrics["platform_stats"])
+        self.insert_plugin_metrics(metrics["plugin_stats"])
+        self.insert_command_metrics(metrics["command_stats"])
+        self.insert_llm_metrics(metrics["llm_stats"])
+
+    @abc.abstractmethod
+    def insert_platform_metrics(self, metrics: dict):
+        """插入平台指标数据"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def insert_plugin_metrics(self, metrics: dict):
+        """插入插件指标数据"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def insert_command_metrics(self, metrics: dict):
+        """插入指令指标数据"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def insert_llm_metrics(self, metrics: dict):
+        """插入 LLM 指标数据"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def update_llm_history(self, session_id: str, content: str, provider_type: str):
+        """更新 LLM 历史记录。当不存在 session_id 时插入"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_llm_history(
+        self, session_id: str = None, provider_type: str = None
+    ) -> List[LLMHistory]:
+        """获取 LLM 历史记录, 如果 session_id 为 None, 返回所有"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_base_stats(self, offset_sec: int = 86400) -> Stats:
+        """获取基础统计数据"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_total_message_count(self) -> int:
+        """获取总消息数"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_grouped_base_stats(self, offset_sec: int = 86400) -> Stats:
+        """获取基础统计数据(合并)"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def insert_atri_vision_data(self, vision_data: ATRIVision):
+        """插入 ATRI 视觉数据"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_atri_vision_data(self) -> List[ATRIVision]:
+        """获取 ATRI 视觉数据"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_atri_vision_data_by_path_or_id(
+        self, url_or_path: str, id: str
+    ) -> ATRIVision:
+        """通过 url 或 path 获取 ATRI 视觉数据"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_conversation_by_user_id(self, user_id: str, cid: str) -> Conversation:
+        """通过 user_id 和 cid 获取 Conversation"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def new_conversation(self, user_id: str, cid: str):
+        """新建 Conversation"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_conversations(self, user_id: str) -> List[Conversation]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def update_conversation(self, user_id: str, cid: str, history: str):
+        """更新 Conversation"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def delete_conversation(self, user_id: str, cid: str):
+        """删除 Conversation"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def update_conversation_title(self, user_id: str, cid: str, title: str):
+        """更新 Conversation 标题"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def update_conversation_persona_id(self, user_id: str, cid: str, persona_id: str):
+        """更新 Conversation Persona ID"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_all_conversations(
+        self, page: int = 1, page_size: int = 20
+    ) -> Tuple[List[Dict[str, Any]], int]:
+        """获取所有对话，支持分页
+
+        Args:
+            page: 页码，从1开始
+            page_size: 每页数量
+
+        Returns:
+            Tuple[List[Dict[str, Any]], int]: 返回一个元组，包含对话列表和总对话数
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_filtered_conversations(
+        self,
+        page: int = 1,
+        page_size: int = 20,
+        platforms: List[str] = None,
+        message_types: List[str] = None,
+        search_query: str = None,
+        exclude_ids: List[str] = None,
+        exclude_platforms: List[str] = None,
+    ) -> Tuple[List[Dict[str, Any]], int]:
+        """获取筛选后的对话列表
+
+        Args:
+            page: 页码
+            page_size: 每页数量
+            platforms: 平台筛选列表
+            message_types: 消息类型筛选列表
+            search_query: 搜索关键词
+            exclude_ids: 排除的用户ID列表
+            exclude_platforms: 排除的平台列表
+
+        Returns:
+            Tuple[List[Dict[str, Any]], int]: 返回一个元组，包含对话列表和总对话数
+        """
+        raise NotImplementedError

astrbot/core/db/plugin/sqlite_impl.py

@@ -0,0 +1,112 @@
+import json
+import aiosqlite
+import os
+from typing import Any
+from .plugin_storage import PluginStorage
+
+DBPATH = "data/plugin_data/sqlite/plugin_data.db"
+
+
+class SQLitePluginStorage(PluginStorage):
+    """插件数据的 SQLite 存储实现类。
+
+    该类提供异步方式将插件数据存储到 SQLite 数据库中，支持数据的增删改查操作。
+    所有数据以 (plugin, key) 作为复合主键进行索引。
+    """
+
+    _instance = None  # Standalone instance of the class
+    _db_conn = None
+    db_path = None
+
+    def __new__(cls):
+        """
+        创建或获取 SQLitePluginStorage 的单例实例。
+        如果实例已存在，则返回现有实例；否则创建一个新实例。
+        数据在 `data/plugin_data/sqlite/plugin_data.db` 下。
+        """
+        os.makedirs(os.path.dirname(DBPATH), exist_ok=True)
+        if cls._instance is None:
+            cls._instance = super(SQLitePluginStorage, cls).__new__(cls)
+            cls._instance.db_path = DBPATH
+        return cls._instance
+
+    async def _init_db(self):
+        """初始化数据库连接（只执行一次）"""
+        if SQLitePluginStorage._db_conn is None:
+            SQLitePluginStorage._db_conn = await aiosqlite.connect(self.db_path)
+            await self._setup_db()
+
+    async def _setup_db(self):
+        """
+        异步初始化数据库。
+
+        创建插件数据表，如果表不存在则创建，表结构包含 plugin、key 和 value 字段，
+        其中 plugin 和 key 组合作为主键。
+        """
+        await self._db_conn.execute("""
+            CREATE TABLE IF NOT EXISTS plugin_data (
+                plugin TEXT,
+                key TEXT,
+                value TEXT,
+                PRIMARY KEY (plugin, key)
+            )
+        """)
+        await self._db_conn.commit()
+
+    async def set(self, plugin: str, key: str, value: Any):
+        """
+        异步存储数据。
+
+        将指定插件的键值对存入数据库，如果键已存在则更新值。
+        值会被序列化为 JSON 字符串后存储。
+
+        Args:
+            plugin: 插件标识符
+            key: 数据键名
+            value: 要存储的数据值（任意类型，将被 JSON 序列化）
+        """
+        await self._init_db()
+        await self._db_conn.execute(
+            "INSERT INTO plugin_data (plugin, key, value) VALUES (?, ?, ?) "
+            "ON CONFLICT(plugin, key) DO UPDATE SET value = excluded.value",
+            (plugin, key, json.dumps(value)),
+        )
+        await self._db_conn.commit()
+
+    async def get(self, plugin: str, key: str) -> Any:
+        """
+        异步获取数据。
+
+        从数据库中获取指定插件和键名对应的值，
+        返回的值会从 JSON 字符串反序列化为原始数据类型。
+
+        Args:
+            plugin: 插件标识符
+            key: 数据键名
+
+        Returns:
+            Any: 存储的数据值，如果未找到则返回 None
+        """
+        await self._init_db()
+        async with self._db_conn.execute(
+            "SELECT value FROM plugin_data WHERE plugin = ? AND key = ?",
+            (plugin, key),
+        ) as cursor:
+            row = await cursor.fetchone()
+            return json.loads(row[0]) if row else None
+
+    async def delete(self, plugin: str, key: str):
+        """
+        异步删除数据。
+
+        从数据库中删除指定插件和键名对应的数据项。
+
+        Args:
+            plugin: 插件标识符
+            key: 要删除的数据键名
+        """
+        await self._init_db()
+        await self._db_conn.execute(
+            "DELETE FROM plugin_data WHERE plugin = ? AND key = ?", (plugin, key)
+        )
+        await self._db_conn.commit()

astrbot/core/db/po.py

@@ -0,0 +1,89 @@
+"""指标数据"""
+
+from dataclasses import dataclass, field
+from typing import List
+
+
+@dataclass
+class Platform:
+    """平台使用统计数据"""
+
+    name: str
+    count: int
+    timestamp: int
+
+
+@dataclass
+class Provider:
+    """供应商使用统计数据"""
+
+    name: str
+    count: int
+    timestamp: int
+
+
+@dataclass
+class Plugin:
+    """插件使用统计数据"""
+
+    name: str
+    count: int
+    timestamp: int
+
+
+@dataclass
+class Command:
+    """命令使用统计数据"""
+
+    name: str
+    count: int
+    timestamp: int
+
+
+@dataclass
+class Stats:
+    platform: List[Platform] = field(default_factory=list)
+    command: List[Command] = field(default_factory=list)
+    llm: List[Provider] = field(default_factory=list)
+
+
+@dataclass
+class LLMHistory:
+    """LLM 聊天时持久化的信息"""
+
+    provider_type: str
+    session_id: str
+    content: str
+
+
+@dataclass
+class ATRIVision:
+    """Deprecated"""
+
+    id: str
+    url_or_path: str
+    caption: str
+    is_meme: bool
+    keywords: List[str]
+    platform_name: str
+    session_id: str
+    sender_nickname: str
+    timestamp: int = -1
+
+
+@dataclass
+class Conversation:
+    """LLM 对话存储
+
+    对于网页聊天，history 存储了包括指令、回复、图片等在内的所有消息。
+    对于其他平台的聊天，不存储非 LLM 的回复（因为考虑到已经存储在各自的平台上）。
+    """
+
+    user_id: str
+    cid: str
+    history: str = ""
+    """字符串格式的列表。"""
+    created_at: int = 0
+    updated_at: int = 0
+    title: str = ""
+    persona_id: str = ""

astrbot/core/db/sqlite.py

@@ -0,0 +1,565 @@
+import sqlite3
+import os
+import time
+from astrbot.core.db.po import Platform, Stats, LLMHistory, ATRIVision, Conversation
+from . import BaseDatabase
+from typing import Tuple, List, Dict, Any
+
+
+class SQLiteDatabase(BaseDatabase):
+    def __init__(self, db_path: str) -> None:
+        super().__init__()
+        self.db_path = db_path
+
+        with open(os.path.dirname(__file__) + "/sqlite_init.sql", "r") as f:
+            sql = f.read()
+
+        # 初始化数据库
+        self.conn = self._get_conn(self.db_path)
+        c = self.conn.cursor()
+        c.executescript(sql)
+        self.conn.commit()
+
+        # 检查 webchat_conversation 的 title 字段是否存在
+        c.execute(
+            """
+            PRAGMA table_info(webchat_conversation)
+            """
+        )
+        res = c.fetchall()
+        has_title = False
+        has_persona_id = False
+        for row in res:
+            if row[1] == "title":
+                has_title = True
+            if row[1] == "persona_id":
+                has_persona_id = True
+        if not has_title:
+            c.execute(
+                """
+                ALTER TABLE webchat_conversation ADD COLUMN title TEXT;
+                """
+            )
+            self.conn.commit()
+        if not has_persona_id:
+            c.execute(
+                """
+                ALTER TABLE webchat_conversation ADD COLUMN persona_id TEXT;
+                """
+            )
+            self.conn.commit()
+
+        c.close()
+
+    def _get_conn(self, db_path: str) -> sqlite3.Connection:
+        conn = sqlite3.connect(self.db_path)
+        conn.text_factory = str
+        return conn
+
+    def _exec_sql(self, sql: str, params: Tuple = None):
+        conn = self.conn
+        try:
+            c = self.conn.cursor()
+        except sqlite3.ProgrammingError:
+            conn = self._get_conn(self.db_path)
+            c = conn.cursor()
+
+        if params:
+            c.execute(sql, params)
+            c.close()
+        else:
+            c.execute(sql)
+            c.close()
+
+        conn.commit()
+
+    def insert_platform_metrics(self, metrics: dict):
+        for k, v in metrics.items():
+            self._exec_sql(
+                """
+                INSERT INTO platform(name, count, timestamp) VALUES (?, ?, ?)
+                """,
+                (k, v, int(time.time())),
+            )
+
+    def insert_plugin_metrics(self, metrics: dict):
+        pass
+
+    def insert_command_metrics(self, metrics: dict):
+        for k, v in metrics.items():
+            self._exec_sql(
+                """
+                INSERT INTO command(name, count, timestamp) VALUES (?, ?, ?)
+                """,
+                (k, v, int(time.time())),
+            )
+
+    def insert_llm_metrics(self, metrics: dict):
+        for k, v in metrics.items():
+            self._exec_sql(
+                """
+                INSERT INTO llm(name, count, timestamp) VALUES (?, ?, ?)
+                """,
+                (k, v, int(time.time())),
+            )
+
+    def update_llm_history(self, session_id: str, content: str, provider_type: str):
+        res = self.get_llm_history(session_id, provider_type)
+        if res:
+            self._exec_sql(
+                """
+                UPDATE llm_history SET content = ? WHERE session_id = ? AND provider_type = ?
+                """,
+                (content, session_id, provider_type),
+            )
+        else:
+            self._exec_sql(
+                """
+                INSERT INTO llm_history(provider_type, session_id, content) VALUES (?, ?, ?)
+                """,
+                (provider_type, session_id, content),
+            )
+
+    def get_llm_history(
+        self, session_id: str = None, provider_type: str = None
+    ) -> Tuple:
+        try:
+            c = self.conn.cursor()
+        except sqlite3.ProgrammingError:
+            c = self._get_conn(self.db_path).cursor()
+
+        conditions = []
+        params = []
+
+        if session_id:
+            conditions.append("session_id = ?")
+            params.append(session_id)
+
+        if provider_type:
+            conditions.append("provider_type = ?")
+            params.append(provider_type)
+
+        sql = "SELECT * FROM llm_history"
+        if conditions:
+            sql += " WHERE " + " AND ".join(conditions)
+
+        c.execute(sql, params)
+
+        res = c.fetchall()
+        histories = []
+        for row in res:
+            histories.append(LLMHistory(*row))
+        c.close()
+        return histories
+
+    def get_base_stats(self, offset_sec: int = 86400) -> Stats:
+        """获取 offset_sec 秒前到现在的基础统计数据"""
+        where_clause = f" WHERE timestamp >= {int(time.time()) - offset_sec}"
+
+        try:
+            c = self.conn.cursor()
+        except sqlite3.ProgrammingError:
+            c = self._get_conn(self.db_path).cursor()
+
+        c.execute(
+            """
+            SELECT * FROM platform
+            """
+            + where_clause
+        )
+
+        platform = []
+        for row in c.fetchall():
+            platform.append(Platform(*row))
+
+        # c.execute(
+        #     '''
+        #     SELECT * FROM command
+        #     ''' + where_clause
+        # )
+
+        # command = []
+        # for row in c.fetchall():
+        #     command.append(Command(*row))
+
+        # c.execute(
+        #     '''
+        #     SELECT * FROM llm
+        #     ''' + where_clause
+        # )
+
+        # llm = []
+        # for row in c.fetchall():
+        #     llm.append(Provider(*row))
+
+        c.close()
+
+        return Stats(platform, [], [])
+
+    def get_total_message_count(self) -> int:
+        try:
+            c = self.conn.cursor()
+        except sqlite3.ProgrammingError:
+            c = self._get_conn(self.db_path).cursor()
+
+        c.execute(
+            """
+            SELECT SUM(count) FROM platform
+            """
+        )
+        res = c.fetchone()
+        c.close()
+        return res[0]
+
+    def get_grouped_base_stats(self, offset_sec: int = 86400) -> Stats:
+        """获取 offset_sec 秒前到现在的基础统计数据(合并)"""
+        where_clause = f" WHERE timestamp >= {int(time.time()) - offset_sec}"
+
+        try:
+            c = self.conn.cursor()
+        except sqlite3.ProgrammingError:
+            c = self._get_conn(self.db_path).cursor()
+
+        c.execute(
+            """
+            SELECT name, SUM(count), timestamp FROM platform
+            """
+            + where_clause
+            + " GROUP BY name"
+        )
+
+        platform = []
+        for row in c.fetchall():
+            platform.append(Platform(*row))
+
+        c.close()
+
+        return Stats(platform, [], [])
+
+    def get_conversation_by_user_id(self, user_id: str, cid: str) -> Conversation:
+        try:
+            c = self.conn.cursor()
+        except sqlite3.ProgrammingError:
+            c = self._get_conn(self.db_path).cursor()
+
+        c.execute(
+            """
+            SELECT * FROM webchat_conversation WHERE user_id = ? AND cid = ?
+            """,
+            (user_id, cid),
+        )
+
+        res = c.fetchone()
+        c.close()
+
+        if not res:
+            return
+
+        return Conversation(*res)
+
+    def new_conversation(self, user_id: str, cid: str):
+        history = "[]"
+        updated_at = int(time.time())
+        created_at = updated_at
+        self._exec_sql(
+            """
+            INSERT INTO webchat_conversation(user_id, cid, history, updated_at, created_at) VALUES (?, ?, ?, ?, ?)
+            """,
+            (user_id, cid, history, updated_at, created_at),
+        )
+
+    def get_conversations(self, user_id: str) -> Tuple:
+        try:
+            c = self.conn.cursor()
+        except sqlite3.ProgrammingError:
+            c = self._get_conn(self.db_path).cursor()
+
+        c.execute(
+            """
+            SELECT cid, created_at, updated_at, title, persona_id FROM webchat_conversation WHERE user_id = ? ORDER BY updated_at DESC
+            """,
+            (user_id,),
+        )
+
+        res = c.fetchall()
+        c.close()
+        conversations = []
+        for row in res:
+            cid = row[0]
+            created_at = row[1]
+            updated_at = row[2]
+            title = row[3]
+            persona_id = row[4]
+            conversations.append(
+                Conversation("", cid, "[]", created_at, updated_at, title, persona_id)
+            )
+        return conversations
+
+    def update_conversation(self, user_id: str, cid: str, history: str):
+        """更新对话，并且同时更新时间"""
+        updated_at = int(time.time())
+        self._exec_sql(
+            """
+            UPDATE webchat_conversation SET history = ?, updated_at = ? WHERE user_id = ? AND cid = ?
+            """,
+            (history, updated_at, user_id, cid),
+        )
+
+    def update_conversation_title(self, user_id: str, cid: str, title: str):
+        self._exec_sql(
+            """
+            UPDATE webchat_conversation SET title = ? WHERE user_id = ? AND cid = ?
+            """,
+            (title, user_id, cid),
+        )
+
+    def update_conversation_persona_id(self, user_id: str, cid: str, persona_id: str):
+        self._exec_sql(
+            """
+            UPDATE webchat_conversation SET persona_id = ? WHERE user_id = ? AND cid = ?
+            """,
+            (persona_id, user_id, cid),
+        )
+
+    def delete_conversation(self, user_id: str, cid: str):
+        self._exec_sql(
+            """
+            DELETE FROM webchat_conversation WHERE user_id = ? AND cid = ?
+            """,
+            (user_id, cid),
+        )
+
+    def insert_atri_vision_data(self, vision: ATRIVision):
+        ts = int(time.time())
+        keywords = ",".join(vision.keywords)
+        self._exec_sql(
+            """
+            INSERT INTO atri_vision(id, url_or_path, caption, is_meme, keywords, platform_name, session_id, sender_nickname, timestamp) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                vision.id,
+                vision.url_or_path,
+                vision.caption,
+                vision.is_meme,
+                keywords,
+                vision.platform_name,
+                vision.session_id,
+                vision.sender_nickname,
+                ts,
+            ),
+        )
+
+    def get_atri_vision_data(self) -> Tuple:
+        try:
+            c = self.conn.cursor()
+        except sqlite3.ProgrammingError:
+            c = self._get_conn(self.db_path).cursor()
+
+        c.execute(
+            """
+            SELECT * FROM atri_vision
+            """
+        )
+
+        res = c.fetchall()
+        visions = []
+        for row in res:
+            visions.append(ATRIVision(*row))
+        c.close()
+        return visions
+
+    def get_atri_vision_data_by_path_or_id(
+        self, url_or_path: str, id: str
+    ) -> ATRIVision:
+        try:
+            c = self.conn.cursor()
+        except sqlite3.ProgrammingError:
+            c = self._get_conn(self.db_path).cursor()
+
+        c.execute(
+            """
+            SELECT * FROM atri_vision WHERE url_or_path = ? OR id = ?
+            """,
+            (url_or_path, id),
+        )
+
+        res = c.fetchone()
+        c.close()
+        if res:
+            return ATRIVision(*res)
+        return None
+
+    def get_all_conversations(
+        self, page: int = 1, page_size: int = 20
+    ) -> Tuple[List[Dict[str, Any]], int]:
+        """获取所有对话，支持分页，按更新时间降序排序"""
+        try:
+            c = self.conn.cursor()
+        except sqlite3.ProgrammingError:
+            c = self._get_conn(self.db_path).cursor()
+
+        try:
+            # 获取总记录数
+            c.execute("""
+                SELECT COUNT(*) FROM webchat_conversation
+            """)
+            total_count = c.fetchone()[0]
+
+            # 计算偏移量
+            offset = (page - 1) * page_size
+
+            # 获取分页数据，按更新时间降序排序
+            c.execute(
+                """
+                SELECT user_id, cid, created_at, updated_at, title, persona_id
+                FROM webchat_conversation
+                ORDER BY updated_at DESC
+                LIMIT ? OFFSET ?
+            """,
+                (page_size, offset),
+            )
+
+            rows = c.fetchall()
+
+            conversations = []
+
+            for row in rows:
+                user_id, cid, created_at, updated_at, title, persona_id = row
+                # 确保 cid 是字符串类型且至少有8个字符，否则使用一个默认值
+                safe_cid = str(cid) if cid else "unknown"
+                display_cid = safe_cid[:8] if len(safe_cid) >= 8 else safe_cid
+
+                conversations.append(
+                    {
+                        "user_id": user_id or "",
+                        "cid": safe_cid,
+                        "title": title or f"对话 {display_cid}",
+                        "persona_id": persona_id or "",
+                        "created_at": created_at or 0,
+                        "updated_at": updated_at or 0,
+                    }
+                )
+
+            return conversations, total_count
+
+        except Exception as _:
+            # 返回空列表和0，确保即使出错也有有效的返回值
+            return [], 0
+        finally:
+            c.close()
+
+    def get_filtered_conversations(
+        self,
+        page: int = 1,
+        page_size: int = 20,
+        platforms: List[str] = None,
+        message_types: List[str] = None,
+        search_query: str = None,
+        exclude_ids: List[str] = None,
+        exclude_platforms: List[str] = None,
+    ) -> Tuple[List[Dict[str, Any]], int]:
+        """获取筛选后的对话列表"""
+        try:
+            c = self.conn.cursor()
+        except sqlite3.ProgrammingError:
+            c = self._get_conn(self.db_path).cursor()
+
+        try:
+            # 构建查询条件
+            where_clauses = []
+            params = []
+
+            # 平台筛选
+            if platforms and len(platforms) > 0:
+                platform_conditions = []
+                for platform in platforms:
+                    platform_conditions.append("user_id LIKE ?")
+                    params.append(f"{platform}:%")
+
+                if platform_conditions:
+                    where_clauses.append(f"({' OR '.join(platform_conditions)})")
+
+            # 消息类型筛选
+            if message_types and len(message_types) > 0:
+                message_type_conditions = []
+                for msg_type in message_types:
+                    message_type_conditions.append("user_id LIKE ?")
+                    params.append(f"%:{msg_type}:%")
+
+                if message_type_conditions:
+                    where_clauses.append(f"({' OR '.join(message_type_conditions)})")
+
+            # 搜索关键词
+            if search_query:
+                search_query = search_query.encode("unicode_escape").decode("utf-8")
+                where_clauses.append(
+                    "(title LIKE ? OR user_id LIKE ? OR cid LIKE ? OR history LIKE ?)"
+                )
+                search_param = f"%{search_query}%"
+                params.extend([search_param, search_param, search_param, search_param])
+
+            # 排除特定用户ID
+            if exclude_ids and len(exclude_ids) > 0:
+                for exclude_id in exclude_ids:
+                    where_clauses.append("user_id NOT LIKE ?")
+                    params.append(f"{exclude_id}%")
+
+            # 排除特定平台
+            if exclude_platforms and len(exclude_platforms) > 0:
+                for exclude_platform in exclude_platforms:
+                    where_clauses.append("user_id NOT LIKE ?")
+                    params.append(f"{exclude_platform}:%")
+
+            # 构建完整的 WHERE 子句
+            where_sql = " WHERE " + " AND ".join(where_clauses) if where_clauses else ""
+
+            # 构建计数查询
+            count_sql = f"SELECT COUNT(*) FROM webchat_conversation{where_sql}"
+
+            # 获取总记录数
+            c.execute(count_sql, params)
+            total_count = c.fetchone()[0]
+
+            # 计算偏移量
+            offset = (page - 1) * page_size
+
+            # 构建分页数据查询
+            data_sql = f"""
+                SELECT user_id, cid, created_at, updated_at, title, persona_id
+                FROM webchat_conversation
+                {where_sql}
+                ORDER BY updated_at DESC
+                LIMIT ? OFFSET ?
+            """
+            query_params = params + [page_size, offset]
+
+            # 获取分页数据
+            c.execute(data_sql, query_params)
+            rows = c.fetchall()
+
+            conversations = []
+
+            for row in rows:
+                user_id, cid, created_at, updated_at, title, persona_id = row
+                # 确保 cid 是字符串类型，否则使用一个默认值
+                safe_cid = str(cid) if cid else "unknown"
+                display_cid = safe_cid[:8] if len(safe_cid) >= 8 else safe_cid
+
+                conversations.append(
+                    {
+                        "user_id": user_id or "",
+                        "cid": safe_cid,
+                        "title": title or f"对话 {display_cid}",
+                        "persona_id": persona_id or "",
+                        "created_at": created_at or 0,
+                        "updated_at": updated_at or 0,
+                    }
+                )
+
+            return conversations, total_count
+
+        except Exception as _:
+            # 返回空列表和0，确保即使出错也有有效的返回值
+            return [], 0
+        finally:
+            c.close()

astrbot/core/db/sqlite_init.sql

@@ -0,0 +1,50 @@
+CREATE TABLE IF NOT EXISTS platform(
+    name VARCHAR(32),
+    count INTEGER,
+    timestamp INTEGER
+);
+CREATE TABLE IF NOT EXISTS llm(
+    name VARCHAR(32),
+    count INTEGER,
+    timestamp INTEGER
+);
+CREATE TABLE IF NOT EXISTS plugin(
+    name VARCHAR(32),
+    count INTEGER,
+    timestamp INTEGER
+);
+CREATE TABLE IF NOT EXISTS command(
+    name VARCHAR(32),
+    count INTEGER,
+    timestamp INTEGER
+);
+CREATE TABLE IF NOT EXISTS llm_history(
+    provider_type VARCHAR(32),
+    session_id VARCHAR(32),
+    content TEXT
+);
+
+-- ATRI
+CREATE TABLE IF NOT EXISTS atri_vision(
+    id TEXT,
+    url_or_path TEXT,
+    caption TEXT,
+    is_meme BOOLEAN,
+    keywords TEXT,
+    platform_name VARCHAR(32),
+    session_id VARCHAR(32),
+    sender_nickname VARCHAR(32),
+    timestamp INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS webchat_conversation(
+    user_id TEXT, -- 会话 id
+    cid TEXT, -- 对话 id
+    history TEXT,
+    created_at INTEGER,
+    updated_at INTEGER,
+    title TEXT,
+    persona_id TEXT
+);
+
+PRAGMA encoding = 'UTF-8';

astrbot/core/event_bus.py

@@ -0,0 +1,57 @@
+"""
+事件总线, 用于处理事件的分发和处理
+事件总线是一个异步队列, 用于接收各种消息事件, 并将其发送到Scheduler调度器进行处理
+其中包含了一个无限循环的调度函数, 用于从事件队列中获取新的事件, 并创建一个新的异步任务来执行管道调度器的处理逻辑
+
+class:
+    EventBus: 事件总线, 用于处理事件的分发和处理
+
+工作流程:
+1. 维护一个异步队列, 来接受各种消息事件
+2. 无限循环的调度函数, 从事件队列中获取新的事件, 打印日志并创建一个新的异步任务来执行管道调度器的处理逻辑
+"""
+
+import asyncio
+from asyncio import Queue
+from astrbot.core.pipeline.scheduler import PipelineScheduler
+from astrbot.core import logger
+from .platform import AstrMessageEvent
+
+
+class EventBus:
+    """事件总线: 用于处理事件的分发和处理
+
+    维护一个异步队列, 来接受各种消息事件
+    """
+
+    def __init__(self, event_queue: Queue, pipeline_scheduler: PipelineScheduler):
+        self.event_queue = event_queue  # 事件队列
+        self.pipeline_scheduler = pipeline_scheduler  # 管道调度器
+
+    async def dispatch(self):
+        """无限循环的调度函数, 从事件队列中获取新的事件, 打印日志并创建一个新的异步任务来执行管道调度器的处理逻辑"""
+        while True:
+            event: AstrMessageEvent = (
+                await self.event_queue.get()
+            )  # 从事件队列中获取新的事件
+            self._print_event(event)  # 打印日志
+            asyncio.create_task(
+                self.pipeline_scheduler.execute(event)
+            )  # 创建新的异步任务来执行管道调度器的处理逻辑
+
+    def _print_event(self, event: AstrMessageEvent):
+        """用于记录事件信息
+
+        Args:
+            event (AstrMessageEvent): 事件对象
+        """
+        # 如果有发送者名称: [平台名] 发送者名称/发送者ID: 消息概要
+        if event.get_sender_name():
+            logger.info(
+                f"[{event.get_platform_name()}] {event.get_sender_name()}/{event.get_sender_id()}: {event.get_message_outline()}"
+            )
+        # 没有发送者名称: [平台名] 发送者ID: 消息概要
+        else:
+            logger.info(
+                f"[{event.get_platform_name()}] {event.get_sender_id()}: {event.get_message_outline()}"
+            )

astrbot/core/initial_loader.py

@@ -0,0 +1,48 @@
+"""
+AstrBot 启动器，负责初始化和启动核心组件和仪表板服务器。
+
+工作流程:
+1. 初始化核心生命周期, 传递数据库和日志代理实例到核心生命周期
+2. 运行核心生命周期任务和仪表板服务器
+"""
+
+import asyncio
+import traceback
+from astrbot.core import logger
+from astrbot.core.core_lifecycle import AstrBotCoreLifecycle
+from astrbot.core.db import BaseDatabase
+from astrbot.core import LogBroker
+from astrbot.dashboard.server import AstrBotDashboard
+
+
+class InitialLoader:
+    """AstrBot 启动器，负责初始化和启动核心组件和仪表板服务器。"""
+
+    def __init__(self, db: BaseDatabase, log_broker: LogBroker):
+        self.db = db
+        self.logger = logger
+        self.log_broker = log_broker
+
+    async def start(self):
+        core_lifecycle = AstrBotCoreLifecycle(self.log_broker, self.db)
+
+        core_task = []
+        try:
+            await core_lifecycle.initialize()
+            core_task = core_lifecycle.start()
+        except Exception as e:
+            logger.critical(traceback.format_exc())
+            logger.critical(f"😭 初始化 AstrBot 失败：{e} !!!")
+
+        self.dashboard_server = AstrBotDashboard(
+            core_lifecycle, self.db, core_lifecycle.dashboard_shutdown_event
+        )
+        task = asyncio.gather(
+            core_task, self.dashboard_server.run()
+        )  # 启动核心任务和仪表板服务器
+
+        try:
+            await task  # 整个AstrBot在这里运行
+        except asyncio.CancelledError:
+            logger.info("🌈 正在关闭 AstrBot...")
+            await core_lifecycle.stop()

astrbot/core/log.py

@@ -0,0 +1,248 @@
+"""
+日志系统, 用于支持核心组件和插件的日志记录, 提供了日志订阅功能
+
+const:
+    CACHED_SIZE: 日志缓存大小, 用于限制缓存的日志数量
+    log_color_config: 日志颜色配置, 定义了不同日志级别的颜色
+
+class:
+    LogBroker: 日志代理类, 用于缓存和分发日志消息
+    LogQueueHandler: 日志处理器, 用于将日志消息发送到 LogBroker
+    LogManager: 日志管理器, 用于创建和配置日志记录器
+
+function:
+    is_plugin_path: 检查文件路径是否来自插件目录
+    get_short_level_name: 将日志级别名称转换为四个字母的缩写
+
+工作流程:
+1. 通过 LogManager.GetLogger() 获取日志器, 配置了控制台输出和多个格式化过滤器
+2. 通过 set_queue_handler() 设置日志处理器, 将日志消息发送到 LogBroker
+3. logBroker 维护一个订阅者列表, 负责将日志分发给所有订阅者
+4. 订阅者可以使用 register() 方法注册到 LogBroker, 订阅日志流
+"""
+
+import logging
+import colorlog
+import asyncio
+import os
+import sys
+from collections import deque
+from asyncio import Queue
+from typing import List
+
+# 日志缓存大小
+CACHED_SIZE = 200
+# 日志颜色配置
+log_color_config = {
+    "DEBUG": "green",
+    "INFO": "bold_cyan",
+    "WARNING": "bold_yellow",
+    "ERROR": "red",
+    "CRITICAL": "bold_red",
+    "RESET": "reset",
+    "asctime": "green",
+}
+
+
+def is_plugin_path(pathname):
+    """检查文件路径是否来自插件目录
+
+    Args:
+        pathname (str): 文件路径
+
+    Returns:
+        bool: 如果路径来自插件目录，则返回 True，否则返回 False
+    """
+    if not pathname:
+        return False
+
+    norm_path = os.path.normpath(pathname)
+    return ("data/plugins" in norm_path) or ("packages/" in norm_path)
+
+
+def get_short_level_name(level_name):
+    """将日志级别名称转换为四个字母的缩写
+
+    Args:
+        level_name (str): 日志级别名称, 如 "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"
+
+    Returns:
+        str: 四个字母的日志级别缩写
+    """
+    level_map = {
+        "DEBUG": "DBUG",
+        "INFO": "INFO",
+        "WARNING": "WARN",
+        "ERROR": "ERRO",
+        "CRITICAL": "CRIT",
+    }
+    return level_map.get(level_name, level_name[:4].upper())
+
+
+class LogBroker:
+    """日志代理类, 用于缓存和分发日志消息
+
+    发布-订阅模式
+    """
+
+    def __init__(self):
+        self.log_cache = deque(maxlen=CACHED_SIZE)  # 环形缓冲区, 保存最近的日志
+        self.subscribers: List[Queue] = []  # 订阅者列表
+
+    def register(self) -> Queue:
+        """注册新的订阅者, 并给每个订阅者返回一个带有日志缓存的队列
+
+        Returns:
+            Queue: 订阅者的队列, 可用于接收日志消息
+        """
+        q = Queue(maxsize=CACHED_SIZE + 10)
+        for log in self.log_cache:
+            q.put_nowait(log)
+        self.subscribers.append(q)
+        return q
+
+    def unregister(self, q: Queue):
+        """取消订阅
+
+        Args:
+            q (Queue): 需要取消订阅的队列
+        """
+        self.subscribers.remove(q)
+
+    def publish(self, log_entry: dict):
+        """发布新日志到所有订阅者, 使用非阻塞方式投递, 避免一个订阅者阻塞整个系统
+
+        Args:
+            log_entry (dict): 日志消息, 包含日志级别和日志内容.
+                example: {"level": "INFO", "data": "This is a log message.", "time": "2023-10-01 12:00:00"}
+        """
+        self.log_cache.append(log_entry)
+        for q in self.subscribers:
+            try:
+                q.put_nowait(log_entry)
+            except asyncio.QueueFull:
+                pass
+
+
+class LogQueueHandler(logging.Handler):
+    """日志处理器, 用于将日志消息发送到 LogBroker
+
+    继承自 logging.Handler
+    """
+
+    def __init__(self, log_broker: LogBroker):
+        super().__init__()
+        self.log_broker = log_broker
+
+    def emit(self, record):
+        """日志处理的入口方法, 接受一个日志记录, 转换为字符串后由 LogBroker 发布
+        这个方法会在每次日志记录时被调用
+
+        Args:
+            record (logging.LogRecord): 日志记录对象, 包含日志信息
+        """
+        log_entry = self.format(record)
+        self.log_broker.publish(
+            {
+                "level": record.levelname,
+                "time": record.asctime,
+                "data": log_entry,
+            }
+        )
+
+
+class LogManager:
+    """日志管理器, 用于创建和配置日志记录器
+
+    提供了获取默认日志记录器logger和设置队列处理器的方法
+    """
+
+    @classmethod
+    def GetLogger(cls, log_name: str = "default"):
+        """获取指定名称的日志记录器logger
+
+        Args:
+            log_name (str): 日志记录器的名称, 默认为 "default"
+
+        Returns:
+            logging.Logger: 返回配置好的日志记录器
+        """
+        logger = logging.getLogger(log_name)
+        # 检查该logger或父级logger是否已经有处理器, 如果已经有处理器, 直接返回该logger, 避免重复配置
+        if logger.hasHandlers():
+            return logger
+        # 如果logger没有处理器
+        console_handler = logging.StreamHandler(
+            sys.stdout
+        )  # 创建一个StreamHandler用于控制台输出
+        console_handler.setLevel(
+            logging.DEBUG
+        )  # 将日志级别设置为DEBUG(最低级别, 显示所有日志), *如果插件没有设置级别, 默认为DEBUG
+
+        # 创建彩色日志格式化器, 输出日志格式为: [时间] [插件标签] [日志级别] [文件名:行号]: 日志消息
+        console_formatter = colorlog.ColoredFormatter(
+            fmt="%(log_color)s [%(asctime)s] %(plugin_tag)s [%(short_levelname)-4s] [%(filename)s:%(lineno)d]: %(message)s %(reset)s",
+            datefmt="%H:%M:%S",
+            log_colors=log_color_config,
+        )
+
+        class PluginFilter(logging.Filter):
+            """插件过滤器类, 用于标记日志来源是插件还是核心组件"""
+
+            def filter(self, record):
+                record.plugin_tag = (
+                    "[Plug]" if is_plugin_path(record.pathname) else "[Core]"
+                )
+                return True
+
+        class FileNameFilter(logging.Filter):
+            """文件名过滤器类, 用于修改日志记录的文件名格式
+            例如: 将文件路径 /path/to/file.py 转换为 file.<file> 格式"""
+
+            # 获取这个文件和父文件夹的名字：<folder>.<file> 并且去除 .py
+            def filter(self, record):
+                dirname = os.path.dirname(record.pathname)
+                record.filename = (
+                    os.path.basename(dirname)
+                    + "."
+                    + os.path.basename(record.pathname).replace(".py", "")
+                )
+                return True
+
+        class LevelNameFilter(logging.Filter):
+            """短日志级别名称过滤器类, 用于将日志级别名称转换为四个字母的缩写"""
+
+            # 添加短日志级别名称
+            def filter(self, record):
+                record.short_levelname = get_short_level_name(record.levelname)
+                return True
+
+        console_handler.setFormatter(console_formatter)  # 设置处理器的格式化器
+        logger.addFilter(PluginFilter())  # 添加插件过滤器
+        logger.addFilter(FileNameFilter())  # 添加文件名过滤器
+        logger.addFilter(LevelNameFilter())  # 添加级别名称过滤器
+        logger.setLevel(logging.DEBUG)  # 设置日志级别为DEBUG
+        logger.addHandler(console_handler)  # 添加处理器到logger
+
+        return logger
+
+    @classmethod
+    def set_queue_handler(cls, logger: logging.Logger, log_broker: LogBroker):
+        """设置队列处理器, 用于将日志消息发送到 LogBroker
+
+        Args:
+            logger (logging.Logger): 日志记录器
+            log_broker (LogBroker): 日志代理类, 用于缓存和分发日志消息
+        """
+        handler = LogQueueHandler(log_broker)
+        handler.setLevel(logging.DEBUG)
+        if logger.handlers:
+            handler.setFormatter(logger.handlers[0].formatter)
+        else:
+            # 为队列处理器设置相同格式的formatter
+            handler.setFormatter(
+                logging.Formatter(
+                    "[%(asctime)s] [%(short_levelname)s] %(plugin_tag)s[%(filename)s:%(lineno)d]: %(message)s"
+                )
+            )
+        logger.addHandler(handler)

astrbot/core/message/components.py

@@ -0,0 +1,683 @@
+"""
+MIT License
+
+Copyright (c) 2021 Lxns-Network
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+
+import base64
+import json
+import os
+import uuid
+import asyncio
+import typing as T
+from enum import Enum
+from pydantic.v1 import BaseModel
+from astrbot.core import logger
+from astrbot.core.utils.io import download_image_by_url, file_to_base64, download_file
+
+
+class ComponentType(Enum):
+    Plain = "Plain"  # 纯文本消息
+    Face = "Face"  # QQ表情
+    Record = "Record"  # 语音
+    Video = "Video"  # 视频
+    At = "At"  # At
+    Node = "Node"  # 转发消息的一个节点
+    Nodes = "Nodes"  # 转发消息的多个节点
+    Poke = "Poke"  # QQ 戳一戳
+    Image = "Image"  # 图片
+    Reply = "Reply"  # 回复
+    Forward = "Forward"  # 转发消息
+    File = "File"  # 文件
+
+    RPS = "RPS"  # TODO
+    Dice = "Dice"  # TODO
+    Shake = "Shake"  # TODO
+    Anonymous = "Anonymous"  # TODO
+    Share = "Share"
+    Contact = "Contact"  # TODO
+    Location = "Location"  # TODO
+    Music = "Music"
+    RedBag = "RedBag"
+    Xml = "Xml"
+    Json = "Json"
+    CardImage = "CardImage"
+    TTS = "TTS"
+    Unknown = "Unknown"
+
+    WechatEmoji = "WechatEmoji"  # Wechat 下的 emoji 表情包
+
+
+class BaseMessageComponent(BaseModel):
+    type: ComponentType
+
+    def toString(self):
+        output = f"[CQ:{self.type.lower()}"
+        for k, v in self.__dict__.items():
+            if k == "type" or v is None:
+                continue
+            if k == "_type":
+                k = "type"
+            if isinstance(v, bool):
+                v = 1 if v else 0
+            output += ",%s=%s" % (
+                k,
+                str(v)
+                .replace("&", "&")
+                .replace(",", ",")
+                .replace("[", "[")
+                .replace("]", "]"),
+            )
+        output += "]"
+        return output
+
+    def toDict(self):
+        data = {}
+        for k, v in self.__dict__.items():
+            if k == "type" or v is None:
+                continue
+            if k == "_type":
+                k = "type"
+            data[k] = v
+        return {"type": self.type.lower(), "data": data}
+
+
+class Plain(BaseMessageComponent):
+    type: ComponentType = "Plain"
+    text: str
+    convert: T.Optional[bool] = True  # 若为 False 则直接发送未转换 CQ 码的消息
+
+    def __init__(self, text: str, convert: bool = True, **_):
+        super().__init__(text=text, convert=convert, **_)
+
+    def toString(self):  # 没有 [CQ:plain] 这种东西，所以直接导出纯文本
+        if not self.convert:
+            return self.text
+        return (
+            self.text.replace("&", "&").replace("[", "[").replace("]", "]")
+        )
+
+
+class Face(BaseMessageComponent):
+    type: ComponentType = "Face"
+    id: int
+
+    def __init__(self, **_):
+        super().__init__(**_)
+
+
+class Record(BaseMessageComponent):
+    type: ComponentType = "Record"
+    file: T.Optional[str] = ""
+    magic: T.Optional[bool] = False
+    url: T.Optional[str] = ""
+    cache: T.Optional[bool] = True
+    proxy: T.Optional[bool] = True
+    timeout: T.Optional[int] = 0
+    # 额外
+    path: T.Optional[str]
+
+    def __init__(self, file: T.Optional[str], **_):
+        for k in _.keys():
+            if k == "url":
+                pass
+                # Protocol.warn(f"go-cqhttp doesn't support send {self.type} by {k}")
+        super().__init__(file=file, **_)
+
+    @staticmethod
+    def fromFileSystem(path, **_):
+        return Record(file=f"file:///{os.path.abspath(path)}", path=path, **_)
+
+    @staticmethod
+    def fromURL(url: str, **_):
+        if url.startswith("http://") or url.startswith("https://"):
+            return Record(file=url, **_)
+        raise Exception("not a valid url")
+
+    async def convert_to_file_path(self) -> str:
+        """将这个语音统一转换为本地文件路径。这个方法避免了手动判断语音数据类型，直接返回语音数据的本地路径（如果是网络 URL, 则会自动进行下载）。
+
+        Returns:
+            str: 语音的本地路径，以绝对路径表示。
+        """
+        if self.file and self.file.startswith("file:///"):
+            file_path = self.file[8:]
+            return file_path
+        elif self.file and self.file.startswith("http"):
+            file_path = await download_image_by_url(self.file)
+            return os.path.abspath(file_path)
+        elif self.file and self.file.startswith("base64://"):
+            bs64_data = self.file.removeprefix("base64://")
+            image_bytes = base64.b64decode(bs64_data)
+            file_path = f"data/temp/{uuid.uuid4()}.jpg"
+            with open(file_path, "wb") as f:
+                f.write(image_bytes)
+            return os.path.abspath(file_path)
+        elif os.path.exists(self.file):
+            file_path = self.file
+            return os.path.abspath(file_path)
+        else:
+            raise Exception(f"not a valid file: {self.file}")
+
+    async def convert_to_base64(self) -> str:
+        """将语音统一转换为 base64 编码。这个方法避免了手动判断语音数据类型，直接返回语音数据的 base64 编码。
+
+        Returns:
+            str: 语音的 base64 编码，不以 base64:// 或者 data:image/jpeg;base64, 开头。
+        """
+        # convert to base64
+        if self.file and self.file.startswith("file:///"):
+            bs64_data = file_to_base64(self.file[8:])
+        elif self.file and self.file.startswith("http"):
+            file_path = await download_image_by_url(self.file)
+            bs64_data = file_to_base64(file_path)
+        elif self.file and self.file.startswith("base64://"):
+            bs64_data = self.file
+        elif os.path.exists(self.file):
+            bs64_data = file_to_base64(self.file)
+        else:
+            raise Exception(f"not a valid file: {self.file}")
+        bs64_data = bs64_data.removeprefix("base64://")
+        return bs64_data
+
+
+class Video(BaseMessageComponent):
+    type: ComponentType = "Video"
+    file: str
+    cover: T.Optional[str] = ""
+    c: T.Optional[int] = 2
+    # 额外
+    path: T.Optional[str] = ""
+
+    def __init__(self, file: str, **_):
+        # for k in _.keys():
+        #     if k == "c" and _[k] not in [2, 3]:
+        #         logger.warn(f"Protocol: {k}={_[k]} doesn't match values")
+        super().__init__(file=file, **_)
+
+    @staticmethod
+    def fromFileSystem(path, **_):
+        return Video(file=f"file:///{os.path.abspath(path)}", path=path, **_)
+
+    @staticmethod
+    def fromURL(url: str, **_):
+        if url.startswith("http://") or url.startswith("https://"):
+            return Video(file=url, **_)
+        raise Exception("not a valid url")
+
+
+class At(BaseMessageComponent):
+    type: ComponentType = "At"
+    qq: T.Union[int, str]  # 此处str为all时代表所有人
+    name: T.Optional[str] = ""
+
+    def __init__(self, **_):
+        super().__init__(**_)
+
+
+class AtAll(At):
+    qq: str = "all"
+
+    def __init__(self, **_):
+        super().__init__(**_)
+
+
+class RPS(BaseMessageComponent):  # TODO
+    type: ComponentType = "RPS"
+
+    def __init__(self, **_):
+        super().__init__(**_)
+
+
+class Dice(BaseMessageComponent):  # TODO
+    type: ComponentType = "Dice"
+
+    def __init__(self, **_):
+        super().__init__(**_)
+
+
+class Shake(BaseMessageComponent):  # TODO
+    type: ComponentType = "Shake"
+
+    def __init__(self, **_):
+        super().__init__(**_)
+
+
+class Anonymous(BaseMessageComponent):  # TODO
+    type: ComponentType = "Anonymous"
+    ignore: T.Optional[bool] = False
+
+    def __init__(self, **_):
+        super().__init__(**_)
+
+
+class Share(BaseMessageComponent):
+    type: ComponentType = "Share"
+    url: str
+    title: str
+    content: T.Optional[str] = ""
+    image: T.Optional[str] = ""
+
+    def __init__(self, **_):
+        super().__init__(**_)
+
+
+class Contact(BaseMessageComponent):  # TODO
+    type: ComponentType = "Contact"
+    _type: str  # type 字段冲突
+    id: T.Optional[int] = 0
+
+    def __init__(self, **_):
+        super().__init__(**_)
+
+
+class Location(BaseMessageComponent):  # TODO
+    type: ComponentType = "Location"
+    lat: float
+    lon: float
+    title: T.Optional[str] = ""
+    content: T.Optional[str] = ""
+
+    def __init__(self, **_):
+        super().__init__(**_)
+
+
+class Music(BaseMessageComponent):
+    type: ComponentType = "Music"
+    _type: str
+    id: T.Optional[int] = 0
+    url: T.Optional[str] = ""
+    audio: T.Optional[str] = ""
+    title: T.Optional[str] = ""
+    content: T.Optional[str] = ""
+    image: T.Optional[str] = ""
+
+    def __init__(self, **_):
+        # for k in _.keys():
+        #     if k == "_type" and _[k] not in ["qq", "163", "xm", "custom"]:
+        #         logger.warn(f"Protocol: {k}={_[k]} doesn't match values")
+        super().__init__(**_)
+
+
+class Image(BaseMessageComponent):
+    type: ComponentType = "Image"
+    file: T.Optional[str] = ""
+    _type: T.Optional[str] = ""
+    subType: T.Optional[int] = 0
+    url: T.Optional[str] = ""
+    cache: T.Optional[bool] = True
+    id: T.Optional[int] = 40000
+    c: T.Optional[int] = 2
+    # 额外
+    path: T.Optional[str] = ""
+    file_unique: T.Optional[str] = ""  # 某些平台可能有图片缓存的唯一标识
+
+    def __init__(self, file: T.Optional[str], **_):
+        super().__init__(file=file, **_)
+
+    @staticmethod
+    def fromURL(url: str, **_):
+        if url.startswith("http://") or url.startswith("https://"):
+            return Image(file=url, **_)
+        raise Exception("not a valid url")
+
+    @staticmethod
+    def fromFileSystem(path, **_):
+        return Image(file=f"file:///{os.path.abspath(path)}", path=path, **_)
+
+    @staticmethod
+    def fromBase64(base64: str, **_):
+        return Image(f"base64://{base64}", **_)
+
+    @staticmethod
+    def fromBytes(byte: bytes):
+        return Image.fromBase64(base64.b64encode(byte).decode())
+
+    @staticmethod
+    def fromIO(IO):
+        return Image.fromBytes(IO.read())
+
+    async def convert_to_file_path(self) -> str:
+        """将这个图片统一转换为本地文件路径。这个方法避免了手动判断图片数据类型，直接返回图片数据的本地路径（如果是网络 URL, 则会自动进行下载）。
+
+        Returns:
+            str: 图片的本地路径，以绝对路径表示。
+        """
+        url = self.url if self.url else self.file
+        if url and url.startswith("file:///"):
+            image_file_path = url[8:]
+            return image_file_path
+        elif url and url.startswith("http"):
+            image_file_path = await download_image_by_url(url)
+            return os.path.abspath(image_file_path)
+        elif url and url.startswith("base64://"):
+            bs64_data = url.removeprefix("base64://")
+            image_bytes = base64.b64decode(bs64_data)
+            image_file_path = f"data/temp/{uuid.uuid4()}.jpg"
+            with open(image_file_path, "wb") as f:
+                f.write(image_bytes)
+            return os.path.abspath(image_file_path)
+        elif os.path.exists(url):
+            image_file_path = url
+            return os.path.abspath(image_file_path)
+        else:
+            raise Exception(f"not a valid file: {url}")
+
+    async def convert_to_base64(self) -> str:
+        """将这个图片统一转换为 base64 编码。这个方法避免了手动判断图片数据类型，直接返回图片数据的 base64 编码。
+
+        Returns:
+            str: 图片的 base64 编码，不以 base64:// 或者 data:image/jpeg;base64, 开头。
+        """
+        # convert to base64
+        url = self.url if self.url else self.file
+        if url and url.startswith("file:///"):
+            bs64_data = file_to_base64(url[8:])
+        elif url and url.startswith("http"):
+            image_file_path = await download_image_by_url(url)
+            bs64_data = file_to_base64(image_file_path)
+        elif url and url.startswith("base64://"):
+            bs64_data = url
+        elif os.path.exists(url):
+            bs64_data = file_to_base64(url)
+        else:
+            raise Exception(f"not a valid file: {url}")
+        bs64_data = bs64_data.removeprefix("base64://")
+        return bs64_data
+
+
+class Reply(BaseMessageComponent):
+    type: ComponentType = "Reply"
+    id: T.Union[str, int]
+    """所引用的消息 ID"""
+    chain: T.Optional[T.List["BaseMessageComponent"]] = []
+    """被引用的消息段列表"""
+    sender_id: T.Optional[int] | T.Optional[str] = 0
+    """被引用的消息对应的发送者的 ID"""
+    sender_nickname: T.Optional[str] = ""
+    """被引用的消息对应的发送者的昵称"""
+    time: T.Optional[int] = 0
+    """被引用的消息发送时间"""
+    message_str: T.Optional[str] = ""
+    """被引用的消息解析后的纯文本消息字符串"""
+
+    text: T.Optional[str] = ""
+    """deprecated"""
+    qq: T.Optional[int] = 0
+    """deprecated"""
+    seq: T.Optional[int] = 0
+    """deprecated"""
+
+    def __init__(self, **_):
+        super().__init__(**_)
+
+
+class RedBag(BaseMessageComponent):
+    type: ComponentType = "RedBag"
+    title: str
+
+    def __init__(self, **_):
+        super().__init__(**_)
+
+
+class Poke(BaseMessageComponent):
+    type: str = ""
+    id: T.Optional[int] = 0
+    qq: T.Optional[int] = 0
+
+    def __init__(self, type: str, **_):
+        type = f"Poke:{type}"
+        super().__init__(type=type, **_)
+
+
+class Forward(BaseMessageComponent):
+    type: ComponentType = "Forward"
+    id: str
+
+    def __init__(self, **_):
+        super().__init__(**_)
+
+
+class Node(BaseMessageComponent):
+    """群合并转发消息"""
+
+    type: ComponentType = "Node"
+    id: T.Optional[int] = 0  # 忽略
+    name: T.Optional[str] = ""  # qq昵称
+    uin: T.Optional[int] = 0  # qq号
+    content: T.Optional[T.Union[str, list, dict]] = ""  # 子消息段列表
+    seq: T.Optional[T.Union[str, list]] = ""  # 忽略
+    time: T.Optional[int] = 0
+
+    def __init__(self, content: T.Union[str, list, dict, "Node", T.List["Node"]], **_):
+        if isinstance(content, list):
+            _content = None
+            if all(isinstance(item, Node) for item in content):
+                _content = [node.toDict() for node in content]
+            else:
+                _content = ""
+                for chain in content:
+                    _content += chain.toString()
+            content = _content
+        elif isinstance(content, Node):
+            content = content.toDict()
+        super().__init__(content=content, **_)
+
+    def toString(self):
+        # logger.warn("Protocol: node doesn't support stringify")
+        return ""
+
+
+class Nodes(BaseMessageComponent):
+    type: ComponentType = "Nodes"
+    nodes: T.List[Node]
+
+    def __init__(self, nodes: T.List[Node], **_):
+        super().__init__(nodes=nodes, **_)
+
+    def toDict(self):
+        return {"messages": [node.toDict() for node in self.nodes]}
+
+
+class Xml(BaseMessageComponent):
+    type: ComponentType = "Xml"
+    data: str
+    resid: T.Optional[int] = 0
+
+    def __init__(self, **_):
+        super().__init__(**_)
+
+
+class Json(BaseMessageComponent):
+    type: ComponentType = "Json"
+    data: T.Union[str, dict]
+    resid: T.Optional[int] = 0
+
+    def __init__(self, data, **_):
+        if isinstance(data, dict):
+            data = json.dumps(data)
+        super().__init__(data=data, **_)
+
+
+class CardImage(BaseMessageComponent):
+    type: ComponentType = "CardImage"
+    file: str
+    cache: T.Optional[bool] = True
+    minwidth: T.Optional[int] = 400
+    minheight: T.Optional[int] = 400
+    maxwidth: T.Optional[int] = 500
+    maxheight: T.Optional[int] = 500
+    source: T.Optional[str] = ""
+    icon: T.Optional[str] = ""
+
+    def __init__(self, **_):
+        super().__init__(**_)
+
+    @staticmethod
+    def fromFileSystem(path, **_):
+        return CardImage(file=f"file:///{os.path.abspath(path)}", **_)
+
+
+class TTS(BaseMessageComponent):
+    type: ComponentType = "TTS"
+    text: str
+
+    def __init__(self, **_):
+        super().__init__(**_)
+
+
+class Unknown(BaseMessageComponent):
+    type: ComponentType = "Unknown"
+    text: str
+
+    def toString(self):
+        return ""
+
+
+class File(BaseMessageComponent):
+    """
+    文件消息段
+    """
+
+    type: ComponentType = "File"
+    name: T.Optional[str] = ""  # 名字
+    _file: T.Optional[str] = ""  # 本地路径
+    url: T.Optional[str] = ""  # url
+    _downloaded: bool = False  # 是否已经下载
+
+    def __init__(self, name: str = "", file: str = "", url: str = ""):
+        super().__init__(name=name, _file=file, url=url)
+
+    @property
+    def file(self) -> str:
+        """
+        获取文件路径，如果文件不存在但有URL，则同步下载文件
+
+        Returns:
+            str: 文件路径
+        """
+        if self._file and os.path.exists(self._file):
+            return self._file
+
+        if self.url and not self._downloaded:
+            try:
+                loop = asyncio.get_event_loop()
+                if loop.is_running():
+                    logger.warning(
+                        "不可以在异步上下文中同步等待下载! 请使用 await get_file() 代替"
+                    )
+                    return ""
+                else:
+                    # 等待下载完成
+                    loop.run_until_complete(self._download_file())
+
+                    if self._file and os.path.exists(self._file):
+                        return self._file
+            except Exception as e:
+                logger.error(f"文件下载失败: {e}")
+
+        return ""
+
+    @file.setter
+    def file(self, value: str):
+        """
+        向前兼容, 设置file属性, 传入的参数可能是文件路径或URL
+
+        Args:
+            value (str): 文件路径或URL
+        """
+        if value.startswith("http://") or value.startswith("https://"):
+            self.url = value
+        else:
+            self._file = value
+
+    async def get_file(self) -> str:
+        """
+        异步获取文件
+        To 插件开发者: 请注意在使用后清理下载的文件, 以免占用过多空间
+
+        Returns:
+            str: 文件路径
+        """
+        if self._file and os.path.exists(self._file):
+            return self._file
+
+        if self.url:
+            await self._download_file()
+            return self._file
+
+        return ""
+
+    async def _download_file(self):
+        """下载文件"""
+        if self._downloaded:
+            return
+
+        os.makedirs("data/download", exist_ok=True)
+        filename = self.name or f"{uuid.uuid4().hex}"
+        file_path = f"data/download/{filename}"
+
+        await download_file(self.url, file_path)
+
+        self._file = file_path
+        self._downloaded = True
+
+
+class WechatEmoji(BaseMessageComponent):
+    type: ComponentType = "WechatEmoji"
+    md5: T.Optional[str] = ""
+    md5_len: T.Optional[int] = 0
+    cdnurl: T.Optional[str] = ""
+
+    def __init__(self, **_):
+        super().__init__(**_)
+
+
+ComponentTypes = {
+    "plain": Plain,
+    "text": Plain,
+    "face": Face,
+    "record": Record,
+    "video": Video,
+    "at": At,
+    "rps": RPS,
+    "dice": Dice,
+    "shake": Shake,
+    "anonymous": Anonymous,
+    "share": Share,
+    "contact": Contact,
+    "location": Location,
+    "music": Music,
+    "image": Image,
+    "reply": Reply,
+    "redbag": RedBag,
+    "poke": Poke,
+    "forward": Forward,
+    "node": Node,
+    "nodes": Nodes,
+    "xml": Xml,
+    "json": Json,
+    "cardimage": CardImage,
+    "tts": TTS,
+    "unknown": Unknown,
+    "file": File,
+    "WechatEmoji": WechatEmoji,
+}

astrbot/core/message/message_event_result.py

@@ -0,0 +1,222 @@
+import enum
+
+from typing import List, Optional, Union, AsyncGenerator
+from dataclasses import dataclass, field
+from astrbot.core.message.components import (
+    BaseMessageComponent,
+    Plain,
+    Image,
+    At,
+    AtAll,
+)
+from typing_extensions import deprecated
+
+
+@dataclass
+class MessageChain:
+    """MessageChain 描述了一整条消息中带有的所有组件。
+    现代消息平台的一条富文本消息中可能由多个组件构成，如文本、图片、At 等，并且保留了顺序。
+
+    Attributes:
+        `chain` (list): 用于顺序存储各个组件。
+        `use_t2i_` (bool): 用于标记是否使用文本转图片服务。默认为 None，即跟随用户的设置。当设置为 True 时，将会使用文本转图片服务。
+    """
+
+    chain: List[BaseMessageComponent] = field(default_factory=list)
+    use_t2i_: Optional[bool] = None  # None 为跟随用户设置
+
+    def message(self, message: str):
+        """添加一条文本消息到消息链 `chain` 中。
+
+        Example:
+
+            CommandResult().message("Hello ").message("world!")
+            # 输出 Hello world!
+
+        """
+        self.chain.append(Plain(message))
+        return self
+
+    def at(self, name: str, qq: Union[str, int]):
+        """添加一条 At 消息到消息链 `chain` 中。
+
+        Example:
+
+            CommandResult().at("张三", "12345678910")
+            # 输出 @张三
+
+        """
+        self.chain.append(At(name=name, qq=qq))
+        return self
+
+    def at_all(self):
+        """添加一条 AtAll 消息到消息链 `chain` 中。
+
+        Example:
+
+            CommandResult().at_all()
+            # 输出 @所有人
+
+        """
+        self.chain.append(AtAll())
+        return self
+
+    @deprecated("请使用 message 方法代替。")
+    def error(self, message: str):
+        """添加一条错误消息到消息链 `chain` 中
+
+        Example:
+
+            CommandResult().error("解析失败")
+
+        """
+        self.chain.append(Plain(message))
+        return self
+
+    def url_image(self, url: str):
+        """添加一条图片消息（https 链接）到消息链 `chain` 中。
+
+        Note:
+            如果需要发送本地图片，请使用 `file_image` 方法。
+
+        Example:
+
+            CommandResult().image("https://example.com/image.jpg")
+
+        """
+        self.chain.append(Image.fromURL(url))
+        return self
+
+    def file_image(self, path: str):
+        """添加一条图片消息（本地文件路径）到消息链 `chain` 中。
+
+        Note:
+            如果需要发送网络图片，请使用 `url_image` 方法。
+
+        CommandResult().image("image.jpg")
+        """
+        self.chain.append(Image.fromFileSystem(path))
+        return self
+
+    def use_t2i(self, use_t2i: bool):
+        """设置是否使用文本转图片服务。
+
+        Args:
+            use_t2i (bool): 是否使用文本转图片服务。默认为 None，即跟随用户的设置。当设置为 True 时，将会使用文本转图片服务。
+        """
+        self.use_t2i_ = use_t2i
+        return self
+
+    def get_plain_text(self) -> str:
+        """获取纯文本消息。这个方法将获取 chain 中所有 Plain 组件的文本并拼接成一条消息。空格分隔。"""
+        return " ".join([comp.text for comp in self.chain if isinstance(comp, Plain)])
+
+    def squash_plain(self):
+        """将消息链中的所有 Plain 消息段聚合到第一个 Plain 消息段中。"""
+        if not self.chain:
+            return
+
+        new_chain = []
+        first_plain = None
+        plain_texts = []
+
+        for comp in self.chain:
+            if isinstance(comp, Plain):
+                if first_plain is None:
+                    first_plain = comp
+                    new_chain.append(comp)
+                plain_texts.append(comp.text)
+            else:
+                new_chain.append(comp)
+
+        if first_plain is not None:
+            first_plain.text = "".join(plain_texts)
+
+        self.chain = new_chain
+        return self
+
+
+class EventResultType(enum.Enum):
+    """用于描述事件处理的结果类型。
+
+    Attributes:
+        CONTINUE: 事件将会继续传播
+        STOP: 事件将会终止传播
+    """
+
+    CONTINUE = enum.auto()
+    STOP = enum.auto()
+
+
+class ResultContentType(enum.Enum):
+    """用于描述事件结果的内容的类型。"""
+
+    LLM_RESULT = enum.auto()
+    """调用 LLM 产生的结果"""
+    GENERAL_RESULT = enum.auto()
+    """普通的消息结果"""
+    STREAMING_RESULT = enum.auto()
+    """调用 LLM 产生的流式结果"""
+    STREAMING_FINISH= enum.auto()
+    """流式输出完成"""
+
+
+@dataclass
+class MessageEventResult(MessageChain):
+    """MessageEventResult 描述了一整条消息中带有的所有组件以及事件处理的结果。
+    现代消息平台的一条富文本消息中可能由多个组件构成，如文本、图片、At 等，并且保留了顺序。
+
+    Attributes:
+        `chain` (list): 用于顺序存储各个组件。
+        `use_t2i_` (bool): 用于标记是否使用文本转图片服务。默认为 None，即跟随用户的设置。当设置为 True 时，将会使用文本转图片服务。
+        `result_type` (EventResultType): 事件处理的结果类型。
+    """
+
+    result_type: Optional[EventResultType] = field(
+        default_factory=lambda: EventResultType.CONTINUE
+    )
+
+    result_content_type: Optional[ResultContentType] = field(
+        default_factory=lambda: ResultContentType.GENERAL_RESULT
+    )
+
+    async_stream: Optional[AsyncGenerator] = None
+    """异步流"""
+
+    def stop_event(self) -> "MessageEventResult":
+        """终止事件传播。"""
+        self.result_type = EventResultType.STOP
+        return self
+
+    def continue_event(self) -> "MessageEventResult":
+        """继续事件传播。"""
+        self.result_type = EventResultType.CONTINUE
+        return self
+
+    def is_stopped(self) -> bool:
+        """
+        是否终止事件传播。
+        """
+        return self.result_type == EventResultType.STOP
+
+    def set_async_stream(self, stream: AsyncGenerator) -> "MessageEventResult":
+        """设置异步流。"""
+        self.async_stream = stream
+        return self
+
+    def set_result_content_type(self, typ: ResultContentType) -> "MessageEventResult":
+        """设置事件处理的结果类型。
+
+        Args:
+            result_type (EventResultType): 事件处理的结果类型。
+        """
+        self.result_content_type = typ
+        return self
+
+    def is_llm_result(self) -> bool:
+        """是否为 LLM 结果。"""
+        return self.result_content_type == ResultContentType.LLM_RESULT
+
+
+# 为了兼容旧版代码，保留 CommandResult 的别名
+CommandResult = MessageEventResult

astrbot/core/pipeline/__init__.py

@@ -0,0 +1,41 @@
+from astrbot.core.message.message_event_result import (
+    MessageEventResult,
+    EventResultType,
+)
+
+from .waking_check.stage import WakingCheckStage
+from .whitelist_check.stage import WhitelistCheckStage
+from .rate_limit_check.stage import RateLimitStage
+from .content_safety_check.stage import ContentSafetyCheckStage
+from .platform_compatibility.stage import PlatformCompatibilityStage
+from .preprocess_stage.stage import PreProcessStage
+from .process_stage.stage import ProcessStage
+from .result_decorate.stage import ResultDecorateStage
+from .respond.stage import RespondStage
+
+# 管道阶段顺序
+STAGES_ORDER = [
+    "WakingCheckStage",  # 检查是否需要唤醒
+    "WhitelistCheckStage",  # 检查是否在群聊/私聊白名单
+    "RateLimitStage",  # 检查会话是否超过频率限制
+    "ContentSafetyCheckStage",  # 检查内容安全
+    "PlatformCompatibilityStage",  # 检查所有处理器的平台兼容性
+    "PreProcessStage",  # 预处理
+    "ProcessStage",  # 交由 Stars 处理（a.k.a 插件），或者 LLM 调用
+    "ResultDecorateStage",  # 处理结果，比如添加回复前缀、t2i、转换为语音 等
+    "RespondStage",  # 发送消息
+]
+
+__all__ = [
+    "WakingCheckStage",
+    "WhitelistCheckStage",
+    "RateLimitStage",
+    "ContentSafetyCheckStage",
+    "PlatformCompatibilityStage",
+    "PreProcessStage",
+    "ProcessStage",
+    "ResultDecorateStage",
+    "RespondStage",
+    "MessageEventResult",
+    "EventResultType",
+]

astrbot/core/pipeline/content_safety_check/stage.py

@@ -0,0 +1,37 @@
+from typing import Union, AsyncGenerator
+from ..stage import Stage, register_stage
+from ..context import PipelineContext
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core.message.message_event_result import MessageEventResult
+from astrbot.core import logger
+from .strategies.strategy import StrategySelector
+
+
+@register_stage
+class ContentSafetyCheckStage(Stage):
+    """检查内容安全
+
+    当前只会检查文本的。
+    """
+
+    async def initialize(self, ctx: PipelineContext):
+        config = ctx.astrbot_config["content_safety"]
+        self.strategy_selector = StrategySelector(config)
+
+    async def process(
+        self, event: AstrMessageEvent, check_text: str = None
+    ) -> Union[None, AsyncGenerator[None, None]]:
+        """检查内容安全"""
+        text = check_text if check_text else event.get_message_str()
+        ok, info = self.strategy_selector.check(text)
+        if not ok:
+            if event.is_at_or_wake_command:
+                event.set_result(
+                    MessageEventResult().message(
+                        "你的消息或者大模型的响应中包含不适当的内容，已被屏蔽。"
+                    )
+                )
+                yield
+            event.stop_event()
+            logger.info(f"内容安全检查不通过，原因：{info}")
+            return

astrbot/core/pipeline/content_safety_check/strategies/__init__.py

@@ -0,0 +1,8 @@
+import abc
+from typing import Tuple
+
+
+class ContentSafetyStrategy(abc.ABC):
+    @abc.abstractmethod
+    def check(self, content: str) -> Tuple[bool, str]:
+        raise NotImplementedError

astrbot/core/pipeline/content_safety_check/strategies/baidu_aip.py

@@ -0,0 +1,30 @@
+"""
+使用此功能应该先 pip install baidu-aip
+"""
+
+from . import ContentSafetyStrategy
+from aip import AipContentCensor
+
+
+class BaiduAipStrategy(ContentSafetyStrategy):
+    def __init__(self, appid: str, ak: str, sk: str) -> None:
+        self.app_id = appid
+        self.api_key = ak
+        self.secret_key = sk
+        self.client = AipContentCensor(self.app_id, self.api_key, self.secret_key)
+
+    def check(self, content: str):
+        res = self.client.textCensorUserDefined(content)
+        if "conclusionType" not in res:
+            return False, ""
+        if res["conclusionType"] == 1:
+            return True, ""
+        else:
+            if "data" not in res:
+                return False, ""
+            count = len(res["data"])
+            info = f"百度审核服务发现 {count} 处违规：\n"
+            for i in res["data"]:
+                info += f"{i['msg']}；\n"
+            info += "\n判断结果：" + res["conclusion"]
+            return False, info

astrbot/core/pipeline/content_safety_check/strategies/keywords.py

@@ -0,0 +1,23 @@
+import re
+from . import ContentSafetyStrategy
+
+
+class KeywordsStrategy(ContentSafetyStrategy):
+    def __init__(self, extra_keywords: list) -> None:
+        self.keywords = []
+        if extra_keywords is None:
+            extra_keywords = []
+        self.keywords.extend(extra_keywords)
+        # keywords_path = os.path.join(os.path.dirname(__file__), "unfit_words")
+        # internal keywords
+        # if os.path.exists(keywords_path):
+        #     with open(keywords_path, "r", encoding="utf-8") as f:
+        #         self.keywords.extend(
+        #             json.loads(base64.b64decode(f.read()).decode("utf-8"))["keywords"]
+        #         )
+
+    def check(self, content: str) -> bool:
+        for keyword in self.keywords:
+            if re.search(keyword, content):
+                return False, "内容安全检查不通过，匹配到敏感词。"
+        return True, ""

astrbot/core/pipeline/content_safety_check/strategies/strategy.py

@@ -0,0 +1,34 @@
+from . import ContentSafetyStrategy
+from typing import List, Tuple
+from astrbot import logger
+
+
+class StrategySelector:
+    def __init__(self, config: dict) -> None:
+        self.enabled_strategies: List[ContentSafetyStrategy] = []
+        if config["internal_keywords"]["enable"]:
+            from .keywords import KeywordsStrategy
+
+            self.enabled_strategies.append(
+                KeywordsStrategy(config["internal_keywords"]["extra_keywords"])
+            )
+        if config["baidu_aip"]["enable"]:
+            try:
+                from .baidu_aip import BaiduAipStrategy
+            except ImportError:
+                logger.warning("使用百度内容审核应该先 pip install baidu-aip")
+                return
+            self.enabled_strategies.append(
+                BaiduAipStrategy(
+                    config["baidu_aip"]["app_id"],
+                    config["baidu_aip"]["api_key"],
+                    config["baidu_aip"]["secret_key"],
+                )
+            )
+
+    def check(self, content: str) -> Tuple[bool, str]:
+        for strategy in self.enabled_strategies:
+            ok, info = strategy.check(content)
+            if not ok:
+                return False, info
+        return True, ""

astrbot/core/pipeline/context.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+from astrbot.core.config.astrbot_config import AstrBotConfig
+from astrbot.core.star import PluginManager
+
+
+@dataclass
+class PipelineContext:
+    """上下文对象，包含管道执行所需的上下文信息"""
+
+    astrbot_config: AstrBotConfig  # AstrBot 配置对象
+    plugin_manager: PluginManager  # 插件管理器对象

astrbot/core/pipeline/platform_compatibility/stage.py

@@ -0,0 +1,56 @@
+from ..stage import Stage, register_stage
+from ..context import PipelineContext
+from typing import Union, AsyncGenerator
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core.star.star import star_map
+from astrbot.core.star.star_handler import StarHandlerMetadata
+from astrbot.core import logger
+
+
+@register_stage
+class PlatformCompatibilityStage(Stage):
+    """检查所有处理器的平台兼容性。
+
+    这个阶段会检查所有处理器是否在当前平台启用，如果未启用则设置platform_compatible属性为False。
+    """
+
+    async def initialize(self, ctx: PipelineContext) -> None:
+        """初始化平台兼容性检查阶段
+
+        Args:
+            ctx (PipelineContext): 消息管道上下文对象, 包括配置和插件管理器
+        """
+        self.ctx = ctx
+
+    async def process(
+        self, event: AstrMessageEvent
+    ) -> Union[None, AsyncGenerator[None, None]]:
+        # 获取当前平台ID
+        platform_id = event.get_platform_id()
+
+        # 获取已激活的处理器
+        activated_handlers = event.get_extra("activated_handlers")
+        if activated_handlers is None:
+            activated_handlers = []
+
+        # 标记不兼容的处理器
+        for handler in activated_handlers:
+            if not isinstance(handler, StarHandlerMetadata):
+                continue
+            # 检查处理器是否在当前平台启用
+            enabled = handler.is_enabled_for_platform(platform_id)
+            if not enabled:
+                if handler.handler_module_path in star_map:
+                    plugin_name = star_map[handler.handler_module_path].name
+                logger.debug(
+                    f"[PlatformCompatibilityStage] 插件 {plugin_name} 在平台 {platform_id} 未启用，标记处理器 {handler.handler_name} 为平台不兼容"
+                )
+                # 设置处理器为平台不兼容状态
+                # TODO: 更好的标记方式
+                handler.platform_compatible = False
+            else:
+                # 确保处理器为平台兼容状态
+                handler.platform_compatible = True
+
+        # 更新已激活的处理器列表
+        event.set_extra("activated_handlers", activated_handlers)

astrbot/core/pipeline/preprocess_stage/stage.py

@@ -0,0 +1,73 @@
+import traceback
+import asyncio
+from typing import Union, AsyncGenerator
+from ..stage import Stage, register_stage
+from ..context import PipelineContext
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core import logger
+from astrbot.core.message.components import Plain, Record, Image
+
+
+@register_stage
+class PreProcessStage(Stage):
+    async def initialize(self, ctx: PipelineContext) -> None:
+        self.ctx = ctx
+        self.config = ctx.astrbot_config
+        self.plugin_manager = ctx.plugin_manager
+
+        self.stt_settings: dict = self.config.get("provider_stt_settings", {})
+        self.platform_settings: dict = self.config.get("platform_settings", {})
+
+    async def process(
+        self, event: AstrMessageEvent
+    ) -> Union[None, AsyncGenerator[None, None]]:
+        """在处理事件之前的预处理"""
+        # 路径映射
+        if mappings := self.platform_settings.get("path_mapping", []):
+            # 支持 Record，Image 消息段的路径映射。
+            message_chain = event.get_messages()
+
+            for idx, component in enumerate(message_chain):
+                if isinstance(component, (Record, Image)) and component.url:
+                    for mapping in mappings:
+                        from_, to_ = mapping.split(":")
+                        from_ = from_.removesuffix("/")
+                        to_ = to_.removesuffix("/")
+
+                        url = component.url.removeprefix("file://")
+                        if url.startswith(from_):
+                            component.url = url.replace(from_, to_, 1)
+                            logger.debug(f"路径映射: {url} -> {component.url}")
+                    message_chain[idx] = component
+
+        # STT
+        if self.stt_settings.get("enable", False):
+            # TODO: 独立
+            stt_provider = (
+                self.plugin_manager.context.provider_manager.curr_stt_provider_inst
+            )
+            if stt_provider:
+                message_chain = event.get_messages()
+                for idx, component in enumerate(message_chain):
+                    if isinstance(component, Record) and component.url:
+                        path = component.url.removeprefix("file://")
+                        retry = 5
+                        for i in range(retry):
+                            try:
+                                result = await stt_provider.get_text(audio_url=path)
+                                if result:
+                                    logger.info("语音转文本结果: " + result)
+                                    message_chain[idx] = Plain(result)
+                                    event.message_str += result
+                                    event.message_obj.message_str += result
+                                break
+                            except FileNotFoundError as e:
+                                # napcat workaround
+                                logger.warning(e)
+                                logger.warning(f"重试中: {i + 1}/{retry}")
+                                await asyncio.sleep(0.5)
+                                continue
+                            except BaseException as e:
+                                logger.error(traceback.format_exc())
+                                logger.error(f"语音转文本失败: {e}")
+                                break

astrbot/core/pipeline/process_stage/method/llm_request.py

@@ -0,0 +1,606 @@
+"""
+本地 Agent 模式的 LLM 调用 Stage
+"""
+
+import traceback
+import asyncio
+import json
+from typing import Union, AsyncGenerator
+from ...context import PipelineContext
+from ..stage import Stage
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core.message.message_event_result import (
+    MessageEventResult,
+    ResultContentType,
+    MessageChain,
+)
+from astrbot.core.message.components import Image
+from astrbot.core import logger
+from astrbot.core.utils.metrics import Metric
+from astrbot.core.provider.entities import (
+    ProviderRequest,
+    LLMResponse,
+    ToolCallMessageSegment,
+    AssistantMessageSegment,
+    ToolCallsResult,
+)
+from astrbot.core.star.star_handler import star_handlers_registry, EventType
+from astrbot.core.star.star import star_map
+from mcp.types import (
+    TextContent,
+    ImageContent,
+    EmbeddedResource,
+    TextResourceContents,
+    BlobResourceContents,
+)
+
+
+class LLMRequestSubStage(Stage):
+    async def initialize(self, ctx: PipelineContext) -> None:
+        self.ctx = ctx
+        self.bot_wake_prefixs = ctx.astrbot_config["wake_prefix"]  # list
+        self.provider_wake_prefix = ctx.astrbot_config["provider_settings"][
+            "wake_prefix"
+        ]  # str
+        self.max_context_length = ctx.astrbot_config["provider_settings"][
+            "max_context_length"
+        ]  # int
+        self.dequeue_context_length = min(
+            max(1, ctx.astrbot_config["provider_settings"]["dequeue_context_length"]),
+            self.max_context_length - 1,
+        )  # int
+        self.streaming_response = ctx.astrbot_config["provider_settings"][
+            "streaming_response"
+        ]  # bool
+
+        for bwp in self.bot_wake_prefixs:
+            if self.provider_wake_prefix.startswith(bwp):
+                logger.info(
+                    f"识别 LLM 聊天额外唤醒前缀 {self.provider_wake_prefix} 以机器人唤醒前缀 {bwp} 开头，已自动去除。"
+                )
+                self.provider_wake_prefix = self.provider_wake_prefix[len(bwp) :]
+
+        self.conv_manager = ctx.plugin_manager.context.conversation_manager
+
+    async def process(
+        self, event: AstrMessageEvent, _nested: bool = False
+    ) -> Union[None, AsyncGenerator[None, None]]:
+        req: ProviderRequest = None
+
+        provider = self.ctx.plugin_manager.context.get_using_provider()
+        if provider is None:
+            return
+
+        if event.get_extra("provider_request"):
+            req = event.get_extra("provider_request")
+            assert isinstance(req, ProviderRequest), (
+                "provider_request 必须是 ProviderRequest 类型。"
+            )
+
+            if req.conversation:
+                all_contexts = json.loads(req.conversation.history)
+                req.contexts = self._process_tool_message_pairs(
+                    all_contexts, remove_tags=True
+                )
+
+        else:
+            req = ProviderRequest(prompt="", image_urls=[])
+            if self.provider_wake_prefix:
+                if not event.message_str.startswith(self.provider_wake_prefix):
+                    return
+            req.prompt = event.message_str[len(self.provider_wake_prefix) :]
+            req.func_tool = self.ctx.plugin_manager.context.get_llm_tool_manager()
+            for comp in event.message_obj.message:
+                if isinstance(comp, Image):
+                    image_path = await comp.convert_to_file_path()
+                    req.image_urls.append(image_path)
+
+            # 获取对话上下文
+            conversation_id = await self.conv_manager.get_curr_conversation_id(
+                event.unified_msg_origin
+            )
+            if not conversation_id:
+                conversation_id = await self.conv_manager.new_conversation(
+                    event.unified_msg_origin
+                )
+            conversation = await self.conv_manager.get_conversation(
+                event.unified_msg_origin, conversation_id
+            )
+            if not conversation:
+                conversation_id = await self.conv_manager.new_conversation(
+                    event.unified_msg_origin
+                )
+                conversation = await self.conv_manager.get_conversation(
+                    event.unified_msg_origin, conversation_id
+                )
+            req.conversation = conversation
+            req.contexts = json.loads(conversation.history)
+
+            event.set_extra("provider_request", req)
+
+        if not req.prompt and not req.image_urls:
+            return
+
+        # 执行请求 LLM 前事件钩子。
+        # 装饰 system_prompt 等功能
+        # 获取当前平台ID
+        platform_id = event.get_platform_id()
+        handlers = star_handlers_registry.get_handlers_by_event_type(
+            EventType.OnLLMRequestEvent, platform_id=platform_id
+        )
+        for handler in handlers:
+            try:
+                logger.debug(
+                    f"hook(on_llm_request) -> {star_map[handler.handler_module_path].name} - {handler.handler_name}"
+                )
+                await handler.handler(event, req)
+            except BaseException:
+                logger.error(traceback.format_exc())
+
+            if event.is_stopped():
+                logger.info(
+                    f"{star_map[handler.handler_module_path].name} - {handler.handler_name} 终止了事件传播。"
+                )
+                return
+
+        if isinstance(req.contexts, str):
+            req.contexts = json.loads(req.contexts)
+
+        # max context length
+        if (
+            self.max_context_length != -1  # -1 为不限制
+            and len(req.contexts) // 2 > self.max_context_length
+        ):
+            logger.debug("上下文长度超过限制，将截断。")
+            req.contexts = req.contexts[
+                -(self.max_context_length - self.dequeue_context_length + 1) * 2 :
+            ]
+            # 找到第一个role 为 user 的索引，确保上下文格式正确
+            index = next(
+                (
+                    i
+                    for i, item in enumerate(req.contexts)
+                    if item.get("role") == "user"
+                ),
+                None,
+            )
+            if index is not None and index > 0:
+                req.contexts = req.contexts[index:]
+
+        # session_id
+        if not req.session_id:
+            req.session_id = event.unified_msg_origin
+
+        async def requesting(req: ProviderRequest):
+            try:
+                need_loop = True
+                while need_loop:
+                    need_loop = False
+                    logger.debug(f"提供商请求 Payload: {req}")
+
+                    final_llm_response = None
+
+                    if self.streaming_response:
+                        stream = provider.text_chat_stream(**req.__dict__)
+                        async for llm_response in stream:
+                            if llm_response.is_chunk:
+                                if llm_response.result_chain:
+                                    yield llm_response.result_chain  # MessageChain
+                                else:
+                                    yield MessageChain().message(
+                                        llm_response.completion_text
+                                    )
+                            else:
+                                final_llm_response = llm_response
+                    else:
+                        final_llm_response = await provider.text_chat(
+                            **req.__dict__
+                        )  # 请求 LLM
+
+                    if not final_llm_response:
+                        raise Exception("LLM response is None.")
+
+                    # 执行 LLM 响应后的事件钩子。
+                    handlers = star_handlers_registry.get_handlers_by_event_type(
+                        EventType.OnLLMResponseEvent
+                    )
+                    for handler in handlers:
+                        try:
+                            logger.debug(
+                                f"hook(on_llm_response) -> {star_map[handler.handler_module_path].name} - {handler.handler_name}"
+                            )
+                            await handler.handler(event, final_llm_response)
+                        except BaseException:
+                            logger.error(traceback.format_exc())
+
+                        if event.is_stopped():
+                            logger.info(
+                                f"{star_map[handler.handler_module_path].name} - {handler.handler_name} 终止了事件传播。"
+                            )
+                            return
+
+                    if self.streaming_response:
+                        # 流式输出的处理
+                        async for result in self._handle_llm_stream_response(
+                            event, req, final_llm_response
+                        ):
+                            if isinstance(result, ProviderRequest):
+                                # 有函数工具调用并且返回了结果，我们需要再次请求 LLM
+                                req = result
+                                need_loop = True
+                            else:
+                                yield
+                    else:
+                        # 非流式输出的处理
+                        async for result in self._handle_llm_response(
+                            event, req, final_llm_response
+                        ):
+                            if isinstance(result, ProviderRequest):
+                                # 有函数工具调用并且返回了结果，我们需要再次请求 LLM
+                                req = result
+                                need_loop = True
+                            else:
+                                yield
+
+                asyncio.create_task(
+                    Metric.upload(
+                        llm_tick=1,
+                        model_name=provider.get_model(),
+                        provider_type=provider.meta().type,
+                    )
+                )
+
+                # 保存到历史记录
+                await self._save_to_history(event, req, final_llm_response)
+
+            except BaseException as e:
+                logger.error(traceback.format_exc())
+                event.set_result(
+                    MessageEventResult().message(
+                        f"AstrBot 请求失败。\n错误类型: {type(e).__name__}\n错误信息: {str(e)}"
+                    )
+                )
+
+        if not self.streaming_response:
+            event.set_extra("tool_call_result", None)
+            async for _ in requesting(req):
+                yield
+        else:
+            event.set_result(
+                MessageEventResult()
+                .set_result_content_type(ResultContentType.STREAMING_RESULT)
+                .set_async_stream(requesting(req))
+            )
+            # 这里使用yield来暂停当前阶段，等待流式输出完成后继续处理
+            yield
+
+            if event.get_extra("tool_call_result"):
+                event.set_result(event.get_extra("tool_call_result"))
+                event.set_extra("tool_call_result", None)
+                yield
+
+        # 暂时直接发出去
+        if img_b64 := event.get_extra("tool_call_img_respond"):
+            await event.send(MessageChain(chain=[Image.fromBase64(img_b64)]))
+            event.set_extra("tool_call_img_respond", None)
+            yield
+
+    async def _handle_llm_response(
+        self,
+        event: AstrMessageEvent,
+        req: ProviderRequest,
+        llm_response: LLMResponse,
+    ) -> AsyncGenerator[Union[None, ProviderRequest], None]:
+        """处理非流式 LLM 响应。
+
+        Returns:
+            AsyncGenerator[Union[None, ProviderRequest], None]: 如果返回 ProviderRequest，表示需要再次调用 LLM
+
+        Yields:
+            Iterator[Union[None, ProviderRequest]]: 将 event 交付给下一个 stage 或者返回 ProviderRequest 表示需要再次调用 LLM
+        """
+        if llm_response.role == "assistant":
+            # text completion
+            if llm_response.result_chain:
+                event.set_result(
+                    MessageEventResult(
+                        chain=llm_response.result_chain.chain
+                    ).set_result_content_type(ResultContentType.LLM_RESULT)
+                )
+            else:
+                event.set_result(
+                    MessageEventResult()
+                    .message(llm_response.completion_text)
+                    .set_result_content_type(ResultContentType.LLM_RESULT)
+                )
+        elif llm_response.role == "err":
+            event.set_result(
+                MessageEventResult().message(
+                    f"AstrBot 请求失败。\n错误信息: {llm_response.completion_text}"
+                )
+            )
+        elif llm_response.role == "tool":
+            # 处理函数工具调用
+            async for result in self._handle_function_tools(event, req, llm_response):
+                yield result
+
+    async def _handle_llm_stream_response(
+        self,
+        event: AstrMessageEvent,
+        req: ProviderRequest,
+        llm_response: LLMResponse,
+    ) -> AsyncGenerator[Union[None, ProviderRequest], None]:
+        """处理流式 LLM 响应。
+
+        专门用于处理流式输出完成后的响应，与非流式响应处理分离。
+
+        Returns:
+            AsyncGenerator[Union[None, ProviderRequest], None]: 如果返回 ProviderRequest，表示需要再次调用 LLM
+
+        Yields:
+            Iterator[Union[None, ProviderRequest]]: 将 event 交付给下一个 stage 或者返回 ProviderRequest 表示需要再次调用 LLM
+        """
+        if llm_response.role == "assistant":
+            # text completion
+            if llm_response.result_chain:
+                event.set_result(
+                    MessageEventResult(
+                        chain=llm_response.result_chain.chain
+                    ).set_result_content_type(ResultContentType.STREAMING_FINISH)
+                )
+            else:
+                event.set_result(
+                    MessageEventResult()
+                    .message(llm_response.completion_text)
+                    .set_result_content_type(ResultContentType.STREAMING_FINISH)
+                )
+        elif llm_response.role == "err":
+            event.set_result(
+                MessageEventResult().message(
+                    f"AstrBot 请求失败。\n错误信息: {llm_response.completion_text}"
+                )
+            )
+        elif llm_response.role == "tool":
+            # 处理函数工具调用
+            async for result in self._handle_function_tools(event, req, llm_response):
+                yield result
+
+    async def _handle_function_tools(
+        self,
+        event: AstrMessageEvent,
+        req: ProviderRequest,
+        llm_response: LLMResponse,
+    ) -> AsyncGenerator[Union[None, ProviderRequest], None]:
+        """处理函数工具调用。
+
+        Returns:
+            AsyncGenerator[Union[None, ProviderRequest], None]: 如果返回 ProviderRequest，表示需要再次调用 LLM
+        """
+        # function calling
+        tool_call_result: list[ToolCallMessageSegment] = []
+        logger.info(
+            f"触发 {len(llm_response.tools_call_name)} 个函数调用: {llm_response.tools_call_name}"
+        )
+        for func_tool_name, func_tool_args, func_tool_id in zip(
+            llm_response.tools_call_name,
+            llm_response.tools_call_args,
+            llm_response.tools_call_ids,
+        ):
+            try:
+                func_tool = req.func_tool.get_func(func_tool_name)
+                if func_tool.origin == "mcp":
+                    logger.info(
+                        f"从 MCP 服务 {func_tool.mcp_server_name} 调用工具函数：{func_tool.name}，参数：{func_tool_args}"
+                    )
+                    client = req.func_tool.mcp_client_dict[func_tool.mcp_server_name]
+                    res = await client.session.call_tool(func_tool.name, func_tool_args)
+                    if res:
+                        # TODO 仅对ImageContent | EmbeddedResource进行了简单的Fallback
+                        if isinstance(res.content[0], TextContent):
+                            tool_call_result.append(
+                                ToolCallMessageSegment(
+                                    role="tool",
+                                    tool_call_id=func_tool_id,
+                                    content=res.content[0].text,
+                                )
+                            )
+                        elif isinstance(res.content[0], ImageContent):
+                            tool_call_result.append(
+                                ToolCallMessageSegment(
+                                    role="tool",
+                                    tool_call_id=func_tool_id,
+                                    content="返回了图片(已直接发送给用户)",
+                                )
+                            )
+                            event.set_extra(
+                                "tool_call_img_respond",
+                                res.content[0].data,
+                            )
+                        elif isinstance(res.content[0], EmbeddedResource):
+                            resource = res.content[0].resource
+                            if isinstance(resource, TextResourceContents):
+                                tool_call_result.append(
+                                    ToolCallMessageSegment(
+                                        role="tool",
+                                        tool_call_id=func_tool_id,
+                                        content=resource.text,
+                                    )
+                                )
+                            elif (
+                                isinstance(resource, BlobResourceContents)
+                                and resource.mimeType
+                                and resource.mimeType.startswith("image/")
+                            ):
+                                tool_call_result.append(
+                                    ToolCallMessageSegment(
+                                        role="tool",
+                                        tool_call_id=func_tool_id,
+                                        content="返回了图片(已直接发送给用户)",
+                                    )
+                                )
+                                event.set_extra(
+                                    "tool_call_img_respond",
+                                    res.content[0].data,
+                                )
+                            else:
+                                tool_call_result.append(
+                                    ToolCallMessageSegment(
+                                        role="tool",
+                                        tool_call_id=func_tool_id,
+                                        content="返回的数据类型不受支持",
+                                    )
+                                )
+                else:
+                    # 获取处理器，过滤掉平台不兼容的处理器
+                    platform_id = event.get_platform_id()
+                    star_md = star_map.get(func_tool.handler_module_path)
+                    if (
+                        star_md
+                        and platform_id in star_md.supported_platforms
+                        and not star_md.supported_platforms[platform_id]
+                    ):
+                        logger.debug(
+                            f"处理器 {func_tool_name}({star_md.name}) 在当前平台不兼容或者被禁用，跳过执行"
+                        )
+                        # 直接跳过，不添加任何消息到tool_call_result
+                        continue
+
+                    logger.info(
+                        f"调用工具函数：{func_tool_name}，参数：{func_tool_args}"
+                    )
+                    # 尝试调用工具函数
+                    wrapper = self._call_handler(
+                        self.ctx, event, func_tool.handler, **func_tool_args
+                    )
+                    async for resp in wrapper:
+                        if resp is not None:  # 有 return 返回
+                            tool_call_result.append(
+                                ToolCallMessageSegment(
+                                    role="tool",
+                                    tool_call_id=func_tool_id,
+                                    content=resp,
+                                )
+                            )
+                        else:
+                            res = event.get_result()
+                            if res and res.chain:
+                                event.set_extra("tool_call_result", res)
+                            yield  # 有生成器返回
+                event.clear_result()  # 清除上一个 handler 的结果
+            except BaseException as e:
+                logger.warning(traceback.format_exc())
+                tool_call_result.append(
+                    ToolCallMessageSegment(
+                        role="tool",
+                        tool_call_id=func_tool_id,
+                        content=f"error: {str(e)}",
+                    )
+                )
+        if tool_call_result:
+            # 函数调用结果
+            req.func_tool = None  # 暂时不支持递归工具调用
+            assistant_msg_seg = AssistantMessageSegment(
+                role="assistant", tool_calls=llm_response.to_openai_tool_calls()
+            )
+            # 在多轮 Tool 调用的情况下，这里始终保持最新的 Tool 调用结果，减少上下文长度。
+            req.tool_calls_result = ToolCallsResult(
+                tool_calls_info=assistant_msg_seg,
+                tool_calls_result=tool_call_result,
+            )
+            yield req  # 再次执行 LLM 请求
+        else:
+            if llm_response.completion_text:
+                event.set_result(
+                    MessageEventResult().message(llm_response.completion_text)
+                )
+
+    async def _save_to_history(
+        self, event: AstrMessageEvent, req: ProviderRequest, llm_response: LLMResponse
+    ):
+        if not req or not req.conversation or not llm_response:
+            return
+
+        if llm_response.role == "assistant":
+            # 文本回复
+            contexts = req.contexts.copy()
+            contexts.append(await req.assemble_context())
+
+            # 记录并标记函数调用结果
+            if req.tool_calls_result:
+                tool_calls_messages = req.tool_calls_result.to_openai_messages()
+
+                # 添加标记
+                for message in tool_calls_messages:
+                    message["_tool_call_history"] = True
+
+                processed_tool_messages = self._process_tool_message_pairs(
+                    tool_calls_messages, remove_tags=False
+                )
+
+                contexts.extend(processed_tool_messages)
+
+            contexts.append(
+                {"role": "assistant", "content": llm_response.completion_text}
+            )
+            contexts_to_save = list(
+                filter(lambda item: "_no_save" not in item, contexts)
+            )
+            await self.conv_manager.update_conversation(
+                event.unified_msg_origin, req.conversation.cid, history=contexts_to_save
+            )
+
+    def _process_tool_message_pairs(self, messages, remove_tags=True):
+        """处理工具调用消息，确保assistant和tool消息成对出现
+
+        Args:
+            messages (list): 消息列表
+            remove_tags (bool): 是否移除_tool_call_history标记
+
+        Returns:
+            list: 处理后的消息列表，保证了assistant和对应tool消息的成对出现
+        """
+        result = []
+        i = 0
+
+        while i < len(messages):
+            current_msg = messages[i]
+
+            # 普通消息直接添加
+            if "_tool_call_history" not in current_msg:
+                result.append(current_msg.copy() if remove_tags else current_msg)
+                i += 1
+                continue
+
+            # 工具调用消息成对处理
+            if current_msg.get("role") == "assistant" and "tool_calls" in current_msg:
+                assistant_msg = current_msg.copy()
+
+                if remove_tags and "_tool_call_history" in assistant_msg:
+                    del assistant_msg["_tool_call_history"]
+
+                related_tools = []
+                j = i + 1
+                while (
+                    j < len(messages)
+                    and messages[j].get("role") == "tool"
+                    and "_tool_call_history" in messages[j]
+                ):
+                    tool_msg = messages[j].copy()
+
+                    if remove_tags:
+                        del tool_msg["_tool_call_history"]
+
+                    related_tools.append(tool_msg)
+                    j += 1
+
+                # 成对的时候添加到结果
+                if related_tools:
+                    result.append(assistant_msg)
+                    result.extend(related_tools)
+
+                i = j  # 跳过已处理
+            else:
+                # 单独的tool消息
+                i += 1
+
+        return result

astrbot/core/pipeline/process_stage/method/star_request.py

@@ -0,0 +1,67 @@
+"""
+本地 Agent 模式的 AstrBot 插件调用 Stage
+"""
+
+from ...context import PipelineContext
+from ..stage import Stage
+from typing import Dict, Any, List, AsyncGenerator, Union
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core.message.message_event_result import MessageEventResult
+from astrbot.core import logger
+from astrbot.core.star.star_handler import StarHandlerMetadata
+from astrbot.core.star.star import star_map
+import traceback
+
+
+class StarRequestSubStage(Stage):
+    async def initialize(self, ctx: PipelineContext) -> None:
+        self.curr_provider = ctx.plugin_manager.context.get_using_provider()
+        self.prompt_prefix = ctx.astrbot_config["provider_settings"]["prompt_prefix"]
+        self.identifier = ctx.astrbot_config["provider_settings"]["identifier"]
+        self.ctx = ctx
+
+    async def process(
+        self, event: AstrMessageEvent
+    ) -> Union[None, AsyncGenerator[None, None]]:
+        activated_handlers: List[StarHandlerMetadata] = event.get_extra(
+            "activated_handlers"
+        )
+        handlers_parsed_params: Dict[str, Dict[str, Any]] = event.get_extra(
+            "handlers_parsed_params"
+        )
+        if not handlers_parsed_params:
+            handlers_parsed_params = {}
+
+        for handler in activated_handlers:
+            # 检查处理器是否在当前平台兼容
+            if (
+                hasattr(handler, "platform_compatible")
+                and handler.platform_compatible is False
+            ):
+                logger.debug(
+                    f"处理器 {handler.handler_name} 在当前平台不兼容，跳过执行"
+                )
+                continue
+
+            params = handlers_parsed_params.get(handler.handler_full_name, {})
+            try:
+                if handler.handler_module_path not in star_map:
+                    continue
+                logger.debug(
+                    f"plugin -> {star_map.get(handler.handler_module_path).name} - {handler.handler_name}"
+                )
+                wrapper = self._call_handler(self.ctx, event, handler.handler, **params)
+                async for ret in wrapper:
+                    yield ret
+                event.clear_result()  # 清除上一个 handler 的结果
+            except Exception as e:
+                logger.error(traceback.format_exc())
+                logger.error(f"Star {handler.handler_full_name} handle error: {e}")
+
+                if event.is_at_or_wake_command:
+                    ret = f":(\n\n在调用插件 {star_map.get(handler.handler_module_path).name} 的处理函数 {handler.handler_name} 时出现异常：{e}"
+                    event.set_result(MessageEventResult().message(ret))
+                    yield
+                    event.clear_result()
+
+                event.stop_event()

astrbot/core/pipeline/process_stage/stage.py

@@ -0,0 +1,68 @@
+from typing import List, Union, AsyncGenerator
+from ..stage import Stage, register_stage
+from ..context import PipelineContext
+from .method.llm_request import LLMRequestSubStage
+from .method.star_request import StarRequestSubStage
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core.star.star_handler import StarHandlerMetadata
+from astrbot.core.provider.entities import ProviderRequest
+from astrbot.core import logger
+
+
+@register_stage
+class ProcessStage(Stage):
+    async def initialize(self, ctx: PipelineContext) -> None:
+        self.ctx = ctx
+        self.config = ctx.astrbot_config
+        self.plugin_manager = ctx.plugin_manager
+        self.llm_request_sub_stage = LLMRequestSubStage()
+        await self.llm_request_sub_stage.initialize(ctx)
+
+        self.star_request_sub_stage = StarRequestSubStage()
+        await self.star_request_sub_stage.initialize(ctx)
+
+    async def process(
+        self, event: AstrMessageEvent
+    ) -> Union[None, AsyncGenerator[None, None]]:
+        """处理事件"""
+        activated_handlers: List[StarHandlerMetadata] = event.get_extra(
+            "activated_handlers"
+        )
+        # 有插件 Handler 被激活
+        if activated_handlers:
+            async for resp in self.star_request_sub_stage.process(event):
+                # 生成器返回值处理
+                if isinstance(resp, ProviderRequest):
+                    # Handler 的 LLM 请求
+                    event.set_extra("provider_request", resp)
+                    _t = False
+                    async for _ in self.llm_request_sub_stage.process(event):
+                        _t = True
+                        yield
+                    if not _t:
+                        yield
+                else:
+                    yield
+
+        # 调用 LLM 相关请求
+        if not self.ctx.astrbot_config["provider_settings"].get("enable", True):
+            return
+
+        if (
+            not event._has_send_oper
+            and event.is_at_or_wake_command
+            and not event.call_llm
+        ):
+            # 是否有过发送操作 and 是否是被 @ 或者通过唤醒前缀
+            if (
+                event.get_result() and not event.get_result().is_stopped()
+            ) or not event.get_result():
+                # 事件没有终止传播
+                provider = self.ctx.plugin_manager.context.get_using_provider()
+
+                if not provider:
+                    logger.info("未找到可用的 LLM 提供商，请先前往配置服务提供商。")
+                    return
+
+                async for _ in self.llm_request_sub_stage.process(event):
+                    yield

astrbot/core/pipeline/rate_limit_check/stage.py

@@ -0,0 +1,101 @@
+import asyncio
+from datetime import datetime, timedelta
+from collections import defaultdict, deque
+from typing import DefaultDict, Deque, Union, AsyncGenerator
+from ..stage import Stage, register_stage
+from ..context import PipelineContext
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core import logger
+from astrbot.core.config.astrbot_config import RateLimitStrategy
+
+
+@register_stage
+class RateLimitStage(Stage):
+    """
+    检查是否需要限制消息发送的限流器。
+
+    使用 Fixed Window 算法。
+    如果触发限流，将 stall 流水线，直到下一个时间窗口来临时自动唤醒。
+    """
+
+    def __init__(self):
+        # 存储每个会话的请求时间队列
+        self.event_timestamps: DefaultDict[str, Deque[datetime]] = defaultdict(deque)
+        # 为每个会话设置一个锁，避免并发冲突
+        self.locks: DefaultDict[str, asyncio.Lock] = defaultdict(asyncio.Lock)
+        # 限流参数
+        self.rate_limit_count: int = 0
+        self.rate_limit_time: timedelta = timedelta(0)
+
+    async def initialize(self, ctx: PipelineContext) -> None:
+        """
+        初始化限流器，根据配置设置限流参数。
+        """
+        self.rate_limit_count = ctx.astrbot_config["platform_settings"]["rate_limit"][
+            "count"
+        ]
+        self.rate_limit_time = timedelta(
+            seconds=ctx.astrbot_config["platform_settings"]["rate_limit"]["time"]
+        )
+        self.rl_strategy = ctx.astrbot_config["platform_settings"]["rate_limit"][
+            "strategy"
+        ]  # stall or discard
+
+    async def process(
+        self, event: AstrMessageEvent
+    ) -> Union[None, AsyncGenerator[None, None]]:
+        """
+        检查并处理限流逻辑。如果触发限流，流水线会 stall 并在窗口期后自动恢复。
+
+        Args:
+            event (AstrMessageEvent): 当前消息事件。
+            ctx (PipelineContext): 流水线上下文。
+
+        Returns:
+            MessageEventResult: 继续或停止事件处理的结果。
+        """
+        session_id = event.session_id
+        now = datetime.now()
+
+        async with self.locks[session_id]:  # 确保同一会话不会并发修改队列
+            timestamps = self.event_timestamps[session_id]
+
+            self._remove_expired_timestamps(timestamps, now)
+
+            if len(timestamps) >= self.rate_limit_count:
+                # 达到限流阈值，计算下一个窗口的时间
+                next_window_time = timestamps[0] + self.rate_limit_time
+                stall_duration = (next_window_time - now).total_seconds()
+
+                match self.rl_strategy:
+                    case RateLimitStrategy.STALL.value:
+                        logger.info(
+                            f"会话 {session_id} 被限流。根据限流策略，此会话处理将被暂停 {stall_duration:.2f} 秒。"
+                        )
+                        await asyncio.sleep(stall_duration)
+                    case RateLimitStrategy.DISCARD.value:
+                        # event.set_result(MessageEventResult().message(f"会话 {session_id} 被限流。根据限流策略，此请求已被丢弃，直到您的限额于 {stall_duration:.2f} 秒后重置。"))
+                        logger.info(
+                            f"会话 {session_id} 被限流。根据限流策略，此请求已被丢弃，直到限额于 {stall_duration:.2f} 秒后重置。"
+                        )
+                        return event.stop_event()
+
+                self._remove_expired_timestamps(
+                    timestamps, now + timedelta(seconds=stall_duration)
+                )
+
+            timestamps.append(now)
+
+    def _remove_expired_timestamps(
+        self, timestamps: Deque[datetime], now: datetime
+    ) -> None:
+        """
+        移除时间窗口外的时间戳。
+
+        Args:
+            timestamps (Deque[datetime]): 当前会话的时间戳队列。
+            now (datetime): 当前时间，用于计算过期时间。
+        """
+        expiry_threshold: datetime = now - self.rate_limit_time
+        while timestamps and timestamps[0] < expiry_threshold:
+            timestamps.popleft()

astrbot/core/pipeline/respond/stage.py

@@ -0,0 +1,233 @@
+import random
+import asyncio
+import math
+import traceback
+import astrbot.core.message.components as Comp
+from typing import Union, AsyncGenerator
+from ..stage import register_stage, Stage
+from ..context import PipelineContext
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core.message.message_event_result import MessageChain, ResultContentType
+from astrbot.core import logger
+from astrbot.core.message.message_event_result import BaseMessageComponent
+from astrbot.core.star.star_handler import star_handlers_registry, EventType
+from astrbot.core.star.star import star_map
+from astrbot.core.utils.path_util import path_Mapping
+
+
+@register_stage
+class RespondStage(Stage):
+    # 组件类型到其非空判断函数的映射
+    _component_validators = {
+        Comp.Plain: lambda comp: bool(
+            comp.text and comp.text.strip()
+        ),  # 纯文本消息需要strip
+        Comp.Face: lambda comp: comp.id is not None,  # QQ表情
+        Comp.Record: lambda comp: bool(comp.file),  # 语音
+        Comp.Video: lambda comp: bool(comp.file),  # 视频
+        Comp.At: lambda comp: bool(comp.qq) or bool(comp.name),  # @
+        Comp.AtAll: lambda comp: True,  # @所有人
+        Comp.RPS: lambda comp: True,  # 不知道是啥(未完成)
+        Comp.Dice: lambda comp: True,  # 骰子(未完成)
+        Comp.Shake: lambda comp: True,  # 摇一摇(未完成)
+        Comp.Anonymous: lambda comp: True,  # 匿名(未完成)
+        Comp.Share: lambda comp: bool(comp.url) and bool(comp.title),  # 分享
+        Comp.Contact: lambda comp: True,  # 联系人(未完成)
+        Comp.Location: lambda comp: bool(comp.lat and comp.lon),  # 位置
+        Comp.Music: lambda comp: bool(comp._type)
+        and bool(comp.url)
+        and bool(comp.audio),  # 音乐
+        Comp.Image: lambda comp: bool(comp.file),  # 图片
+        Comp.Reply: lambda comp: bool(comp.id) and comp.sender_id is not None,  # 回复
+        Comp.RedBag: lambda comp: bool(comp.title),  # 红包
+        Comp.Poke: lambda comp: comp.id != 0 and comp.qq != 0,  # 戳一戳
+        Comp.Forward: lambda comp: bool(comp.id and comp.id.strip()),  # 转发
+        Comp.Node: lambda comp: bool(comp.name)
+        and comp.uin != 0
+        and bool(comp.content),  # 一个转发节点
+        Comp.Nodes: lambda comp: bool(comp.nodes),  # 多个转发节点
+        Comp.Xml: lambda comp: bool(comp.data and comp.data.strip()),  # XML
+        Comp.Json: lambda comp: bool(comp.data),  # JSON
+        Comp.CardImage: lambda comp: bool(comp.file),  # 卡片图片
+        Comp.TTS: lambda comp: bool(comp.text and comp.text.strip()),  # 语音合成
+        Comp.Unknown: lambda comp: bool(comp.text and comp.text.strip()),  # 未知消息
+        Comp.File: lambda comp: bool(comp.file),  # 文件
+        Comp.WechatEmoji: lambda comp: bool(comp.md5),  # 微信表情
+    }
+
+    async def initialize(self, ctx: PipelineContext):
+        self.ctx = ctx
+        self.config = ctx.astrbot_config
+        self.platform_settings: dict = self.config.get("platform_settings", {})
+
+        self.reply_with_mention = ctx.astrbot_config["platform_settings"][
+            "reply_with_mention"
+        ]
+        self.reply_with_quote = ctx.astrbot_config["platform_settings"][
+            "reply_with_quote"
+        ]
+
+        # 分段回复
+        self.enable_seg: bool = ctx.astrbot_config["platform_settings"][
+            "segmented_reply"
+        ]["enable"]
+        self.only_llm_result = ctx.astrbot_config["platform_settings"][
+            "segmented_reply"
+        ]["only_llm_result"]
+
+        self.interval_method = ctx.astrbot_config["platform_settings"][
+            "segmented_reply"
+        ]["interval_method"]
+        self.log_base = float(
+            ctx.astrbot_config["platform_settings"]["segmented_reply"]["log_base"]
+        )
+        interval_str: str = ctx.astrbot_config["platform_settings"]["segmented_reply"][
+            "interval"
+        ]
+        interval_str_ls = interval_str.replace(" ", "").split(",")
+        try:
+            self.interval = [float(t) for t in interval_str_ls]
+        except BaseException as e:
+            logger.error(f"解析分段回复的间隔时间失败。{e}")
+            self.interval = [1.5, 3.5]
+        logger.info(f"分段回复间隔时间：{self.interval}")
+
+    async def _word_cnt(self, text: str) -> int:
+        """分段回复 统计字数"""
+        if all(ord(c) < 128 for c in text):
+            word_count = len(text.split())
+        else:
+            word_count = len([c for c in text if c.isalnum()])
+        return word_count
+
+    async def _calc_comp_interval(self, comp: BaseMessageComponent) -> float:
+        """分段回复 计算间隔时间"""
+        if self.interval_method == "log":
+            if isinstance(comp, Comp.Plain):
+                wc = await self._word_cnt(comp.text)
+                i = math.log(wc + 1, self.log_base)
+                return random.uniform(i, i + 0.5)
+            else:
+                return random.uniform(1, 1.75)
+        else:
+            # random
+            return random.uniform(self.interval[0], self.interval[1])
+
+    async def _is_empty_message_chain(self, chain: list[BaseMessageComponent]):
+        """检查消息链是否为空
+
+        Args:
+            chain (list[BaseMessageComponent]): 包含消息对象的列表
+        """
+        if not chain:
+            return True
+
+        for comp in chain:
+            comp_type = type(comp)
+
+            # 检查组件类型是否在字典中
+            if comp_type in self._component_validators:
+                if self._component_validators[comp_type](comp):
+                    return False
+            else:
+                logger.info(f"空内容检查: 无法识别的组件类型: {comp_type.__name__}")
+
+        # 如果所有组件都为空
+        return True
+
+    async def process(
+        self, event: AstrMessageEvent
+    ) -> Union[None, AsyncGenerator[None, None]]:
+        result = event.get_result()
+        if result is None:
+            return
+        if result.result_content_type == ResultContentType.STREAMING_FINISH:
+            return
+
+        if result.result_content_type == ResultContentType.STREAMING_RESULT:
+            # 流式结果直接交付平台适配器处理
+            use_fallback = self.config.get("provider_settings", {}).get(
+                "streaming_segmented", False
+            )
+            logger.info(f"应用流式输出({event.get_platform_name()})")
+            await event._pre_send()
+            await event.send_streaming(result.async_stream, use_fallback)
+            await event._post_send()
+            return
+        elif len(result.chain) > 0:
+            # 检查路径映射
+            if mappings := self.platform_settings.get("path_mapping", []):
+                for idx, component in enumerate(result.chain):
+                    if isinstance(component, Comp.File) and component.file:
+                        # 支持 File 消息段的路径映射。
+                        component.file = path_Mapping(mappings, component.file)
+                        event.get_result().chain[idx] = component
+
+            await event._pre_send()
+
+            # 检查消息链是否为空
+            try:
+                if await self._is_empty_message_chain(result.chain):
+                    logger.info("消息为空，跳过发送阶段")
+                    event.clear_result()
+                    event.stop_event()
+                    return
+            except Exception as e:
+                logger.warning(f"空内容检查异常: {e}")
+
+            if self.enable_seg and (
+                (self.only_llm_result and result.is_llm_result())
+                or not self.only_llm_result
+            ):
+                decorated_comps = []
+                if self.reply_with_mention:
+                    for comp in result.chain:
+                        if isinstance(comp, Comp.At):
+                            decorated_comps.append(comp)
+                            result.chain.remove(comp)
+                            break
+                if self.reply_with_quote:
+                    for comp in result.chain:
+                        if isinstance(comp, Comp.Reply):
+                            decorated_comps.append(comp)
+                            result.chain.remove(comp)
+                            break
+                # 分段回复
+                for comp in result.chain:
+                    i = await self._calc_comp_interval(comp)
+                    await asyncio.sleep(i)
+                    try:
+                        await event.send(MessageChain([*decorated_comps, comp]))
+                    except Exception as e:
+                        logger.error(f"发送消息失败: {e} chain: {result.chain}")
+                        break
+            else:
+                try:
+                    await event.send(result)
+                except Exception as e:
+                    logger.error(traceback.format_exc())
+                    logger.error(f"发送消息失败: {e} chain: {result.chain}")
+            await event._post_send()
+            logger.info(
+                f"AstrBot -> {event.get_sender_name()}/{event.get_sender_id()}: {event._outline_chain(result.chain)}"
+            )
+
+        handlers = star_handlers_registry.get_handlers_by_event_type(
+            EventType.OnAfterMessageSentEvent, platform_id=event.get_platform_id()
+        )
+        for handler in handlers:
+            try:
+                logger.debug(
+                    f"hook(on_after_message_sent) -> {star_map[handler.handler_module_path].name} - {handler.handler_name}"
+                )
+                await handler.handler(event)
+            except BaseException:
+                logger.error(traceback.format_exc())
+
+            if event.is_stopped():
+                logger.info(
+                    f"{star_map[handler.handler_module_path].name} - {handler.handler_name} 终止了事件传播。"
+                )
+                return
+
+        event.clear_result()

astrbot/core/pipeline/result_decorate/stage.py

@@ -0,0 +1,260 @@
+import time
+import re
+import traceback
+from typing import Union, AsyncGenerator
+from ..stage import Stage, register_stage, registered_stages
+from ..context import PipelineContext
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core.message.message_event_result import ResultContentType
+from astrbot.core.platform.message_type import MessageType
+from astrbot.core import logger
+from astrbot.core.message.components import Plain, Image, At, Reply, Record, File, Node
+from astrbot.core import html_renderer
+from astrbot.core.star.star_handler import star_handlers_registry, EventType
+from astrbot.core.star.star import star_map
+
+
+@register_stage
+class ResultDecorateStage(Stage):
+    async def initialize(self, ctx: PipelineContext):
+        self.ctx = ctx
+        self.reply_prefix = ctx.astrbot_config["platform_settings"]["reply_prefix"]
+        self.reply_with_mention = ctx.astrbot_config["platform_settings"][
+            "reply_with_mention"
+        ]
+        self.reply_with_quote = ctx.astrbot_config["platform_settings"][
+            "reply_with_quote"
+        ]
+        self.t2i_word_threshold = ctx.astrbot_config["t2i_word_threshold"]
+        try:
+            self.t2i_word_threshold = int(self.t2i_word_threshold)
+            if self.t2i_word_threshold < 50:
+                self.t2i_word_threshold = 50
+        except BaseException:
+            self.t2i_word_threshold = 150
+        self.t2i_strategy = ctx.astrbot_config["t2i_strategy"]
+        self.t2i_use_network = self.t2i_strategy == "remote"
+
+        self.forward_threshold = ctx.astrbot_config["platform_settings"][
+            "forward_threshold"
+        ]
+
+        # 分段回复
+        self.words_count_threshold = int(
+            ctx.astrbot_config["platform_settings"]["segmented_reply"][
+                "words_count_threshold"
+            ]
+        )
+        self.enable_segmented_reply = ctx.astrbot_config["platform_settings"][
+            "segmented_reply"
+        ]["enable"]
+        self.only_llm_result = ctx.astrbot_config["platform_settings"][
+            "segmented_reply"
+        ]["only_llm_result"]
+        self.regex = ctx.astrbot_config["platform_settings"]["segmented_reply"]["regex"]
+        self.content_cleanup_rule = ctx.astrbot_config["platform_settings"][
+            "segmented_reply"
+        ]["content_cleanup_rule"]
+
+        # exception
+        self.content_safe_check_reply = ctx.astrbot_config["content_safety"][
+            "also_use_in_response"
+        ]
+        self.content_safe_check_stage = None
+        if self.content_safe_check_reply:
+            for stage in registered_stages:
+                if stage.__class__.__name__ == "ContentSafetyCheckStage":
+                    self.content_safe_check_stage = stage
+
+    async def process(
+        self, event: AstrMessageEvent
+    ) -> Union[None, AsyncGenerator[None, None]]:
+        result = event.get_result()
+        if result is None or not result.chain:
+            return
+
+        if result.result_content_type == ResultContentType.STREAMING_RESULT:
+            return
+
+        is_stream = result.result_content_type == ResultContentType.STREAMING_FINISH
+
+        # 回复时检查内容安全
+        if (
+            self.content_safe_check_reply
+            and self.content_safe_check_stage
+            and result.is_llm_result()
+            and not is_stream  # 流式输出不检查内容安全
+        ):
+            text = ""
+            for comp in result.chain:
+                if isinstance(comp, Plain):
+                    text += comp.text
+            async for _ in self.content_safe_check_stage.process(
+                event, check_text=text
+            ):
+                yield
+
+        # 发送消息前事件钩子
+        handlers = star_handlers_registry.get_handlers_by_event_type(
+            EventType.OnDecoratingResultEvent, platform_id=event.get_platform_id()
+        )
+        for handler in handlers:
+            try:
+                logger.debug(
+                    f"hook(on_decorating_result) -> {star_map[handler.handler_module_path].name} - {handler.handler_name}"
+                )
+                if is_stream:
+                    logger.warning(
+                        "启用流式输出时，依赖发送消息前事件钩子的插件可能无法正常工作"
+                    )
+                await handler.handler(event)
+                if event.get_result() is None or not event.get_result().chain:
+                    logger.debug(
+                        f"hook(on_decorating_result) -> {star_map[handler.handler_module_path].name} - {handler.handler_name} 将消息结果清空。"
+                    )
+            except BaseException:
+                logger.error(traceback.format_exc())
+
+            if event.is_stopped():
+                logger.info(
+                    f"{star_map[handler.handler_module_path].name} - {handler.handler_name} 终止了事件传播。"
+                )
+                return
+
+        # 流式输出不执行下面的逻辑
+        if is_stream:
+            logger.info("流式输出已启用，跳过结果装饰阶段")
+            return
+
+        # 需要再获取一次。插件可能直接对 chain 进行了替换。
+        result = event.get_result()
+        if result is None:
+            return
+
+        if len(result.chain) > 0:
+            # 回复前缀
+            if self.reply_prefix:
+                for comp in result.chain:
+                    if isinstance(comp, Plain):
+                        comp.text = self.reply_prefix + comp.text
+                        break
+
+            # 分段回复
+            if self.enable_segmented_reply:
+                if (
+                    self.only_llm_result and result.is_llm_result()
+                ) or not self.only_llm_result:
+                    new_chain = []
+                    for comp in result.chain:
+                        if isinstance(comp, Plain):
+                            if len(comp.text) > self.words_count_threshold:
+                                # 不分段回复
+                                new_chain.append(comp)
+                                continue
+                            split_response = re.findall(
+                                self.regex, comp.text, re.DOTALL | re.MULTILINE
+                            )
+                            if not split_response:
+                                new_chain.append(comp)
+                                continue
+                            for seg in split_response:
+                                if self.content_cleanup_rule:
+                                    seg = re.sub(self.content_cleanup_rule, "", seg)
+                                if seg.strip():
+                                    new_chain.append(Plain(seg))
+                        else:
+                            # 非 Plain 类型的消息段不分段
+                            new_chain.append(comp)
+                    result.chain = new_chain
+
+            # TTS
+            if (
+                self.ctx.astrbot_config["provider_tts_settings"]["enable"]
+                and result.is_llm_result()
+            ):
+                tts_provider = self.ctx.plugin_manager.context.provider_manager.curr_tts_provider_inst
+                new_chain = []
+                for comp in result.chain:
+                    if isinstance(comp, Plain) and len(comp.text) > 1:
+                        try:
+                            logger.info("TTS 请求: " + comp.text)
+                            audio_path = await tts_provider.get_audio(comp.text)
+                            logger.info("TTS 结果: " + audio_path)
+                            if audio_path:
+                                new_chain.append(
+                                    Record(file=audio_path, url=audio_path)
+                                )
+                                if(self.ctx.astrbot_config["provider_tts_settings"]["dual_output"]):
+                                    new_chain.append(comp)
+                            else:
+                                logger.error(
+                                    f"由于 TTS 音频文件没找到，消息段转语音失败: {comp.text}"
+                                )
+                                new_chain.append(comp)
+                        except BaseException:
+                            logger.error(traceback.format_exc())
+                            logger.error("TTS 失败，使用文本发送。")
+                            new_chain.append(comp)
+                    else:
+                        new_chain.append(comp)
+                result.chain = new_chain
+
+            # 文本转图片
+            elif (
+                result.use_t2i_ is None and self.ctx.astrbot_config["t2i"]
+            ) or result.use_t2i_:
+                plain_str = ""
+                for comp in result.chain:
+                    if isinstance(comp, Plain):
+                        plain_str += "\n\n" + comp.text
+                    else:
+                        break
+                if plain_str and len(plain_str) > self.t2i_word_threshold:
+                    render_start = time.time()
+                    try:
+                        url = await html_renderer.render_t2i(
+                            plain_str, return_url=True, use_network=self.t2i_use_network
+                        )
+                    except BaseException:
+                        logger.error("文本转图片失败，使用文本发送。")
+                        return
+                    if time.time() - render_start > 3:
+                        logger.warning(
+                            "文本转图片耗时超过了 3 秒，如果觉得很慢可以使用 /t2i 关闭文本转图片模式。"
+                        )
+                    if url:
+                        if url.startswith("http"):
+                            result.chain = [Image.fromURL(url)]
+                        else:
+                            result.chain = [Image.fromFileSystem(url)]
+
+            # 触发转发消息
+            has_forwarded = False
+            if event.get_platform_name() == "aiocqhttp":
+                word_cnt = 0
+                for comp in result.chain:
+                    if isinstance(comp, Plain):
+                        word_cnt += len(comp.text)
+                if word_cnt > self.forward_threshold:
+                    node = Node(
+                        uin=event.get_self_id(), name="AstrBot", content=[*result.chain]
+                    )
+                    result.chain = [node]
+                    has_forwarded = True
+
+            if not has_forwarded:
+                # at 回复
+                if (
+                    self.reply_with_mention
+                    and event.get_message_type() != MessageType.FRIEND_MESSAGE
+                ):
+                    result.chain.insert(
+                        0, At(qq=event.get_sender_id(), name=event.get_sender_name())
+                    )
+                    if len(result.chain) > 1 and isinstance(result.chain[1], Plain):
+                        result.chain[1].text = "\n" + result.chain[1].text
+
+                # 引用回复
+                if self.reply_with_quote:
+                    if not any(isinstance(item, File) for item in result.chain):
+                        result.chain.insert(0, Reply(id=event.message_obj.message_id))

astrbot/core/pipeline/scheduler.py

@@ -0,0 +1,79 @@
+from . import STAGES_ORDER
+from .stage import registered_stages
+from .context import PipelineContext
+from typing import AsyncGenerator
+from astrbot.core.platform import AstrMessageEvent
+from astrbot.core import logger
+
+
+class PipelineScheduler:
+    """管道调度器，负责调度各个阶段的执行"""
+
+    def __init__(self, context: PipelineContext):
+        registered_stages.sort(
+            key=lambda x: STAGES_ORDER.index(x.__class__.__name__)
+        )  # 按照顺序排序
+        self.ctx = context  # 上下文对象
+
+    async def initialize(self):
+        """初始化管道调度器时, 初始化所有阶段"""
+        for stage in registered_stages:
+            # logger.debug(f"初始化阶段 {stage.__class__ .__name__}")
+
+            await stage.initialize(self.ctx)
+
+    async def _process_stages(self, event: AstrMessageEvent, from_stage=0):
+        """依次执行各个阶段
+
+        Args:
+            event (AstrMessageEvent): 事件对象
+            from_stage (int): 从第几个阶段开始执行, 默认从0开始
+        """
+        for i in range(from_stage, len(registered_stages)):
+            stage = registered_stages[i]  # 获取当前要执行的阶段
+            # logger.debug(f"执行阶段 {stage.__class__ .__name__}")
+            coroutine = stage.process(
+                event
+            )  # 调用阶段的process方法, 返回协程或者异步生成器
+
+            if isinstance(coroutine, AsyncGenerator):
+                # 如果返回的是异步生成器, 实现洋葱模型的核心
+                async for _ in coroutine:
+                    # 此处是前置处理完成后的暂停点(yield), 下面开始执行后续阶段
+                    if event.is_stopped():
+                        logger.debug(
+                            f"阶段 {stage.__class__.__name__} 已终止事件传播。"
+                        )
+                        break
+
+                    # 递归调用, 处理所有后续阶段
+                    await self._process_stages(event, i + 1)
+
+                    # 此处是后续所有阶段处理完毕后返回的点, 执行后置处理
+                    if event.is_stopped():
+                        logger.debug(
+                            f"阶段 {stage.__class__.__name__} 已终止事件传播。"
+                        )
+                        break
+            else:
+                # 如果返回的是普通协程(不含yield的async函数), 则不进入下一层(基线条件)
+                # 简单地等待它执行完成, 然后继续执行下一个阶段
+                await coroutine
+
+                if event.is_stopped():
+                    logger.debug(f"阶段 {stage.__class__.__name__} 已终止事件传播。")
+                    break
+
+    async def execute(self, event: AstrMessageEvent):
+        """执行 pipeline
+
+        Args:
+            event (AstrMessageEvent): 事件对象
+        """
+        await self._process_stages(event)
+
+        # 如果没有发送操作, 则发送一个空消息, 以便于后续的处理
+        if not event._has_send_oper and event.get_platform_name() == "webchat":
+            await event.send(None)
+
+        logger.debug("pipeline 执行完毕。")

astrbot/core/pipeline/stage.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+import abc
+import inspect
+import traceback
+from astrbot.api import logger
+from typing import List, AsyncGenerator, Union, Awaitable
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from .context import PipelineContext
+from astrbot.core.message.message_event_result import MessageEventResult, CommandResult
+
+registered_stages: List[Stage] = []  # 维护了所有已注册的 Stage 实现类
+
+
+def register_stage(cls):
+    """一个简单的装饰器，用于注册 pipeline 包下的 Stage 实现类"""
+    registered_stages.append(cls())
+    return cls
+
+
+class Stage(abc.ABC):
+    """描述一个 Pipeline 的某个阶段"""
+
+    @abc.abstractmethod
+    async def initialize(self, ctx: PipelineContext) -> None:
+        """初始化阶段
+
+        Args:
+            ctx (PipelineContext): 消息管道上下文对象, 包括配置和插件管理器
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def process(
+        self, event: AstrMessageEvent
+    ) -> Union[None, AsyncGenerator[None, None]]:
+        """处理事件
+
+        Args:
+            event (AstrMessageEvent): 事件对象，包含事件的相关信息
+        Returns:
+            Union[None, AsyncGenerator[None, None]]: 处理结果，可能是 None 或者异步生成器, 如果为 None 则表示不需要继续处理, 如果为异步生成器则表示需要继续处理(进入下一个阶段)
+        """
+        raise NotImplementedError
+
+    async def _call_handler(
+        self,
+        ctx: PipelineContext,
+        event: AstrMessageEvent,
+        handler: Awaitable,
+        *args,
+        **kwargs,
+    ) -> AsyncGenerator[None, None]:
+        """执行事件处理函数并处理其返回结果
+
+        该方法负责调用处理函数并处理不同类型的返回值。它支持两种类型的处理函数:
+        1. 异步生成器: 实现洋葱模型，每次yield都会将控制权交回上层
+        2. 协程: 执行一次并处理返回值
+
+        Args:
+            ctx (PipelineContext): 消息管道上下文对象
+            event (AstrMessageEvent): 待处理的事件对象
+            handler (Awaitable): 事件处理函数
+            *args: 传递给handler的位置参数
+            **kwargs: 传递给handler的关键字参数
+
+        Returns:
+            AsyncGenerator[None, None]: 异步生成器，用于在管道中传递控制流
+        """
+        ready_to_call = None  # 一个协程或者异步生成器(async def)
+
+        trace_ = None
+
+        try:
+            ready_to_call = handler(event, *args, **kwargs)
+        except TypeError as _:
+            # 向下兼容
+            trace_ = traceback.format_exc()
+            # 以前的handler会额外传入一个参数, 但是context对象实际上在插件实例中有一份
+            ready_to_call = handler(event, ctx.plugin_manager.context, *args, **kwargs)
+
+        if isinstance(ready_to_call, AsyncGenerator):
+            # 如果是一个异步生成器, 进入洋葱模型
+            _has_yielded = False  # 是否返回过值
+            try:
+                async for ret in ready_to_call:
+                    # 这里逐步执行异步生成器, 对于每个yield返回的ret, 执行下面的代码
+                    # 返回值只能是 MessageEventResult 或者 None（无返回值）
+                    _has_yielded = True
+                    if isinstance(ret, (MessageEventResult, CommandResult)):
+                        # 如果返回值是 MessageEventResult, 设置结果并继续
+                        event.set_result(ret)
+                        yield  # 传递控制权给上一层的process函数
+                    else:
+                        # 如果返回值是 None, 则不设置结果并继续
+                        # 继续执行后续阶段
+                        yield ret  # 传递控制权给上一层的process函数
+                if not _has_yielded:
+                    # 如果这个异步生成器没有执行到yield分支
+                    yield
+            except Exception as e:
+                logger.error(f"Previous Error: {trace_}")
+                raise e
+        elif inspect.iscoroutine(ready_to_call):
+            # 如果只是一个协程, 直接执行
+            ret = await ready_to_call
+            if isinstance(ret, (MessageEventResult, CommandResult)):
+                event.set_result(ret)
+                yield  # 传递控制权给上一层的process函数
+            else:
+                yield ret  # 传递控制权给上一层的process函数