fix: 修复 /dashbord_update 指令

WebChat 支持

.dockerignore

@@ -16,3 +16,5 @@ venv*/
 ENV/
 .conda/
 README*.md
+dashboard/
+data/

.github/workflows/auto_release.yml

@@ -0,0 +1,35 @@
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+name: Auto Release
+
+jobs:
+  build:
+    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 Release
+        uses: ncipollo/release-action@v1
+        with:
+          bodyFile: ${{ env.changelog }}
+          artifacts: "dashboard/dist.zip"

.github/workflows/coverage_test.yml

@@ -1,7 +1,14 @@
 name: Run tests and upload coverage
 
 on: 
-  push
+  push:
+    branches:
+      - master
+    paths-ignore:
+      - 'README.md'
+      - 'changelogs/**'
+      - 'dashboard/**'
+  workflow_dispatch:
 
 jobs:
   test:
@@ -21,17 +28,16 @@ jobs:
           python -m pip install --upgrade pip
           pip install -r requirements.txt
           pip install pytest pytest-cov pytest-asyncio
-          mkdir data
-          mkdir data/plugins
-          mkdir data/config
-          mkdir temp
 
       - name: Run tests
         run: |
-          export LLM_MODEL=${{ secrets.LLM_MODEL }}
-          export OPENAI_API_BASE=${{ secrets.OPENAI_API_BASE }}
-          export OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY }}
-          PYTHONPATH=./ pytest --cov=. tests/ -v
+          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

.github/workflows/docker-image.yml

@@ -1,8 +1,9 @@
 name: Docker Image CI/CD
 
 on:
-  release:
-    types: [published]
+  push:
+    tags:
+      - 'v*'
   workflow_dispatch:
 
 jobs:
@@ -35,7 +36,7 @@ jobs:
           push: true
           tags: |
             ${{ secrets.DOCKER_HUB_USERNAME }}/astrbot:latest
-            ${{ secrets.DOCKER_HUB_USERNAME }}/astrbot:${{ github.event.release.tag_name }}
+            ${{ secrets.DOCKER_HUB_USERNAME }}/astrbot:${{ github.ref_name }}
 
       - name: Post build notifications
         run: echo "Docker image has been built and pushed successfully"

.gitignore

@@ -1,14 +1,24 @@
 __pycache__
 botpy.log
 .vscode
-data.db
+data_v2.db
+data_v3.db
 configs/session
 configs/config.yaml
 **/.DS_Store
 temp
 cmd_config.json
-data/*
+data
 cookies.json
 logs/
 addons/plugins
 .coverage
+
+
+tests/astrbot_plugin_openai
+chroma
+node_modules/
+.DS_Store
+package-lock.json
+package.json
+venv/*

README.md

@@ -1,51 +1,110 @@
+
 <p align="center">
-
-<img width="750" alt="image" src="https://github.com/Soulter/AstrBot/assets/37870767/c6f057d9-46d7-4144-8116-00a962941746">
-
+<img width=200 src="https://github.com/user-attachments/assets/3dd6a669-0830-4db4-b821-c8b279ea19a6"/>
 </p>
+
 <div align="center">
 
+<h1>AstrBot</h1>
+
+_✨ 易上手的多平台 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://img.shields.io/badge/python-3.9+-blue.svg" alt="python">
+<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>
-[![codecov](https://codecov.io/gh/Soulter/AstrBot/graph/badge.svg?token=FF3P5967B8)](https://codecov.io/gh/Soulter/AstrBot)
-<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">
+[![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)
+[![codecov](https://codecov.io/gh/Soulter/AstrBot/graph/badge.svg?token=FF3P5967B8)](https://codecov.io/gh/Soulter/AstrBot)
 </a>
 
-<a href="https://astrbot.soulter.top/docs/main">快速开始</a> ｜
-<a href="https://github.com/Soulter/AstrBot/issues">问题提交</a> ｜
-<a href="https://astrbot.soulter.top/docs/develop/plugin4p">插件开发</a>
+<a href="https://astrbot.lwl.lol/">查看文档</a> ｜
+<a href="https://github.com/Soulter/AstrBot/issues">问题提交</a>
 </div>
 
-## 🛠️ 功能
+AstrBot 是一个松耦合、异步、支持多消息平台部署、具有易用的插件系统和完善的大语言模型（LLM）接入功能的聊天机器人及开发框架。
 
-🌍 支持的消息平台
-- QQ 群、QQ 频道（OneBot、QQ 官方接口）
-- Telegram（[astrbot_plugin_telegram](https://github.com/Soulter/astrbot_plugin_telegram) 插件）
+## ✨ 多消息平台部署
 
-🌍 支持的大模型/底座：
+1. QQ 群、QQ 频道、微信个人号、Telegram。
+2. 支持文本转图片，Markdown 渲染。
    
-- OpenAI GPT、DallE 系列
-- Claude（由[LLMs插件](https://github.com/Soulter/llms)支持）
-- HuggingChat（由[LLMs插件](https://github.com/Soulter/llms)支持）
-- Gemini（由[LLMs插件](https://github.com/Soulter/llms)支持）
-- Ollama 
-- 几乎所有已知模型（可接入 [OneAPI](https://astrbot.soulter.top/docs/docs/adavanced/one-api)）
+## ✨ 多 LLM 配置
 
-🌍 机器人支持的能力一览：
-- 大模型对话、人格、网页搜索
-- 可视化仪表盘
-- 同时处理多平台消息
-- 精确到个人的会话隔离
-- 插件支持
-- 文本转图片回复（Markdown）
+1. 适配 OpenAI API，支持接入 Gemini、GPT、Llama、Claude、DeepSeek、GLM 等各种大语言模型。
+2. 支持 OneAPI 等分发平台。
+3. 支持 LLMTuner 载入微调模型。
+4. 支持 Ollama 载入自部署模型。
+4. 支持网页搜索（Web Search）、自然语言待办提醒。
 
-## 🧩 插件
+## ✨ 管理面板
 
-有关插件的使用和列表请移步：[AstrBot 文档 - 插件](https://astrbot.soulter.top/docs/get-started/plugin)
+1. 支持可视化修改配置
+2. 日志实时查看
+3. 简单的信息统计
+4. 插件管理
 
-## 云部署
+## ✨ 支持 Dify
+
+1. 对接了 LLMOps 平台 Dify，便捷接入 Dify 智能助手、知识库和 Dify 工作流！[接入 Dify - AstrBot 文档](https://astrbot.lwl.lol/others/dify.html)
+
+## ✨ 代码执行器(Beta)
+
+基于 Docker 的沙箱化代码执行器（Beta 测试中）
+
+> [!NOTE]
+> 文件输入/输出目前仅支持 Napcat（QQ）
+
+<div align='center'>
+<img src="https://github.com/user-attachments/assets/700a545e-7450-4f23-90ff-af6d0d60e501" height=300>
+
+<img src="https://github.com/user-attachments/assets/0b0c5344-e98b-4902-92ad-fe9f0bb10c2a" height=300>
+
+<img src="https://github.com/user-attachments/assets/b9b98ff4-8630-46fb-9a39-ecbad9d601ae" height=300>
+
+<img src="https://github.com/user-attachments/assets/9fe6e44c-e4f6-4347-9d5f-281677d47feb" height=300>
+
+</div>
+
+
+
+## ✨ Demo
+
+<div align='center'>
+
+<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/caadf2bd-a0ee-43d0-a95e-566d63e3e34d" height=330>
+<img src="https://github.com/user-attachments/assets/b418f281-e920-49db-9fe1-d6a13ce28a84" height=350>
+
+_✨ 管理面板 ✨_
+
+
+
+
+</div>
+
+
+<!-- ## ✨ ATRI [Beta 测试]
+
+该功能作为插件载入。插件仓库地址：[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
+    -->
+## ✨ 云部署
 
 [![Run on Repl.it](https://repl.it/badge/github/Soulter/AstrBot)](https://repl.it/github/Soulter/AstrBot)
 
@@ -53,15 +112,15 @@
 
 欢迎任何 Issues/Pull Requests！只需要将你的更改提交到此项目 ：)
 
-对于新功能的添加，请先通过 Issue 进行讨论。
+对于新功能的添加，请先通过 Issue 讨论。
 
 ## 🔭 展望
 
-- [ ] 更多、更开放的 LLM Agent 能力
-
-## ✨ Demo
-
-<img width="900" alt="image" src="https://github.com/Soulter/AstrBot/assets/37870767/824d1ff3-7b85-481c-b795-8e62dedb9fd7">
-
+1. 更强大的 Agent 系统。
+2. 打造插件工作流平台。
 
+## ✨ Support
 
+- Star 这个项目！
+- 在[爱发电](https://afdian.com/a/soulter)支持我！
+- 在[微信](https://drive.soulter.top/f/pYfA/d903f4fa49a496fda3f16d2be9e023b5.png)支持我~

astrbot/__init__.py

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

astrbot/api/__init__.py

@@ -0,0 +1,15 @@
+from astrbot.core.config.astrbot_config import AstrBotConfig
+from astrbot import logger
+from astrbot.core.utils.personality import personalities
+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",
+    "personalities",
+    "html_renderer",
+    "llm_tool",
+    "sp"
+]

astrbot/api/all.py

@@ -0,0 +1,41 @@
+
+from astrbot.core.config.astrbot_config import AstrBotConfig
+from astrbot import logger
+from astrbot.core.utils.personality import personalities
+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,35 @@
+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_on_llm_request as on_llm_request,
+    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
+
+__all__ = [
+    'command',
+    'command_group',
+    'event_message_type',
+    'regex',
+    'platform_adapter_type',
+    'permission_type',
+    'EventMessageTypeFilter',
+    'EventMessageType',
+    'PlatformAdapterTypeFilter',
+    'PlatformAdapterType',
+    'PermissionTypeFilter',
+    'PermissionType',
+    'on_llm_request',
+    'llm_tool',
+    'on_decorating_result',
+    'after_message_sent'
+]

astrbot/api/message_components.py

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

astrbot/api/platform/__init__.py

@@ -0,0 +1,5 @@
+from astrbot.core.platform import (
+    AstrMessageEvent, Platform, AstrBotMessage, MessageMember, MessageType, PlatformMetadata
+)
+
+from astrbot.core.platform.register import register_platform_adapter

astrbot/api/provider/__init__.py

@@ -0,0 +1,2 @@
+from astrbot.core.provider import Provider, Personality, ProviderMetaData
+from astrbot.core.provider.entites import ProviderRequest

astrbot/api/star/__init__.py

@@ -0,0 +1,6 @@
+from astrbot.core.star.register import (
+    register_star as register # 注册插件（Star）
+)
+
+from astrbot.core.star import Context, Star
+from astrbot.core.star.config import *

astrbot/bootstrap.py

@@ -1,129 +0,0 @@
-import asyncio
-import traceback
-import os
-from astrbot.message.handler import MessageHandler
-from astrbot.persist.helper import dbConn
-from dashboard.server import AstrBotDashBoard
-from model.command.manager import CommandManager
-from model.command.internal_handler import InternalCommandHandler
-from model.plugin.manager import PluginManager
-from model.platform.manager import PlatformManager
-from typing import Union
-from type.types import Context
-from type.config import VERSION
-from SparkleLogging.utils.core import LogManager
-from logging import Logger
-from util.cmd_config import AstrBotConfig, try_migrate
-from util.metrics import MetricUploader
-from util.updator.astrbot_updator import AstrBotUpdator
-
-logger: Logger = LogManager.GetLogger(log_name='astrbot')
-
-
-class AstrBotBootstrap():
-    def __init__(self) -> None:
-        self.context = Context()
-        
-        # load configs and ensure the backward compatibility
-        try_migrate()
-        self.config_helper = AstrBotConfig()
-        self.context.config_helper = self.config_helper
-        logger.info("AstrBot v" + VERSION)
-        # apply proxy settings
-        http_proxy = self.context.config_helper.http_proxy
-        https_proxy = self.context.config_helper.https_proxy
-        if http_proxy:
-            os.environ['HTTP_PROXY'] = http_proxy
-        if https_proxy:
-            os.environ['HTTPS_PROXY'] = https_proxy
-        os.environ['NO_PROXY'] = 'https://api.sgroup.qq.com'
-        
-        if http_proxy and https_proxy:
-            logger.info(f"使用代理: {http_proxy}, {https_proxy}")
-        else:
-            logger.info("未使用代理。")
-            
-        self.test_mode = os.environ.get('TEST_MODE', 'off') == 'on'
-    
-    async def run(self):
-        self.command_manager = CommandManager()
-        self.plugin_manager = PluginManager(self.context)
-        self.updator = AstrBotUpdator()
-        self.cmd_handler = InternalCommandHandler(self.command_manager, self.plugin_manager)
-        self.db_conn_helper = dbConn()
-        
-        # load llm provider
-        self.load_llm()
-        
-        self.message_handler = MessageHandler(self.context, self.command_manager, self.db_conn_helper)
-        self.platfrom_manager = PlatformManager(self.context, self.message_handler)
-        self.dashboard = AstrBotDashBoard(self.context, plugin_manager=self.plugin_manager, astrbot_updator=self.updator)
-        self.metrics_uploader = MetricUploader(self.context)
-        
-        self.context.metrics_uploader = self.metrics_uploader
-        self.context.updator = self.updator
-        self.context.plugin_updator = self.plugin_manager.updator
-        self.context.message_handler = self.message_handler
-        self.context.command_manager = self.command_manager
-        
-        if self.test_mode:
-            return
-        
-        # load plugins, plugins' commands.
-        self.load_plugins()
-        self.command_manager.register_from_pcb(self.context.plugin_command_bridge)
-        
-        # load platforms
-        platform_tasks = self.load_platform()
-        # load metrics uploader
-        metrics_upload_task = asyncio.create_task(self.metrics_uploader.upload_metrics(), name="metrics-uploader")
-        # load dashboard
-        self.dashboard.run_http_server()
-        dashboard_task = asyncio.create_task(self.dashboard.ws_server(), name="dashboard")
-        tasks = [metrics_upload_task, dashboard_task, *platform_tasks, *self.context.ext_tasks]
-        tasks = [self.handle_task(task) for task in tasks]
-        await asyncio.gather(*tasks)
-
-    async def handle_task(self, task: Union[asyncio.Task, asyncio.Future]):
-        while True:
-            try:
-                result = await task
-                return result
-            except asyncio.CancelledError:
-                logger.info(f"{task.get_name()} 任务已取消。")
-                return
-            except Exception as e:
-                logger.error(traceback.format_exc())
-                logger.error(f"{task.get_name()} 任务发生错误。")
-                return
-    
-    def load_llm(self):
-        f = False
-        llms = self.context.config_helper.llm
-        logger.info(f"加载 {len(llms)} 个 LLM Provider...")
-        for llm in llms:
-            if llm.enable:
-                if llm.name == "openai" and llm.key and llm.enable:
-                    self.load_openai(llm)
-                    f = True
-                    logger.info(f"已启用 OpenAI API 支持。")
-                else:
-                    logger.warn(f"未知的 LLM Provider: {llm.name}")
-        if f:
-            from model.command.openai_official_handler import OpenAIOfficialCommandHandler
-            self.openai_command_handler = OpenAIOfficialCommandHandler(self.command_manager)
-            self.openai_command_handler.set_provider(self.context.llms[0].llm_instance)
-
-    def load_openai(self, llm_config):
-        from model.provider.openai_official import ProviderOpenAIOfficial
-        inst = ProviderOpenAIOfficial(llm_config)
-        self.context.register_provider("internal_openai", inst)
-    
-    def load_plugins(self):
-        self.plugin_manager.plugin_reload()
-    
-    def load_platform(self):
-        platforms = self.platfrom_manager.load_platforms()
-        if not platforms:
-            logger.warn("未启用任何消息平台。")
-        return platforms

astrbot/core/__init__.py

@@ -0,0 +1,25 @@
+import os
+import asyncio
+from .log import LogManager, LogBroker
+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()
+html_renderer = HtmlRenderer()
+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', ''))
+web_chat_queue = asyncio.Queue()
+web_chat_back_queue = asyncio.Queue()
+WEBUI_SK = "Advanced_System_for_Text_Response_and_Bot_Operations_Tool"

astrbot/core/config/__init__.py

@@ -0,0 +1,2 @@
+from .default import DEFAULT_CONFIG, VERSION, DB_PATH
+from .astrbot_config import *

astrbot/core/config/astrbot_config.py

@@ -0,0 +1,84 @@
+import os
+import json
+import logging
+import enum
+from .default import DEFAULT_CONFIG
+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):
+    '''从配置文件中加载的配置，支持直接通过点号操作符访问配置项'''
+    
+    def __init__(self):
+        super().__init__()
+        if not self.check_exist():
+            '''不存在时载入默认配置'''
+            with open(ASTRBOT_CONFIG_PATH, "w", encoding="utf-8-sig") as f:
+                json.dump(DEFAULT_CONFIG, f, indent=4, ensure_ascii=False)
+
+        with open(ASTRBOT_CONFIG_PATH, "r", encoding="utf-8-sig") as f:
+            conf_str = f.read()
+            if conf_str.startswith(u'/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 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(ASTRBOT_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(ASTRBOT_CONFIG_PATH)

astrbot/core/config/default.py

@@ -0,0 +1,605 @@
+"""
+如需修改配置，请在 `data/cmd_config.json` 中修改或者在管理面板中可视化修改。
+"""
+
+VERSION = "3.4.4"
+DB_PATH = "data/data_v3.db"
+
+# 默认配置
+DEFAULT_CONFIG = {
+    "config_version": 2,
+    "platform_settings": {
+        "unique_session": False,
+        "rate_limit": {
+            "time": 60,
+            "count": 30,
+            "strategy": "stall",  # stall, discard
+        },
+        "reply_prefix": "",
+        "forward_threshold": 200,
+        "enable_id_white_list": True,
+        "id_whitelist": [],
+        "id_whitelist_log": True,
+        "wl_ignore_admin_on_group": True,
+        "wl_ignore_admin_on_friend": True,
+    },
+    "provider": [],
+    "provider_settings": {
+        "enable": True,
+        "wake_prefix": "",
+        "web_search": False,
+        "identifier": False,
+        "datetime_system_prompt": True,
+        "default_personality": "如果用户寻求帮助或者打招呼，请告诉他可以用 /help 查看 AstrBot 帮助。",
+        "prompt_prefix": "",
+    },
+    "content_safety": {
+        "internal_keywords": {"enable": True, "extra_keywords": []},
+        "baidu_aip": {"enable": False, "app_id": "", "api_key": "", "secret_key": ""},
+    },
+    "admins_id": [],
+    "t2i": False,
+    "http_proxy": "",
+    "dashboard": {
+        "enable": True,
+        "username": "astrbot",
+        "password": "77b90590a8945a7d36c963981a307dc9",
+    },
+    "platform": [],
+    "wake_prefix": ["/"],
+    "log_level": "INFO",
+    "t2i_endpoint": "",
+    "pip_install_arg": "",
+    "plugin_repo_mirror": "",
+    "knowledge_db": {},
+}
+
+
+# 配置项的中文描述、值类型
+CONFIG_METADATA_2 = {
+    "platform_group": {
+        "name": "消息平台",
+        "metadata": {
+            "platform": {
+                "description": "消息平台适配器",
+                "type": "list",
+                "config_template": {
+                    "qq_official(QQ)": {
+                        "id": "default",
+                        "type": "qq_official",
+                        "enable": False,
+                        "appid": "",
+                        "secret": "",
+                        "enable_group_c2c": True,
+                        "enable_guild_direct_message": True,
+                    },
+                    "aiocqhtp(QQ)": {
+                        "id": "default",
+                        "type": "aiocqhttp",
+                        "enable": False,
+                        "ws_reverse_host": "",
+                        "ws_reverse_port": 6199,
+                    },
+                    "vchat(微信)": {"id": "default", "type": "vchat", "enable": False},
+                },
+                "items": {
+                    "id": {
+                        "description": "ID",
+                        "type": "string",
+                        "hint": "提供商 ID 名，用于在多实例下方便管理和识别。自定义，ID 不能重复。",
+                    },
+                    "type": {
+                        "description": "适配器类型",
+                        "type": "string",
+                        "invisible": True,
+                    },
+                    "enable": {
+                        "description": "启用",
+                        "type": "bool",
+                        "hint": "是否启用该适配器。未启用的适配器对应的消息平台将不会接收到消息。",
+                    },
+                    "appid": {
+                        "description": "appid",
+                        "type": "string",
+                        "hint": "必填项。QQ 官方机器人平台的 appid。如何获取请参考文档。",
+                    },
+                    "secret": {
+                        "description": "secret",
+                        "type": "string",
+                        "hint": "必填项。QQ 官方机器人平台的 secret。如何获取请参考文档。",
+                    },
+                    "enable_group_c2c": {
+                        "description": "启用消息列表单聊",
+                        "type": "bool",
+                        "hint": "启用后，机器人可以接收到 QQ 消息列表中的私聊消息。你可能需要在 QQ 机器人平台上通过扫描二维码的方式添加机器人为你的好友。详见文档。",
+                    },
+                    "enable_guild_direct_message": {
+                        "description": "启用频道私聊",
+                        "type": "bool",
+                        "hint": "启用后，机器人可以接收到频道的私聊消息。",
+                    },
+                    "ws_reverse_host": {
+                        "description": "反向 Websocket 主机地址",
+                        "type": "string",
+                        "hint": "aiocqhttp 适配器的反向 Websocket 服务器 IP 地址，不包含端口号。",
+                    },
+                    "ws_reverse_port": {
+                        "description": "反向 Websocket 端口",
+                        "type": "int",
+                        "hint": "aiocqhttp 适配器的反向 Websocket 端口。",
+                    },
+                },
+            },
+            "platform_settings": {
+                "description": "平台设置",
+                "type": "object",
+                "items": {
+                    "unique_session": {
+                        "description": "会话隔离",
+                        "type": "bool",
+                        "hint": "启用后，在群组或者频道中，每个人的消息上下文都是独立的。",
+                    },
+                    "rate_limit": {
+                        "description": "速率限制",
+                        "hint": "每个会话在 `time` 秒内最多只能发送 `count` 条消息。",
+                        "type": "object",
+                        "items": {
+                            "time": {"description": "消息速率限制时间", "type": "int"},
+                            "count": {"description": "消息速率限制计数", "type": "int"},
+                            "strategy": {
+                                "description": "速率限制策略",
+                                "type": "string",
+                                "options": ["stall", "discard"],
+                                "hint": "当消息速率超过限制时的处理策略。stall 为等待，discard 为丢弃。",
+                            },
+                        },
+                    },
+                    "reply_prefix": {
+                        "description": "回复前缀",
+                        "type": "string",
+                        "hint": "机器人回复消息时带有的前缀。",
+                    },
+                    "forward_threshold": {
+                        "description": "转发消息的字数阈值",
+                        "type": "int",
+                        "hint": "超过一定字数后，机器人会将消息折叠成 QQ 群聊的 “转发消息”，以防止刷屏。目前仅 QQ 平台适配器适用。",
+                    },
+                    "enable_id_white_list": {
+                        "description": "启用 ID 白名单",
+                        "type": "bool"
+                    },
+                    "id_whitelist": {
+                        "description": "ID 白名单",
+                        "type": "list",
+                        "items": {"type": "int"},
+                        "hint": "填写后，将只处理所填写的 ID 发来的消息事件。为空时表示不启用白名单过滤。可以使用 /myid 指令获取在某个平台上的会话 ID。也可在 AstrBot 日志内获取会话 ID，当一条消息没通过白名单时，会输出 INFO 级别的日志。会话 ID 类似 aiocqhttp:GroupMessage:547540978",
+                    },
+                    "id_whitelist_log": {
+                        "description": "打印白名单日志",
+                        "type": "bool",
+                        "hint": "启用后，当一条消息没通过白名单时，会输出 INFO 级别的日志。",
+                    },
+                    "wl_ignore_admin_on_group": {
+                        "description": "管理员群组消息无视 ID 白名单",
+                        "type": "bool",
+                    },
+                    "wl_ignore_admin_on_friend": {
+                        "description": "管理员私聊消息无视 ID 白名单",
+                        "type": "bool",
+                    },
+                },
+            },
+            "content_safety": {
+                "description": "内容安全",
+                "type": "object",
+                "items": {
+                    "baidu_aip": {
+                        "description": "百度内容审核配置",
+                        "type": "object",
+                        "items": {
+                            "enable": {
+                                "description": "启用百度内容审核",
+                                "type": "bool",
+                                "hint": "启用此功能前，您需要手动在设备中安装 baidu-aip 库。一般来说，安装指令如下: `pip3 install baidu-aip`",
+                            },
+                            "app_id": {"description": "APP ID", "type": "string"},
+                            "api_key": {"description": "API Key", "type": "string"},
+                            "secret_key": {
+                                "description": "Secret Key",
+                                "type": "string",
+                            },
+                        },
+                    },
+                    "internal_keywords": {
+                        "description": "内部关键词过滤",
+                        "type": "object",
+                        "items": {
+                            "enable": {
+                                "description": "启用内部关键词过滤",
+                                "type": "bool",
+                            },
+                            "extra_keywords": {
+                                "description": "额外关键词",
+                                "type": "list",
+                                "items": {"type": "string"},
+                                "hint": "额外的屏蔽关键词列表，支持正则表达式。",
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+    "provider_group": {
+        "name": "服务提供商",
+        "metadata": {
+            "provider": {
+                "description": "服务提供商配置",
+                "type": "list",
+                "config_template": {
+                    "openai": {
+                        "id": "default",
+                        "type": "openai_chat_completion",
+                        "enable": True,
+                        "key": [],
+                        "api_base": "",
+                        "model_config": {
+                            "model": "gpt-4o-mini",
+                        },
+                    },
+                    "ollama": {
+                        "id": "ollama_default",
+                        "type": "openai_chat_completion",
+                        "enable": True,
+                        "key": ["ollama"],  # ollama 的 key 默认是 ollama
+                        "api_base": "http://localhost:11434",
+                        "model_config": {
+                            "model": "llama3.1-8b",
+                        },
+                    },
+                    "gemini(OpenAI兼容)": {
+                        "id": "gemini_default",
+                        "type": "openai_chat_completion",
+                        "enable": True,
+                        "key": [],
+                        "api_base": "https://generativelanguage.googleapis.com/v1beta/openai/",
+                        "model_config": {
+                            "model": "gemini-1.5-flash",
+                        },
+                    },
+                    "gemini(googlegenai原生)": {
+                        "id": "gemini_default",
+                        "type": "googlegenai_chat_completion",
+                        "enable": True,
+                        "key": [],
+                        "api_base": "https://generativelanguage.googleapis.com/",
+                        "model_config": {
+                            "model": "gemini-1.5-flash",
+                        },
+                    },
+                    "deepseek": {
+                        "id": "deepseek_default",
+                        "type": "openai_chat_completion",
+                        "enable": True,
+                        "key": [],
+                        "api_base": "https://api.deepseek.com/v1",
+                        "model_config": {
+                            "model": "deepseek-chat",
+                        },
+                    },
+                    "zhipu": {
+                        "id": "zhipu_default",
+                        "type": "zhipu_chat_completion",
+                        "enable": True,
+                        "key": [],
+                        "api_base": "https://open.bigmodel.cn/api/paas/v4/",
+                        "model_config": {
+                            "model": "glm-4-flash",
+                        },
+                    },
+                    "llmtuner": {
+                        "id": "llmtuner_default",
+                        "type": "llm_tuner",
+                        "enable": True,
+                        "base_model_path": "",
+                        "adapter_model_path": "",
+                        "llmtuner_template": "",
+                        "finetuning_type": "lora",
+                        "quantization_bit": 4,
+                    },
+                    "dify": {
+                        "id": "dify_app_default",
+                        "type": "dify",
+                        "enable": True,
+                        "dify_api_type": "chat",
+                        "dify_api_key": "",
+                        "dify_api_base": "https://api.dify.ai/v1",
+                        "dify_workflow_output_key": "",
+                    }
+                },
+                "items": {
+                    "id": {
+                        "description": "ID",
+                        "type": "string",
+                        "hint": "提供商 ID 名，用于在多实例下方便管理和识别。自定义，ID 不能重复。",
+                    },
+                    "type": {
+                        "description": "模型提供商类型",
+                        "type": "string",
+                        "invisible": True,
+                    },
+                    "enable": {
+                        "description": "启用",
+                        "type": "bool",
+                        "hint": "是否启用该模型。未启用的模型将不会被使用。",
+                    },
+                    "key": {
+                        "description": "API Key",
+                        "type": "list",
+                        "items": {"type": "string"},
+                        "hint": "API Key 列表。填写好后输入回车即可添加 API Key。支持多个 API Key。",
+                    },
+                    "api_base": {
+                        "description": "API Base URL",
+                        "type": "string",
+                        "hint": "API Base URL 请在在模型提供商处获得。支持 Ollama 开放的 API 地址。如果您确认填写正确但是使用时出现了 404 异常，可以尝试在地址末尾加上 `/v1`。",
+                    },
+                    "base_model_path": {
+                        "description": "基座模型路径",
+                        "type": "string",
+                        "hint": "基座模型路径。",
+                    },
+                    "adapter_model_path": {
+                        "description": "Adapter 模型路径",
+                        "type": "string",
+                        "hint": "Adapter 模型路径。如 Lora",
+                    },
+                    "llmtuner_template": {
+                        "description": "template",
+                        "type": "string",
+                        "hint": "基座模型的类型。如 llama3, qwen, 请参考 LlamaFactory 文档。",
+                    },
+                    "finetuning_type": {
+                        "description": "微调类型",
+                        "type": "string",
+                        "hint": "微调类型。如 `lora`",
+                    },
+                    "quantization_bit": {
+                        "description": "量化位数",
+                        "type": "int",
+                        "hint": "量化位数。如 4",
+                    },
+                    "model_config": {
+                        "description": "文本生成模型",
+                        "type": "object",
+                        "items": {
+                            "model": {
+                                "description": "模型名称",
+                                "type": "string",
+                                "hint": "大语言模型的名称，一般是小写的英文。如 gpt-4o-mini, deepseek-chat 等。",
+                            },
+                            "max_tokens": {
+                                "description": "模型最大输出长度（tokens）",
+                                "type": "int",
+                            },
+                            "temperature": {"description": "温度", "type": "float"},
+                            "top_p": {"description": "Top P值", "type": "float"},
+                        },
+                    },
+                    "dify_api_key": {
+                        "description": "API Key",
+                        "type": "string",
+                        "hint": "Dify API Key。此项必填。",
+                    },
+                    "dify_api_base": {
+                        "description": "API Base URL",
+                        "type": "string",
+                        "hint": "Dify API Base URL。默认为 https://api.dify.ai/v1",
+                    },
+                    "dify_api_type": {
+                        "description": "Dify 应用类型",
+                        "type": "string",
+                        "hint": "Dify API 类型。根据 Dify 官网，目前支持 chat, agent, workflow 三种应用类型",
+                        "options": ["chat", "agent", "workflow"],
+                    },
+                    "dify_workflow_output_key": {
+                        "description": "Dify Workflow 输出变量名",
+                        "type": "string",
+                        "hint": "Dify Workflow 输出变量名。当应用类型为 workflow 时才使用。默认为 astrbot_wf_output。",
+                    }
+                },
+            },
+            "provider_settings": {
+                "description": "大语言模型设置",
+                "type": "object",
+                "items": {
+                    "enable": {
+                        "description": "启用大语言模型聊天",
+                        "type": "bool",
+                        "hint": "是否启用大语言模型聊天。默认启用",
+                    },
+                    "wake_prefix": {
+                        "description": "LLM 聊天额外唤醒前缀",
+                        "type": "string",
+                        "hint": "使用 LLM 聊天额外的触发条件。如填写 `chat`，则需要消息前缀加上 `/chat` 才能触发 LLM 聊天，是一个防止滥用的手段。",
+                    },
+                    "web_search": {
+                        "description": "启用网页搜索",
+                        "type": "bool",
+                        "hint": "能访问 Google 时效果最佳。如果 Google 访问失败，程序会依次访问 Bing, Sogo 搜索引擎。",
+                    },
+                    "identifier": {
+                        "description": "启动识别群员",
+                        "type": "bool",
+                        "hint": "在 Prompt 前加上群成员的名字以让模型更好地了解群聊状态。启用将略微增加 token 开销。",
+                    },
+                    "datetime_system_prompt": {
+                        "description": "启用日期时间系统提示",
+                        "type": "bool",
+                        "hint": "启用后，会在系统提示词中加上当前机器的日期时间。",
+                    },
+                    "default_personality": {
+                        "description": "默认人格",
+                        "type": "string",
+                        "hint": "默认人格（情境设置/System Prompt）文本。",
+                    },
+                    "prompt_prefix": {
+                        "description": "Prompt 前缀文本",
+                        "type": "string",
+                        "hint": "添加之后，会在每次对话的 Prompt 前加上此文本。",
+                    },
+                },
+            },
+        },
+    },
+    "misc_config_group": {
+        "name": "其他配置",
+        "metadata": {
+            "wake_prefix": {
+                "description": "机器人唤醒前缀",
+                "type": "list",
+                "items": {"type": "string"},
+                "hint": "在不 @ 机器人的情况下，可以通过外加消息前缀来唤醒机器人。",
+            },
+            "t2i": {
+                "description": "文本转图像",
+                "type": "bool",
+                "hint": "启用后，超出一定长度的文本将会通过 AstrBot API 渲染成 Markdown 图片发送。可以缓解审核和消息过长刷屏的问题，并提高 Markdown 文本的可读性。",
+            },
+            "admins_id": {
+                "description": "管理员 ID",
+                "type": "list",
+                "items": {"type": "int"},
+                "hint": "管理员 ID 列表，管理员可以使用一些特权命令，如 `update`, `plugin` 等。ID 可以通过 `/myid` 指令获得。回车添加，可添加多个。",
+            },
+            "http_proxy": {
+                "description": "HTTP 代理",
+                "type": "string",
+                "hint": "启用后，会以添加环境变量的方式设置代理。格式为 `http://ip:port`",
+            },
+            "log_level": {
+                "description": "控制台日志级别",
+                "type": "string",
+                "hint": "控制台输出日志的级别。",
+                "options": ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+            },
+            "t2i_endpoint": {
+                "description": "文本转图像服务接口",
+                "type": "string",
+                "hint": "为空时使用 AstrBot API 服务",
+            },
+            "pip_install_arg": {
+                "description": "pip 安装参数",
+                "type": "string",
+                "hint": "安装插件依赖时，会使用 Python 的 pip 工具。这里可以填写额外的参数，如 `--break-system-package` 等。",
+            },
+            "plugin_repo_mirror": {
+                "description": "插件仓库镜像",
+                "type": "string",
+                "hint": "插件仓库的镜像地址，用于加速插件的下载。",
+                "options": [
+                    "default",
+                    "https://ghp.ci/",
+                    "https://github-mirror.us.kg/",
+                ],
+            },
+        },
+    },
+}
+
+DEFAULT_VALUE_MAP = {
+    "int": 0,
+    "float": 0.0,
+    "bool": False,
+    "string": "",
+    "text": "",
+    "list": [],
+    "object": {},
+}
+
+
+# "project_atri": {
+#     "description": "Project ATRI 配置",
+#     "type": "object",
+#     "items": {
+#         "enable": {"description": "启用", "type": "bool"},
+#         "long_term_memory": {
+#             "description": "长期记忆",
+#             "type": "object",
+#             "items": {
+#                 "enable": {"description": "启用", "type": "bool"},
+#                 "summary_threshold_cnt": {
+#                     "description": "摘要阈值",
+#                     "type": "int",
+#                     "hint": "当一个会话的对话记录数量超过该阈值时，会自动进行摘要。",
+#                 },
+#                 "embedding_provider_id": {
+#                     "description": "Embedding provider ID",
+#                     "type": "string",
+#                     "hint": "只有当启用了长期记忆时，才需要填写此项。将会使用指定的 provider 来获取 Embedding，请确保所填的 provider id 在 `配置页` 中存在并且设置了 Embedding 配置",
+#                     "obvious_hint": True,
+#                 },
+#                 "summarize_provider_id": {
+#                     "description": "Summary provider ID",
+#                     "type": "string",
+#                     "hint": "只有当启用了长期记忆时，才需要填写此项。将会使用指定的 provider 来获取 Summary，请确保所填的 provider id 在 `配置页` 中存在。",
+#                     "obvious_hint": True,
+#                 },
+#             },
+#         },
+#         "active_message": {
+#             "description": "主动消息",
+#             "type": "object",
+#             "items": {
+#                 "enable": {"description": "启用", "type": "bool"},
+#             },
+#         },
+#         "vision": {
+#             "description": "视觉理解",
+#             "type": "object",
+#             "items": {
+#                 "enable": {"description": "启用", "type": "bool"},
+#                 "provider_id_or_ofa_model_path": {
+#                     "description": "提供商 ID 或 OFA 模型路径",
+#                     "type": "string",
+#                     "hint": "将会使用指定的 provider 来进行视觉处理，请确保所填的 provider id 在 `配置页` 中存在。",
+#                 },
+#             },
+#         },
+#         "split_response": {
+#             "description": "是否分割回复",
+#             "type": "bool",
+#             "hint": "启用后，将会根据句子分割回复以更像人类回复。每次回复之间具有随机的时间间隔。默认启用。",
+#         },
+#         "persona": {
+#             "description": "人格",
+#             "type": "string",
+#             "hint": "默认人格。当启动 ATRI 之后，在 Provider 处设置的人格将会失效。",
+#             "obvious_hint": True,
+#         },
+#         "chat_provider_id": {
+#             "description": "Chat provider ID",
+#             "type": "string",
+#             "hint": "将会使用指定的 provider 来进行文本聊天，请确保所填的 provider id 在 `配置页` 中存在。",
+#             "obvious_hint": True,
+#         },
+#         "chat_base_model_path": {
+#             "description": "用于聊天的基座模型路径",
+#             "type": "string",
+#             "hint": "用于聊天的基座模型路径。当填写此项和 Lora 路径后，将会忽略上面设置的 Chat provider ID。",
+#             "obvious_hint": True,
+#         },
+#         "chat_adapter_model_path": {
+#             "description": "用于聊天的 Lora 模型路径",
+#             "type": "string",
+#             "hint": "Lora 模型路径。",
+#             "obvious_hint": True,
+#         },
+#         "quantization_bit": {
+#             "description": "量化位数",
+#             "type": "int",
+#             "hint": "模型量化位数。如果你不知道这是什么，请不要修改。默认为 4。",
+#             "obvious_hint": True,
+#         },
+#     },
+# },

astrbot/core/core_lifecycle.py

@@ -0,0 +1,116 @@
+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.config.astrbot_config import AstrBotConfig
+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
+
+class AstrBotCoreLifecycle:
+    def __init__(self, log_broker: LogBroker, db: BaseDatabase):
+        self.log_broker = log_broker
+        self.astrbot_config = astrbot_config
+        self.db = db
+        
+        if self.astrbot_config['http_proxy']:
+            os.environ['https_proxy'] = self.astrbot_config['http_proxy']
+            os.environ['http_proxy'] = self.astrbot_config['http_proxy']
+    
+    async def initialize(self):
+        logger.info("AstrBot v"+ VERSION)
+        if os.environ.get("TESTING", ""):
+            logger.setLevel("DEBUG")
+        else:
+            logger.setLevel(self.astrbot_config['log_level'])
+        self.event_queue = Queue()
+        self.event_queue.closed = False
+        
+        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.star_context = Context(
+            self.event_queue, 
+            self.astrbot_config, 
+            self.db,
+            self.provider_manager,
+            self.platform_manager,
+            self.knowledge_db_manager
+        )
+        self.plugin_manager = PluginManager(self.star_context, self.astrbot_config)
+        
+        await self.plugin_manager.reload()
+        '''扫描、注册插件、实例化插件类'''
+        
+        await self.provider_manager.initialize()
+        '''根据配置实例化各个 Provider'''
+        
+        await self.platform_manager.initialize()
+        '''根据配置实例化各个平台适配器'''
+
+        self.pipeline_scheduler = PipelineScheduler(PipelineContext(self.astrbot_config, self.plugin_manager))
+        await self.pipeline_scheduler.initialize()
+        '''初始化消息事件流水线调度器'''
+        
+        self.astrbot_updator = AstrBotUpdator(self.astrbot_config['plugin_repo_mirror'])
+        self.event_bus = EventBus(self.event_queue, self.pipeline_scheduler)
+        self.start_time = int(time.time())
+        self.curr_tasks: List[asyncio.Task] = []
+
+    def _load(self):
+
+        platform_tasks = self.load_platform()
+        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__))
+        
+        self.curr_tasks = [event_bus_task, *platform_tasks, *extra_tasks]
+        self.start_time = int(time.time())
+    
+    async def start(self):
+        self._load()
+        logger.info("AstrBot 启动完成。")
+        await asyncio.gather(*self.curr_tasks, return_exceptions=True)
+        
+    async def stop(self):
+        self.event_queue.closed = True
+        for task in self.curr_tasks:
+            task.cancel()
+            
+        await self.provider_manager.terminate()
+        
+        for task in self.curr_tasks:
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+            except Exception as e:
+                logger.error(f"任务 {task.get_name()} 发生错误: {e}")
+        
+    def restart(self):
+        self.event_queue.closed = True
+        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,103 @@
+import abc
+from dataclasses import dataclass
+from typing import List
+from astrbot.core.db.po import Stats, LLMHistory, ATRIVision, WebChatConversation
+
+@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_webchat_conversation_by_user_id(self, user_id: str, cid: str) -> WebChatConversation:
+        '''通过 user_id 和 cid 获取 WebChatConversation'''
+        raise NotImplementedError
+    
+    @abc.abstractmethod
+    def webchat_new_conversation(self, user_id: str, cid: str):
+        '''新建 WebChatConversation'''
+        raise NotImplementedError
+    
+    @abc.abstractmethod
+    def get_webchat_conversations(self, user_id: str) -> List[WebChatConversation]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def update_webchat_conversation(self, user_id: str, cid: str, history: str):
+        '''更新 WebChatConversation'''
+        raise NotImplementedError
+    
+    @abc.abstractmethod
+    def delete_webchat_conversation(self, user_id: str, cid: str):
+        '''删除 WebChatConversation'''
+        raise NotImplementedError

astrbot/core/db/po.py

@@ -0,0 +1,65 @@
+'''指标数据'''
+
+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)
+    
+'''LLM 聊天时持久化的信息'''
+
+@dataclass
+class LLMHistory():
+    provider_type: str
+    session_id: str
+    content: str
+    
+@dataclass
+class ATRIVision():
+    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 WebChatConversation():
+    user_id: str
+    cid: str
+    history: str = ""
+    created_at: int = 0
+    updated_at: int = 0
+    

astrbot/core/db/sqlite.py

@@ -0,0 +1,312 @@
+import sqlite3
+import os
+import time
+from astrbot.core.db.po import (
+    Platform, 
+    Stats,
+    LLMHistory,
+    ATRIVision,
+    WebChatConversation
+)
+from . import BaseDatabase
+from typing import Tuple
+
+
+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()
+    
+    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()
+        
+        where_clause = ""
+        if session_id or provider_type:
+            where_clause += " WHERE "
+            has = False
+            if session_id:
+                where_clause += f"session_id = '{session_id}'"
+                has = True
+            if provider_type:
+                if has:
+                    where_clause += " AND "
+                where_clause += f"provider_type = '{provider_type}'"
+        
+        c.execute(
+            '''
+            SELECT * FROM llm_history
+            ''' + where_clause
+        )
+        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_webchat_conversation_by_user_id(self, user_id: str, cid: str) -> WebChatConversation:
+        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()
+        return WebChatConversation(*res)
+    
+    def webchat_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_webchat_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 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]
+            conversations.append(WebChatConversation("", cid, '[]', created_at, updated_at))
+        return conversations
+    
+    def update_webchat_conversation(self, user_id: str, cid: str, history: str):
+        self._exec_sql(
+            '''
+            UPDATE webchat_conversation SET history = ? WHERE user_id = ? AND cid = ?
+            ''', (history, user_id, cid)
+        )
+    
+    def delete_webchat_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

astrbot/core/db/sqlite_init.sql

@@ -0,0 +1,46 @@
+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,
+    cid TEXT,
+    history TEXT,
+    created_at INTEGER,
+    updated_at INTEGER
+);

astrbot/core/event_bus.py

@@ -0,0 +1,23 @@
+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):
+        logger.info("事件总线已打开。")
+        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):        
+        if event.get_sender_name():
+            logger.info(f"[{event.get_platform_name()}] {event.get_sender_name()}/{event.get_sender_id()}: {event.get_message_outline()}")
+        else:
+            logger.info(f"[{event.get_platform_name()}] {event.get_sender_id()}: {event.get_message_outline()}")

astrbot/core/log.py

@@ -0,0 +1,79 @@
+import logging
+import colorlog
+import asyncio
+from collections import deque
+from asyncio import Queue
+from typing import List
+
+CACHED_SIZE = 200
+log_color_config = {
+    'DEBUG': 'bold_blue', 'INFO': 'bold_cyan',
+    'WARNING': 'bold_yellow', 'ERROR': 'red',
+    'CRITICAL': 'bold_red', 'RESET': 'reset',
+    'asctime': 'green'
+}
+
+class LogBroker:
+    def __init__(self):
+        self.log_cache = deque(maxlen=CACHED_SIZE)
+        self.subscribers: List[Queue] = []
+    
+    def register(self) -> 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):
+        '''取消订阅'''
+        self.subscribers.remove(q)
+        
+    def publish(self, log_entry: str):
+        '''发布消息'''
+        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):
+    def __init__(self, log_broker: LogBroker):
+        super().__init__()
+        self.log_broker = log_broker
+
+    def emit(self, record):
+        log_entry = self.format(record)
+        self.log_broker.publish(log_entry)
+
+class LogManager:
+
+    @classmethod
+    def GetLogger(cls, log_name: str = 'default'):
+        logger = logging.getLogger(log_name)
+        if logger.hasHandlers():
+            return logger
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.DEBUG)
+        console_formatter = colorlog.ColoredFormatter(
+            fmt='%(log_color)s [%(asctime)s| %(levelname)s] [%(filename)s:%(lineno)d]: %(message)s %(reset)s',
+            datefmt='%H:%M:%S',
+            log_colors=log_color_config
+        )
+        console_handler.setFormatter(console_formatter)
+        logger.setLevel(logging.DEBUG)
+        logger.addHandler(console_handler)
+        
+        return logger
+    
+    @classmethod
+    def set_queue_handler(cls, logger: logging.Logger, log_broker: LogBroker):
+        handler = LogQueueHandler(log_broker)
+        handler.setLevel(logging.DEBUG)
+        if logger.handlers:
+            handler.setFormatter(logger.handlers[0].formatter)
+        else:
+            handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
+        logger.addHandler(handler)

astrbot/core/message/components.py

@@ -0,0 +1,458 @@
+'''
+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 typing as T
+from enum import Enum
+from pydantic.v1 import BaseModel
+
+class ComponentType(Enum):
+    Plain = "Plain"
+    Face = "Face"
+    Record = "Record"
+    Video = "Video"
+    At = "At"
+    RPS = "RPS"  # TODO
+    Dice = "Dice"  # TODO
+    Shake = "Shake"  # TODO
+    Anonymous = "Anonymous"  # TODO
+    Share = "Share"
+    Contact = "Contact"  # TODO
+    Location = "Location"  # TODO
+    Music = "Music"
+    Image = "Image"
+    Reply = "Reply"
+    RedBag = "RedBag"
+    Poke = "Poke"
+    Forward = "Forward"
+    Node = "Node"
+    Xml = "Xml"
+    Json = "Json"
+    CardImage = "CardImage"
+    TTS = "TTS"
+    Unknown = "Unknown"
+    File = "File"
+
+
+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 = dict()
+        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")
+
+
+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], **_):
+        # for k in _.keys():
+        #     if (k == "_type" and _[k] not in ["flash", "show", None]) or \
+        #             (k == "c" and _[k] not in [2, 3]):
+        #         logger.warn(f"Protocol: {k}={_[k]} doesn't match values")
+        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())
+
+
+class Reply(BaseMessageComponent):
+    type: ComponentType = "Reply"
+    id: int
+    text: T.Optional[str] = ""
+    qq: T.Optional[int] = 0
+    time: T.Optional[int] = 0
+    seq: T.Optional[int] = 0
+
+    def __init__(self, **_):
+        super().__init__(**_)
+
+
+class RedBag(BaseMessageComponent):
+    type: ComponentType = "RedBag"
+    title: str
+
+    def __init__(self, **_):
+        super().__init__(**_)
+
+
+class Poke(BaseMessageComponent):
+    type: ComponentType = "Poke"
+    qq: int
+
+    def __init__(self, **_):
+        super().__init__(**_)
+
+
+class Forward(BaseMessageComponent):
+    type: ComponentType = "Forward"
+    id: str
+
+    def __init__(self, **_):
+        super().__init__(**_)
+
+
+class Node(BaseMessageComponent):  # 该 component 仅支持使用 sendGroupForwardMessage 发送
+    type: ComponentType = "Node"
+    id: T.Optional[int] = 0
+    name: T.Optional[str] = ""
+    uin: T.Optional[int] = 0
+    content: T.Optional[T.Union[str, list]] = ""
+    seq: T.Optional[T.Union[str, list]] = ""  # 不清楚是什么
+    time: T.Optional[int] = 0
+
+    def __init__(self, content: T.Union[str, list], **_):
+        if isinstance(content, list):
+            _content = ""
+            for chain in content:
+                _content += chain.toString()
+            content = _content
+        super().__init__(content=content, **_)
+
+    def toString(self):
+        # logger.warn("Protocol: node doesn't support stringify")
+        return ""
+
+
+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):
+    '''
+    目前此消息段只适配了 Napcat。
+    '''
+    type: ComponentType = "File"
+    name: T.Optional[str] = "" # 名字
+    file: T.Optional[str] = "" # url（本地路径）
+    
+    def __init__(self, name: str, file: str):
+        super().__init__(name=name, file=file)
+
+
+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,
+    "xml": Xml,
+    "json": Json,
+    "cardimage": CardImage,
+    "tts": TTS,
+    "unknown": Unknown,
+    'file': File,
+}

astrbot/core/message/message_event_result.py

@@ -0,0 +1,152 @@
+import enum
+
+from typing import List, Optional
+from dataclasses import dataclass, field
+from astrbot.core.message.components import BaseMessageComponent, Plain, Image
+from typing_extensions import deprecated
+
+@dataclass
+class MessageChain():
+    '''MessageChain 描述了一整条消息中带有的所有组件。
+    现代消息平台的一条富文本消息中可能由多个组件构成，如文本、图片、At 等，并且保留了顺序。
+    
+    Attributes:
+        `chain` (list): 用于顺序存储各个组件。
+        `use_t2i_` (bool): 用于标记是否使用文本转图片服务。默认为 None，即跟随用户的设置。当设置为 True 时，将会使用文本转图片服务。
+        `is_split_` (bool): 用于标记是否分条发送消息。默认为 False。启用后，将会依次发送 chain 中的每个 component。
+    '''
+    
+    chain: List[BaseMessageComponent] = field(default_factory=list)
+    use_t2i_: Optional[bool] = None # None 为跟随用户设置
+    is_split_: Optional[bool] = False # 是否将消息分条发送。默认为 False。启用后，将会依次发送 chain 中的每个 component。
+    
+    def message(self, message: str):
+        '''添加一条文本消息到消息链 `chain` 中。
+        
+        Example:
+
+            CommandResult().message("Hello ").message("world!")
+            # 输出 Hello world!
+
+        '''
+        self.chain.append(Plain(message))
+        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 is_split(self, is_split: bool):
+        '''设置是否分条发送消息。默认为 False。启用后，将会依次发送 chain 中的每个 component。
+        
+        Note:
+            具体的效果以各适配器实现为准。
+            
+        '''
+        self.is_split_ = is_split
+        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()
+    '''普通的消息结果'''
+@dataclass
+class MessageEventResult(MessageChain):
+    '''MessageEventResult 描述了一整条消息中带有的所有组件以及事件处理的结果。
+    现代消息平台的一条富文本消息中可能由多个组件构成，如文本、图片、At 等，并且保留了顺序。
+    
+    Attributes:
+        `chain` (list): 用于顺序存储各个组件。
+        `use_t2i_` (bool): 用于标记是否使用文本转图片服务。默认为 None，即跟随用户的设置。当设置为 True 时，将会使用文本转图片服务。
+        `is_split_` (bool): 用于标记是否分条发送消息。默认为 False。启用后，将会依次发送 chain 中的每个 component。
+        `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)
+    
+    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_result_content_type(self, typ: EventResultType) -> 'MessageEventResult':
+        '''设置事件处理的结果类型。
+        
+        Args:
+            result_type (EventResultType): 事件处理的结果类型。
+        '''
+        self.result_content_type = typ
+        return self
+    
+    
+CommandResult = MessageEventResult

astrbot/core/pipeline/__init__.py

@@ -0,0 +1,29 @@
+from astrbot.core.message.message_event_result import MessageEventResult, EventResultType
+
+from .waking_check.stage import WakingCheckStage
+from .whitelist_check.stage import WhitelistCheckStage
+from .content_safety_check.stage import ContentSafetyCheckStage
+from .process_stage.stage import ProcessStage
+from .result_decorate.stage import ResultDecorateStage
+from .respond.stage import RespondStage
+
+STAGES_ORDER = [
+    "WakingCheckStage", # 检查是否需要唤醒
+    "WhitelistCheckStage", # 检查是否在群聊/私聊白名单
+    "RateLimitCheckStage", # 检查会话是否超过频率限制
+    "ContentSafetyCheckStage", # 检查内容安全
+    "ProcessStage", # 交由 Stars 处理（a.k.a 插件），或者 LLM 调用
+    "ResultDecorateStage", # 处理结果，比如添加回复前缀、t2i、转换为语音 等
+    "RespondStage" # 发送消息
+]
+
+__all__ = [
+    "WakingCheckStage",
+    "WhitelistCheckStage",
+    "ContentSafetyCheckStage",
+    "ProcessStage",
+    "ResultDecorateStage",
+    "RespondStage",
+    "MessageEventResult",
+    "EventResultType"
+]

astrbot/core/pipeline/content_safety_check/stage.py

@@ -0,0 +1,28 @@
+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) -> Union[None, AsyncGenerator[None, None]]:
+        '''检查内容安全'''
+        ok, info = self.strategy_selector.check(event.get_message_str())
+        if not ok:
+            event.set_result(MessageEventResult().message("你的消息中包含不适当的内容，已被屏蔽。"))
+            event.stop_event()
+            logger.info(f"内容安全检查不通过，原因：{info}")
+            return
+        event.continue_event()

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

@@ -1,25 +1,27 @@
+'''
+使用此功能应该先 pip install baidu-aip
+'''
+from . import ContentSafetyStrategy
 from aip import AipContentCensor
-from util.cmd_config import BaiduAIPConfig
 
-
-class BaiduJudge:
-    def __init__(self, baidu_configs: BaiduAIPConfig) -> None:
-        self.app_id = baidu_configs.app_id
-        self.api_key = baidu_configs.api_key
-        self.secret_key = baidu_configs.secret_key
+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 judge(self, text):
-        res = self.client.textCensorUserDefined(text)
+    def check(self, content: str):
+        res = self.client.textCensorUserDefined(content)
         if 'conclusionType' not in res:
-            return False, "百度审核服务未知错误"
+            return False, ""
         if res['conclusionType'] == 1:
-            return True, "合规"
+            return True, ""
         else:
             if 'data' not in res:
-                return False, "百度审核服务未知错误"
+                return False, ""
             count = len(res['data'])
             info = f"百度审核服务发现 {count} 处违规：\n"
             for i in res['data']:

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

@@ -0,0 +1,23 @@
+import re
+import os
+import json
+import base64
+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,33 @@
+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/content_safety_check/strategies/unfit_words

@@ -0,0 +1 @@
+ewogICAgImtleXdvcmRzIjogWwogICAgICAgICLkuaDov5HlubMiLAogICAgICAgICLog6HplKbmtpsiLAogICAgICAgICLmsZ/ms73msJEiLAogICAgICAgICLmuKnlrrblrp0iLAogICAgICAgICLmnY7lhYvlvLoiLAogICAgICAgICLmnY7plb/mmKUiLAogICAgICAgICLmr5vms73kuJwiLAogICAgICAgICLpgpPlsI/lubMiLAogICAgICAgICLlkajmganmnaUiLAogICAgICAgICLnpL7kvJrkuLvkuYkiLAogICAgICAgICLlhbHkuqflhZoiLAogICAgICAgICLlhbHkuqfkuLvkuYkiLAogICAgICAgICLlpKfpmYblrpjmlrkiLAogICAgICAgICLljJfkuqzmlL/mnYMiLAogICAgICAgICLkuK3ljY7luJ3lm70iLAogICAgICAgICLkuK3lm73mlL/lupwiLAogICAgICAgICLlhbHni5ciLAogICAgICAgICLlha3lm5vkuovku7YiLAogICAgICAgICLlpKnlronpl6giLAogICAgICAgICLlha3lm5siLAogICAgICAgICLmlL/msrvlsYDluLjlp5QiLAogICAgICAgICLlrabmva4iLAogICAgICAgICLlhavkuZ0iLAogICAgICAgICLkuozljYHlpKciLAogICAgICAgICLmsJHov5vlhZoiLAogICAgICAgICLlj7Dni6wiLAogICAgICAgICLlj7Dmub7ni6znq4siLAogICAgICAgICLlj7Dmub7lm70iLAogICAgICAgICLlm73msJHlhZoiLAogICAgICAgICLlj7Dmub7msJHlm70iLAogICAgICAgICLkuK3ljY7msJHlm70iLAogICAgICAgICJwb3JuaHViIiwKICAgICAgICAiUG9ybmh1YiIsCiAgICAgICAgIuS9nOeIsSIsCiAgICAgICAgIuWBmueIsSIsCiAgICAgICAgIuaAp+S6pCIsCiAgICAgICAgIuiHquaFsCIsCiAgICAgICAgIumYtOiMjiIsCiAgICAgICAgIua3q+WmhyIsCiAgICAgICAgIuiCm+S6pCIsCiAgICAgICAgIuS6pOmFjSIsCiAgICAgICAgIuaAp+WFs+ezuyIsCiAgICAgICAgIuaAp+a0u+WKqCIsCiAgICAgICAgIuiJsuaDhSIsCiAgICAgICAgIuiJsuWbviIsCiAgICAgICAgIuijuOS9kyIsCiAgICAgICAgIuWwj+eptCIsCiAgICAgICAgIua3q+iNoSIsCiAgICAgICAgIuaAp+eIsSIsCiAgICAgICAgIua4r+eLrCIsCiAgICAgICAgIuazlei9ruWKnyIsCiAgICAgICAgIuWFreWbmyIKICAgIF0KfQ==

astrbot/core/pipeline/context.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+from astrbot.core.config.astrbot_config import AstrBotConfig
+from astrbot.core.star import PluginManager
+
+@dataclass
+class PipelineContext:
+    astrbot_config: AstrBotConfig
+    plugin_manager: PluginManager

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

@@ -0,0 +1,60 @@
+'''
+Dify 调用 Stage
+'''
+import traceback
+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
+from astrbot.core.message.components import Image
+from astrbot.core import logger
+from astrbot.core.utils.metrics import Metric
+from astrbot.core.provider.entites import ProviderRequest
+
+class DifyRequestSubStage(Stage):
+    
+    async def initialize(self, ctx: PipelineContext) -> None:
+        self.ctx = ctx
+        
+    async def process(self, event: AstrMessageEvent) -> Union[None, AsyncGenerator[None, None]]:
+        req: ProviderRequest = None
+        
+        provider = self.ctx.plugin_manager.context.get_using_provider()
+        if provider.meta().type != "dify":
+            return
+        
+        if event.get_extra("provider_request"):
+            req = event.get_extra("provider_request")
+            assert isinstance(req, ProviderRequest), "provider_request 必须是 ProviderRequest 类型。"
+        else:
+            req = ProviderRequest(prompt="", image_urls=[])
+            if self.ctx.astrbot_config['provider_settings']['wake_prefix']:
+                if not event.message_str.startswith(self.ctx.astrbot_config['provider_settings']['wake_prefix']):
+                    return
+            req.prompt = event.message_str[len(self.ctx.astrbot_config['provider_settings']['wake_prefix']):]
+            for comp in event.message_obj.message:
+                if isinstance(comp, Image):
+                    image_url = comp.url if comp.url else comp.file
+                    req.image_urls.append(image_url)
+            req.session_id = event.session_id
+            event.set_extra("provider_request", req)
+            
+        if not req.prompt:
+            return
+            
+        try:
+            logger.debug(f"Dify 请求 Payload: {req.__dict__}")
+            llm_response = await provider.text_chat(**req.__dict__) # 请求 LLM
+            await Metric.upload(llm_tick=1, model_name=provider.get_model(), provider_type=provider.meta().type)
+
+            if llm_response.role == 'assistant':
+                # text completion
+                event.set_result(MessageEventResult().message(llm_response.completion_text)
+                                 .set_result_content_type(ResultContentType.LLM_RESULT))
+                yield # rick roll
+
+        except BaseException as e:
+            logger.error(traceback.format_exc())
+            event.set_result(MessageEventResult().message("AstrBot 请求 Dify 失败：" + str(e)))
+            return

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

@@ -0,0 +1,102 @@
+'''
+本地 Agent 模式的 LLM 调用 Stage
+'''
+import traceback
+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
+from astrbot.core.message.components import Image
+from astrbot.core import logger
+from astrbot.core.utils.metrics import Metric
+from astrbot.core.provider.entites import ProviderRequest
+from astrbot.core.star.star_handler import star_handlers_registry, EventType
+
+class LLMRequestSubStage(Stage):
+    
+    async def initialize(self, ctx: PipelineContext) -> None:
+        self.ctx = ctx
+        
+    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 类型。"
+        else:
+            req = ProviderRequest(prompt="", image_urls=[])
+            if self.ctx.astrbot_config['provider_settings']['wake_prefix']:
+                if not event.message_str.startswith(self.ctx.astrbot_config['provider_settings']['wake_prefix']):
+                    return
+            req.prompt = event.message_str[len(self.ctx.astrbot_config['provider_settings']['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_url = comp.url if comp.url else comp.file
+                    req.image_urls.append(image_url)
+            req.session_id = event.session_id
+            event.set_extra("provider_request", req)
+            session_provider_context = provider.session_memory.get(event.session_id)
+            req.contexts = session_provider_context if session_provider_context else []
+            
+        if not req.prompt:
+            return
+            
+        # 执行请求 LLM 前事件。
+        # 装饰 system_prompt 等功能
+        handlers = star_handlers_registry.get_handlers_by_event_type(EventType.OnLLMRequestEvent)
+        for handler in handlers:
+            try:
+                await handler.handler(event, req)
+            except BaseException:
+                logger.error(traceback.format_exc())
+        
+        try:
+            logger.debug(f"提供商请求 Payload: {req.__dict__}")
+            if _nested:
+                req.func_tool = None # 暂时不支持递归工具调用
+            llm_response = await provider.text_chat(**req.__dict__) # 请求 LLM
+            await Metric.upload(llm_tick=1, model_name=provider.get_model(), provider_type=provider.meta().type)
+
+            if llm_response.role == 'assistant':
+                # text completion
+                event.set_result(MessageEventResult().message(llm_response.completion_text)
+                                 .set_result_content_type(ResultContentType.LLM_RESULT))
+            elif llm_response.role == 'tool':
+                # function calling
+                function_calling_result = {}
+                for func_tool_name, func_tool_args in zip(llm_response.tools_call_name, llm_response.tools_call_args):
+                    func_tool = req.func_tool.get_func(func_tool_name)
+                    logger.info(f"调用工具函数：{func_tool_name}，参数：{func_tool_args}")
+                    try:
+                        # 尝试调用工具函数
+                        wrapper = self._call_handler(self.ctx, event, func_tool.handler, **func_tool_args)
+                        async for resp in wrapper:
+                            if resp is not None:
+                                function_calling_result[func_tool_name] = resp
+                            else:
+                                yield
+                        event.clear_result() # 清除上一个 handler 的结果
+                    except BaseException as e:
+                        logger.warning(traceback.format_exc())
+                        function_calling_result[func_tool_name] = "When calling the function, an error occurred: " + str(e)
+                if function_calling_result:
+                    # 工具返回 LLM 资源。比如 RAG、网页 得到的相关结果等。
+                    # 我们重新执行一遍这个 stage
+                    req.func_tool = None # 暂时不支持递归工具调用
+                    extra_prompt = "\n\nSystem executed some external tools for this task and here are the results:\n"
+                    for tool_name, tool_result in function_calling_result.items():
+                        extra_prompt += f"Tool: {tool_name}\nTool Result: {tool_result}\n"
+                    req.prompt += extra_prompt
+                    async for _ in self.process(event, _nested=True):
+                        yield
+
+        except BaseException as e:
+            logger.error(traceback.format_exc())
+            event.set_result(MessageEventResult().message("AstrBot 请求 LLM 资源失败：" + str(e)))
+            return

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

@@ -0,0 +1,46 @@
+'''
+本地 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:
+            params = handlers_parsed_params.get(handler.handler_full_name, {})
+            try:
+                if handler.handler_module_path not in star_map:
+                    # 孤立无援的 star handler 
+                    continue
+                
+                logger.debug(f"执行 Star Handler {handler.handler_full_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}")
+                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,58 @@
+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 .method.dify_request import DifyRequestSubStage
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core.star.star_handler import StarHandlerMetadata
+from astrbot.core.provider.entites 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)
+        
+        self.dify_request_sub_stage = DifyRequestSubStage()
+        await self.dify_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 请求
+                    logger.debug(f"llm request -> {resp.prompt}")
+                    event.set_extra("provider_request", resp)
+                    async for _ in self.llm_request_sub_stage.process(event):
+                        yield
+                else:
+                    yield
+        
+        # 调用提供商相关请求
+        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:
+            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()
+                match provider.meta().type:
+                    case "dify":
+                        async for _ in self.dify_request_sub_stage.process(event):
+                            yield
+                    case _:
+                        async for _ in self.llm_request_sub_stage.process(event):
+                            yield

astrbot/core/pipeline/rate_limit_check/stage.py

@@ -0,0 +1,87 @@
+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.message.message_event_result import MessageEventResult
+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:
+                        logger.info(f"会话 {session_id} 被限流。根据限流策略，此会话处理将被暂停 {stall_duration:.2f} 秒。")
+                        await asyncio.sleep(stall_duration)
+                    case RateLimitStrategy.DISCARD:
+                        event.set_result(MessageEventResult().message(f"会话 {session_id} 被限流。根据限流策略，此请求已被丢弃，直到您的限额于 {stall_duration:.2f} 秒后重置。"))
+                        return event.stop_event()
+                
+                self._remove_expired_timestamps(timestamps, now + timedelta(seconds=stall_duration))
+
+            timestamps.append(now)
+
+        return event.continue_event()
+
+    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,27 @@
+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 import logger
+from astrbot.core.star.star_handler import star_handlers_registry, EventType
+
+@register_stage
+class RespondStage(Stage):
+    async def initialize(self, ctx: PipelineContext):
+        self.ctx = ctx
+
+    async def process(self, event: AstrMessageEvent) -> Union[None, AsyncGenerator[None, None]]:
+        result = event.get_result()
+        if result is None:
+            return
+
+        if len(result.chain) > 0:
+            await event.send(result)
+            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)
+        for handler in handlers:
+            # TODO: 如何让这里的 handler 也能使用 LLM 能力。也许需要将 LLMRequestSubStage 提取出来。
+            await handler.handler(event)
+            
+        event.clear_result()

astrbot/core/pipeline/result_decorate/stage.py

@@ -0,0 +1,51 @@
+import time
+from typing import Union, AsyncGenerator
+from ..stage import 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, Image
+from astrbot.core import html_renderer
+from astrbot.core.star.star_handler import star_handlers_registry, EventType
+
+@register_stage
+class ResultDecorateStage:
+    async def initialize(self, ctx: PipelineContext):
+        self.ctx = ctx
+        self.reply_prefix = ctx.astrbot_config['platform_settings']['reply_prefix']
+        self.t2i = ctx.astrbot_config['t2i']
+
+    async def process(self, event: AstrMessageEvent) -> Union[None, AsyncGenerator[None, None]]:
+        result = event.get_result()
+        if result is None:
+            return
+        
+        handlers = star_handlers_registry.get_handlers_by_event_type(EventType.OnDecoratingResultEvent)
+        for handler in handlers:
+            # TODO: 如何让这里的 handler 也能使用 LLM 能力。也许需要将 LLMRequestSubStage 提取出来。
+            await handler.handler(event)
+        
+        if len(result.chain) > 0:
+            # 回复前缀
+            if self.reply_prefix:
+                result.chain.insert(0, Plain(self.reply_prefix))
+            
+            # 文本转图片
+            if (result.use_t2i_ is None and self.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) > 150:
+                    render_start = time.time()
+                    try:
+                        url = await html_renderer.render_t2i(plain_str, return_url=True)
+                    except BaseException:
+                        logger.error("文本转图片失败，使用文本发送。")
+                        return
+                    if time.time() - render_start > 3:
+                        logger.warning("文本转图片耗时超过了 3 秒，如果觉得很慢可以使用 /t2i 关闭文本转图片模式。")
+                    if url:
+                        result.chain = [Image.fromURL(url)]

astrbot/core/pipeline/scheduler.py

@@ -0,0 +1,44 @@
+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):
+        for i in range(from_stage, len(registered_stages)):
+            stage = registered_stages[i]
+            logger.debug(f"执行阶段 {stage.__class__ .__name__}")
+            coro = stage.process(event)
+            if isinstance(coro, AsyncGenerator):
+                async for _ in coro:
+                    if event.is_stopped():
+                        logger.debug(f"阶段 {stage.__class__ .__name__} 已终止事件传播。")
+                        break
+                    await self._process_stages(event, i + 1)
+            else:
+                await coro
+
+                if event.is_stopped():
+                    logger.debug(f"阶段 {stage.__class__ .__name__} 已终止事件传播。")
+                    break
+
+            if event.is_stopped():
+                logger.debug(f"阶段 {stage.__class__ .__name__} 已终止事件传播。")
+                break
+    
+    async def execute(self, event: AstrMessageEvent):
+        '''执行 pipeline'''
+        await self._process_stages(event)
+        logger.debug("pipeline 执行完毕。")

astrbot/core/pipeline/stage.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+import abc
+import inspect
+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:
+        '''初始化阶段
+        '''
+        raise NotImplementedError
+    
+    @abc.abstractmethod
+    async def process(self, event: AstrMessageEvent) -> Union[None, AsyncGenerator[None, None]]:
+        '''处理事件
+        '''
+        raise NotImplementedError
+    
+    async def _call_handler(
+        self, 
+        ctx: PipelineContext,
+        event: AstrMessageEvent, 
+        handler: Awaitable,
+        **params
+    ) -> AsyncGenerator[None, None]:
+        '''调用 Handler。'''
+        # 判断 handler 是否是类方法（通过装饰器注册的没有 __self__ 属性）
+        ready_to_call = None
+        try:
+            ready_to_call = handler(event, **params)
+        except TypeError as e:
+            # 向下兼容
+            ready_to_call = handler(event, ctx.plugin_manager.context, **params)
+        
+        if isinstance(ready_to_call, AsyncGenerator):
+            async for ret in ready_to_call:
+                # 如果处理函数是生成器，返回值只能是 MessageEventResult 或者 None（无返回值）
+                if isinstance(ret, (MessageEventResult, CommandResult)):
+                    event.set_result(ret)
+                    yield
+                else:
+                    yield ret
+        elif inspect.iscoroutine(ready_to_call):
+            # 如果只是一个 coroutine
+            ret = await ready_to_call
+            if isinstance(ret, (MessageEventResult, CommandResult)):
+                event.set_result(ret)
+                yield
+            else:
+                yield ret

astrbot/core/pipeline/waking_check/stage.py

@@ -0,0 +1,128 @@
+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.message.message_event_result import MessageEventResult
+from astrbot.core.message.components import At
+from astrbot.core.star.star_handler import star_handlers_registry, EventType
+from astrbot.core.star.filter.command_group import CommandGroupFilter
+
+
+@register_stage
+class WakingCheckStage(Stage):
+    """检查是否需要唤醒。唤醒机器人有如下几点条件：
+
+    1. 机器人被 @ 了
+    2. 机器人的消息被提到了
+    3. 以 wake_prefix 前缀开头，并且消息没有以 At 消息段开头
+    4. 插件（Star）的 handler filter 通过
+    5. 私聊情况下，位于 admins_id 列表中的管理员的消息（在白名单阶段中）
+    """
+
+    async def initialize(self, ctx: PipelineContext) -> None:
+        self.ctx = ctx
+
+    async def process(
+        self, event: AstrMessageEvent
+    ) -> Union[None, AsyncGenerator[None, None]]:
+        # 设置 sender 身份
+        event.message_str = event.message_str.strip()
+        for admin_id in self.ctx.astrbot_config["admins_id"]:
+            if event.get_sender_id() == admin_id:
+                event.role = "admin"
+                break
+
+        # 检查 wake
+        wake_prefixes = self.ctx.astrbot_config["wake_prefix"]
+        messages = event.get_messages()
+        is_wake = False
+        for wake_prefix in wake_prefixes:
+            if event.message_str.startswith(wake_prefix):
+                if (
+                    not event.is_private_chat()
+                    and isinstance(messages[0], At)
+                    and str(messages[0].qq) != str(event.get_self_id())
+                    and str(messages[0].qq) != "all"
+                ):
+                    # 如果是群聊，且第一个消息段是 At 消息，但不是 At 机器人或 At 全体成员，则不唤醒
+                    break
+                is_wake = True
+                event.is_at_or_wake_command = True
+                event.is_wake = True
+                event.message_str = event.message_str[len(wake_prefix) :].strip()
+                break
+        if not is_wake:
+            # 检查是否有 at 消息
+            for message in messages:
+                if isinstance(message, At) and (
+                    str(message.qq) == str(event.get_self_id())
+                    or str(message.qq) == "all"
+                ):
+                    is_wake = True
+                    event.is_wake = True
+                    wake_prefix = ""
+                    event.is_at_or_wake_command = True
+                    break
+            # 检查是否是私聊
+            if event.is_private_chat():
+                is_wake = True
+                event.is_wake = True
+                event.is_at_or_wake_command = True
+                wake_prefix = ""
+
+        # 检查插件的 handler filter
+        activated_handlers = []
+        handlers_parsed_params = {}  # 注册了指令的 handler
+        for handler in star_handlers_registry.get_handlers_by_event_type(EventType.AdapterMessageEvent):
+            # filter 需要满足 AND 的逻辑关系
+            passed = True
+            child_command_handler_md = None
+
+            if len(handler.event_filters) == 0:
+                # 不可能有这种情况, 也不允许有这种情况
+                continue
+
+            for filter in handler.event_filters:
+                try:
+                    if isinstance(filter, CommandGroupFilter):
+                        """如果指令组过滤成功, 会返回叶子指令的 StarHandlerMetadata"""
+                        ok, child_command_handler_md = filter.filter(
+                            event, self.ctx.astrbot_config
+                        )
+                        if not ok:
+                            passed = False
+                        else:
+                            handler = child_command_handler_md  # handler 覆盖
+                            break
+                    else:
+                        if not filter.filter(event, self.ctx.astrbot_config):
+                            passed = False
+                            break
+                except Exception as e:
+                    # event.set_result(MessageEventResult().message(f"插件 {handler.handler_full_name} 报错：{e}"))
+                    # yield
+                    await event.send(
+                        MessageEventResult().message(
+                            f"插件 {handler.handler_full_name} 报错：{e}"
+                        )
+                    )
+                    event.stop_event()
+                    passed = False
+                    break
+
+            if passed:
+                is_wake = True
+                event.is_wake = True
+
+                activated_handlers.append(handler)
+                if "parsed_params" in event.get_extra():
+                    handlers_parsed_params[handler.handler_full_name] = event.get_extra(
+                        "parsed_params"
+                    )
+            event.clear_extra()
+
+        event.set_extra("activated_handlers", activated_handlers)
+        event.set_extra("handlers_parsed_params", handlers_parsed_params)
+
+        if not is_wake:
+            event.stop_event()

astrbot/core/pipeline/whitelist_check/stage.py

@@ -0,0 +1,37 @@
+from ..stage import Stage, register_stage
+from ..context import PipelineContext
+from typing import AsyncGenerator, Union
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core.platform.message_type import MessageType
+from astrbot.core import logger
+
+@register_stage
+class WhitelistCheckStage(Stage):
+    '''检查是否在群聊/私聊白名单
+    '''
+    async def initialize(self, ctx: PipelineContext) -> None:
+        self.enable_whitelist_check = ctx.astrbot_config['platform_settings']['enable_id_white_list']
+        self.whitelist = ctx.astrbot_config['platform_settings']['id_whitelist']
+        self.wl_ignore_admin_on_group = ctx.astrbot_config['platform_settings']['wl_ignore_admin_on_group']
+        self.wl_ignore_admin_on_friend = ctx.astrbot_config['platform_settings']['wl_ignore_admin_on_friend']    
+        self.wl_log = ctx.astrbot_config['platform_settings']['id_whitelist_log']
+        
+    async def process(self, event: AstrMessageEvent) -> Union[None, AsyncGenerator[None, None]]:
+        if not self.enable_whitelist_check:
+            return
+        
+        if event.get_platform_name() == 'webchat':
+            # WebChat 豁免
+            return
+        
+        # 检查是否在白名单
+        if self.wl_ignore_admin_on_group:
+            if event.role == 'admin' and event.get_message_type() == MessageType.GROUP_MESSAGE:
+                return
+        if self.wl_ignore_admin_on_friend:
+            if event.role == 'admin' and event.get_message_type() == MessageType.FRIEND_MESSAGE:
+                return
+        if event.unified_msg_origin not in self.whitelist:
+            if self.wl_log:
+                logger.info(f"会话 ID {event.unified_msg_origin} 不在会话白名单中，已终止事件传播。请在配置文件中添加该会话 ID 到白名单。")
+            event.stop_event()

astrbot/core/platform/__init__.py

@@ -0,0 +1,4 @@
+from .platform import Platform
+from .astr_message_event import AstrMessageEvent
+from .platform_metadata import PlatformMetadata
+from .astrbot_message import AstrBotMessage, MessageMember, MessageType

astrbot/core/platform/astr_message_event.py

@@ -0,0 +1,312 @@
+import abc
+from dataclasses import dataclass
+from .astrbot_message import AstrBotMessage
+from .platform_metadata import PlatformMetadata
+from astrbot.core.message.message_event_result import MessageEventResult, MessageChain
+from astrbot.core.platform.message_type import MessageType
+from typing import List, Union
+from astrbot.core.message.components import Plain, Image, BaseMessageComponent, Face, At, AtAll, Forward
+from astrbot.core.utils.metrics import Metric
+from astrbot.core.provider.entites import ProviderRequest
+
+
+@dataclass
+class MessageSesion:
+    platform_name: str
+    message_type: MessageType
+    session_id: str
+    
+    def __str__(self):
+        return f"{self.platform_name}:{self.message_type.value}:{self.session_id}"
+    
+    @staticmethod
+    def from_str(session_str: str):
+        platform_name, message_type, session_id = session_str.split(":")
+        return MessageSesion(platform_name, MessageType(message_type), session_id)
+
+class AstrMessageEvent(abc.ABC):
+    def __init__(self, 
+                message_str: str,
+                message_obj: AstrBotMessage,
+                platform_meta: PlatformMetadata,
+                session_id: str,):
+        self.message_str = message_str
+        self.message_obj = message_obj
+        self.platform_meta = platform_meta
+        self.session_id = session_id
+        self.role = "member"
+        self.is_wake = False # 是否通过 WakingStage
+        self.is_at_or_wake_command = False # 是否是 At 机器人或者带有唤醒词或者是私聊（事件监听器会让 is_wake 设为 True）
+        self._extras = {}
+        self.session = MessageSesion(
+            platform_name=platform_meta.name,
+            message_type=message_obj.type,
+            session_id=session_id
+        )
+        self.unified_msg_origin = str(self.session)
+        
+        self._result: MessageEventResult = None
+        '''消息事件的结果'''
+        
+        self._has_send_oper = False 
+        '''是否有过至少一次发送操作'''
+        
+        
+        # back_compability
+        self.platform = platform_meta
+    
+    def get_platform_name(self):
+        return self.platform_meta.name
+    
+    def get_message_str(self) -> str:
+        '''
+        获取消息字符串。
+        '''
+        return self.message_str
+    
+    def _outline_chain(self, chain: List[BaseMessageComponent]) -> str:
+        outline = ""
+        for i in chain:
+            if isinstance(i, Plain):
+                outline += i.text
+            elif isinstance(i, Image):
+                outline += "[图片]"
+            elif isinstance(i, Face):
+                outline += f"[表情:{i.id}]"
+            elif isinstance(i, At):
+                outline += f"[At:{i.qq}]"
+            elif isinstance(i, AtAll):
+                outline += "[At:全体成员]"
+            elif isinstance(i, Forward):
+                # 转发消息
+                outline += "[转发消息]"
+            else:
+                outline += f"[{i.type}]"
+        return outline
+    
+    def get_message_outline(self) -> str:
+        '''
+        获取消息概要。
+        
+        除了文本消息外，其他消息类型会被转换为对应的占位符。如图片消息会被转换为 [图片]。
+        '''
+        return self._outline_chain(self.message_obj.message)
+    
+    def get_messages(self) -> List[BaseMessageComponent]:
+        '''
+        获取消息链。
+        '''
+        return self.message_obj.message
+    
+    def get_message_type(self) -> MessageType:
+        '''
+        获取消息类型。
+        '''
+        return self.message_obj.type
+    
+    def get_session_id(self) -> str:
+        '''
+        获取会话id。
+        '''
+        return self.session_id
+    
+    def get_group_id(self) -> str:
+        '''
+        获取群组id。如果不是群组消息，返回空字符串。
+        '''
+        return self.message_obj.group_id
+    
+    def get_self_id(self) -> str:
+        '''
+        获取机器人自身的id。
+        '''
+        return self.message_obj.self_id
+    
+    def get_sender_id(self) -> str:
+        '''
+        获取消息发送者的id。
+        '''
+        return self.message_obj.sender.user_id
+    
+    def get_sender_name(self) -> str:
+        '''
+        获取消息发送者的名称。(可能会返回空字符串)
+        '''
+        return self.message_obj.sender.nickname
+        
+    def set_extra(self, key, value):
+        '''
+        设置额外的信息。
+        '''
+        self._extras[key] = value
+        
+    def get_extra(self, key = None):
+        '''
+        获取额外的信息。
+        '''
+        if key is None:
+            return self._extras
+        return self._extras.get(key, None)
+    
+    def clear_extra(self):
+        '''
+        清除额外的信息。
+        '''
+        self._extras.clear()
+        
+    def is_private_chat(self) -> bool:
+        '''
+        是否是私聊。
+        '''
+        return self.message_obj.type.value == (MessageType.FRIEND_MESSAGE).value
+    
+    def is_wake_up(self) -> bool:
+        '''
+        是否是唤醒机器人的事件。
+        '''
+        return self.is_wake
+    
+    def is_admin(self) -> bool:
+        '''
+        是否是管理员。
+        '''
+        return self.role == "admin"
+    
+    async def send(self, message: MessageChain):
+        '''
+        发送消息到消息平台。
+        '''
+        await Metric.upload(msg_event_tick = 1, adapter_name = self.platform_meta.name)
+        self._has_send_oper = True
+        
+    def set_result(self, result: Union[MessageEventResult, str]):
+        '''设置消息事件的结果。
+        
+        Note:
+            事件处理器可以通过设置结果来控制事件是否继续传播，并向消息适配器发送消息。
+            
+            如果没有设置 `MessageEventResult` 中的 result_type，默认为 CONTINUE。即事件将会继续向后面的 listener 或者 command 传播。
+        
+        Example:
+        ```
+        async def ban_handler(self, event: AstrMessageEvent):
+            if event.get_sender_id() in self.blacklist:
+                event.set_result(MessageEventResult().set_console_log("由于用户在黑名单，因此消息事件中断处理。")).set_result_type(EventResultType.STOP)
+                return
+            
+        async def check_count(self, event: AstrMessageEvent):
+            self.count += 1
+            event.set_result(MessageEventResult().set_console_log("数量已增加", logging.DEBUG).set_result_type(EventResultType.CONTINUE))
+            return
+        ```
+        '''
+        if isinstance(result, str):
+            result = MessageEventResult().message(result)
+        self._result = result
+        
+    def stop_event(self):
+        '''终止事件传播。
+        '''
+        if self._result is None:
+            self.set_result(MessageEventResult().stop_event())
+        else:
+            self._result.stop_event()
+        
+    def continue_event(self):
+        '''继续事件传播。
+        '''
+        if self._result is None:
+            self.set_result(MessageEventResult().continue_event())
+        else:
+            self._result.continue_event()
+            
+    def is_stopped(self) -> bool:
+        '''
+        是否终止事件传播。
+        '''
+        if self._result is None:
+            return False # 默认是继续传播
+        return self._result.is_stopped()        
+        
+    def get_result(self) -> MessageEventResult:
+        '''
+        获取消息事件的结果。
+        '''
+        return self._result
+    
+    def clear_result(self):
+        '''
+        清除消息事件的结果。
+        '''
+        self._result = None
+    
+    '''消息链相关'''
+    
+    def make_result(self) -> MessageEventResult:
+        '''
+        创建一个空的消息事件结果。
+        
+        Example:
+        
+        ```python
+        # 纯文本回复
+        yield event.make_result().message("Hi")
+        # 发送图片
+        yield event.make_result().url_image("https://example.com/image.jpg")
+        yield event.make_result().file_image("image.jpg")
+        ```
+        '''
+        return MessageEventResult()
+    
+    def plain_result(self, text: str) -> MessageEventResult:
+        '''
+        创建一个空的消息事件结果，只包含一条文本消息。
+        '''
+        return MessageEventResult().message(text)
+    
+    def image_result(self, url_or_path: str) -> MessageEventResult:
+        '''
+        创建一个空的消息事件结果，只包含一条图片消息。
+        
+        根据开头是否包含 http 来判断是网络图片还是本地图片。
+        '''
+        if url_or_path.startswith("http"):
+            return MessageEventResult().url_image(url_or_path)
+        return MessageEventResult().file_image(url_or_path)
+    
+    def chain_result(self, chain: List[BaseMessageComponent]) -> MessageEventResult:
+        '''
+        创建一个空的消息事件结果，包含指定的消息链。
+        '''
+        mer = MessageEventResult()
+        mer.chain = chain
+        return mer
+    
+    '''LLM 请求相关'''
+    
+    def request_llm(
+        self,
+        prompt: str,
+        session_id: str = None,
+        image_urls: List[str] = None,
+        contexts: List = None,
+        system_prompt: str = ""
+    ) -> ProviderRequest:
+        '''
+        创建一个 LLM 请求。
+        
+        Examples:
+        ```py
+        yield event.request_llm(prompt="hi")
+        ```
+        
+        image_urls: 可以是 base64:// 或者 http:// 开头的图片链接，也可以是本地图片路径。
+        contexts: 当指定 contexts 时，将会**只**使用 contexts 作为上下文。
+        '''
+        return ProviderRequest(
+            prompt = prompt,
+            session_id = session_id,
+            image_urls = image_urls,
+            contexts = contexts,
+            system_prompt = system_prompt
+        )

astrbot/core/platform/astrbot_message.py

@@ -1,29 +1,23 @@
 import time
-from enum import Enum
 from typing import List
 from dataclasses import dataclass
-from nakuru.entities.components import BaseMessageComponent
-
-class MessageType(Enum):
-    GROUP_MESSAGE = 'GroupMessage'  # 群组形式的消息
-    FRIEND_MESSAGE = 'FriendMessage'  # 私聊、好友等单聊消息
-    GUILD_MESSAGE = 'GuildMessage'  # 频道消息
+from astrbot.core.message.components import BaseMessageComponent
+from .message_type import MessageType
 
 @dataclass
 class MessageMember():
     user_id: str  # 发送者id
     nickname: str = None
 
-
-class AstrBotMessage():
+class AstrBotMessage:
     '''
     AstrBot 的消息对象
     '''
-    tag: str  # 消息来源标签
     type: MessageType  # 消息类型
     self_id: str  # 机器人的识别id
-    session_id: str  # 会话id
+    session_id: str  # 会话id。取决于 unique_session 的设置。
     message_id: str  # 消息id
+    group_id: str = "" # 群组id，如果为私聊，则为空
     sender: MessageMember  # 发送者
     message: List[BaseMessageComponent]  # 消息链使用 Nakuru 的消息链格式
     message_str: str  # 最直观的纯文本消息字符串

astrbot/core/platform/manager.py

@@ -0,0 +1,45 @@
+from astrbot.core.config.astrbot_config import AstrBotConfig
+from .platform import Platform
+from typing import List
+from asyncio import Queue
+from .register import platform_cls_map
+from astrbot.core import logger
+from .sources.webchat.webchat_adapter import WebChatAdapter
+
+class PlatformManager():
+    def __init__(self, config: AstrBotConfig, event_queue: Queue):
+        self.platform_insts: List[Platform] = []
+        '''加载的 Platform 的实例'''
+        
+        self.platforms_config = config['platform']
+        self.settings = config['platform_settings']
+        self.event_queue = event_queue
+        
+        for platform in self.platforms_config:
+            if not platform['enable']:
+                continue
+            match platform['type']:
+                case "aiocqhttp":
+                    from .sources.aiocqhttp.aiocqhttp_platform_adapter import AiocqhttpAdapter  # noqa: F401
+                case "qq_official":
+                    from .sources.qqofficial.qqofficial_platform_adapter import QQOfficialPlatformAdapter # noqa: F401
+                case "vchat":
+                    from .sources.vchat.vchat_platform_adapter import VChatPlatformAdapter # noqa: F401
+        
+
+    async def initialize(self):
+        for platform in self.platforms_config:
+            if not platform['enable']:
+                continue
+            if platform['type'] not in platform_cls_map:
+                logger.error(f"未找到适用于 {platform['type']}({platform['id']}) 平台适配器，请检查是否已经安装或者名称填写错误。已跳过。")
+                continue
+            cls_type = platform_cls_map[platform['type']]
+            logger.info(f"尝试实例化 {platform['type']}({platform['id']}) 平台适配器 ...")
+            inst = cls_type(platform, self.settings, self.event_queue)
+            self.platform_insts.append(inst)
+        
+        self.platform_insts.append(WebChatAdapter({}, self.settings, self.event_queue))
+                    
+    def get_insts(self):
+        return self.platform_insts

astrbot/core/platform/message_type.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+class MessageType(Enum):
+    GROUP_MESSAGE = 'GroupMessage'  # 群组形式的消息
+    FRIEND_MESSAGE = 'FriendMessage'  # 私聊、好友等单聊消息
+    OTHER_MESSAGE = 'OtherMessage'  # 其他类型的消息，如系统消息等

astrbot/core/platform/platform.py

@@ -0,0 +1,42 @@
+import abc
+from typing import Awaitable, Any
+from asyncio import Queue
+from .platform_metadata import PlatformMetadata
+from .astr_message_event import AstrMessageEvent
+from astrbot.core.message.message_event_result import MessageChain
+from .astr_message_event import MessageSesion
+from astrbot.core.utils.metrics import Metric
+
+class Platform(abc.ABC):
+    def __init__(self, event_queue: Queue):
+        super().__init__()
+        # 维护了消息平台的事件队列，EventBus 会从这里取出事件并处理。
+        self._event_queue = event_queue
+    
+    @abc.abstractmethod
+    def run(self) -> Awaitable[Any]:
+        '''
+        得到一个平台的运行实例，需要返回一个协程对象。
+        '''
+        raise NotImplementedError
+    
+    @abc.abstractmethod
+    def meta(self) -> PlatformMetadata:
+        '''
+        得到一个平台的元数据。
+        '''
+        raise NotImplementedError
+    
+    async def send_by_session(self, session: MessageSesion, message_chain: MessageChain) -> Awaitable[Any]:
+        '''
+        通过会话发送消息。该方法旨在让插件能够直接通过**可持久化的会话数据**发送消息，而不需要保存 event 对象。
+        
+        异步方法。
+        '''            
+        await Metric.upload(msg_event_tick = 1, adapter_name = self.meta().name)
+    
+    def commit_event(self, event: AstrMessageEvent):
+        '''
+        提交一个事件到事件队列。
+        '''
+        self._event_queue.put_nowait(event)

astrbot/core/platform/platform_metadata.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+@dataclass
+class PlatformMetadata():
+    name: str # 平台的名称
+    description: str # 平台的描述
+    
+    default_config_tmpl: dict = None # 平台的默认配置模板

astrbot/core/platform/register.py

@@ -0,0 +1,36 @@
+from typing import List, Dict, Type
+from .platform_metadata import PlatformMetadata
+from astrbot.core import logger
+
+platform_registry: List[PlatformMetadata] = []
+'''维护了通过装饰器注册的平台适配器'''
+platform_cls_map: Dict[str, Type] = {}
+'''维护了平台适配器名称和适配器类的映射'''
+
+def register_platform_adapter(adapter_name: str, desc: str, default_config_tmpl: dict = None):
+    '''用于注册平台适配器的带参装饰器。
+    
+    default_config_tmpl 指定了平台适配器的默认配置模板。用户填写好后将会作为 platform_config 传入你的 Platform 类的实现类。 
+    '''
+    def decorator(cls):
+        if adapter_name in platform_cls_map:
+            raise ValueError(f"平台适配器 {adapter_name} 已经注册过了，可能发生了适配器命名冲突。")
+        
+        # 添加必备选项
+        if default_config_tmpl:
+            if 'type' not in default_config_tmpl:
+                default_config_tmpl['type'] = adapter_name
+            if 'enable' not in default_config_tmpl:
+                default_config_tmpl['enable'] = False
+
+        pm = PlatformMetadata(
+            name=adapter_name,
+            description=desc,
+            default_config_tmpl=default_config_tmpl
+        )
+        platform_registry.append(pm)
+        platform_cls_map[adapter_name] = cls
+        logger.debug(f"平台适配器 {adapter_name} 已注册")
+        return cls
+    
+    return decorator

astrbot/core/platform/sources/aiocqhttp/aiocqhttp_message_event.py

@@ -0,0 +1,46 @@
+import os
+import random
+import asyncio
+
+from astrbot.api.event import AstrMessageEvent, MessageChain
+from astrbot.api.message_components import Plain, Image
+from aiocqhttp import CQHttp
+from astrbot.core.utils.io import file_to_base64, download_image_by_url
+
+class AiocqhttpMessageEvent(AstrMessageEvent):
+    def __init__(self, message_str, message_obj, platform_meta, session_id, bot: CQHttp):
+        super().__init__(message_str, message_obj, platform_meta, session_id)
+        self.bot = bot
+    
+    @staticmethod
+    async def _parse_onebot_json(message_chain: MessageChain):
+        '''解析成 OneBot json 格式'''
+        ret = []
+        for segment in message_chain.chain:
+            d = segment.toDict()
+            if isinstance(segment, Plain):
+                d['type'] = 'text'
+            if isinstance(segment, Image):
+                # convert to base64
+                if segment.file and segment.file.startswith("file:///"):
+                    image_base64 = file_to_base64(segment.file[8:])
+                    image_file_path = segment.file[8:]
+                elif segment.file and segment.file.startswith("http"):
+                    image_file_path = await download_image_by_url(segment.file)
+                    image_base64 = file_to_base64(image_file_path)
+                d['data']['file'] = image_base64
+            ret.append(d)
+        return ret
+
+    async def send(self, message: MessageChain):
+        ret = await AiocqhttpMessageEvent._parse_onebot_json(message)
+        if os.environ.get('TEST_MODE', 'off') == 'on':
+            return
+        
+        if message.is_split_: # 分条发送
+            for m in ret:
+                await self.bot.send(self.message_obj.raw_message, [m])
+                await asyncio.sleep(random.uniform(0.75, 2.5))
+        else:
+            await self.bot.send(self.message_obj.raw_message, ret)
+        await super().send(message)

astrbot/core/platform/sources/aiocqhttp/aiocqhttp_platform_adapter.py

@@ -0,0 +1,154 @@
+import os
+import time
+import asyncio
+import logging
+from typing import Awaitable, Any
+from aiocqhttp import CQHttp, Event
+from astrbot.api.platform import Platform, AstrBotMessage, MessageMember, MessageType, PlatformMetadata
+from astrbot.api.event import MessageChain
+from .aiocqhttp_message_event import *  # noqa: F403
+from astrbot.api.message_components import *  # noqa: F403
+from astrbot.api import logger
+from .aiocqhttp_message_event import AiocqhttpMessageEvent
+from astrbot.core.platform.astr_message_event import MessageSesion
+from ...register import register_platform_adapter
+from aiocqhttp.exceptions import ActionFailed
+
+@register_platform_adapter("aiocqhttp", "适用于 OneBot 标准的消息平台适配器，支持反向 WebSockets。")
+class AiocqhttpAdapter(Platform):
+    def __init__(self, platform_config: dict, platform_settings: dict, event_queue: asyncio.Queue) -> None:
+        super().__init__(event_queue)
+        
+        self.config = platform_config
+        self.settings = platform_settings
+        self.unique_session = platform_settings['unique_session']
+        self.host = platform_config['ws_reverse_host']
+        self.port = platform_config['ws_reverse_port']
+        
+        self.metadata = PlatformMetadata(
+            "aiocqhttp",
+            "适用于 OneBot 标准的消息平台适配器，支持反向 WebSockets。",
+        )
+        
+    async def send_by_session(self, session: MessageSesion, message_chain: MessageChain):
+        ret = await AiocqhttpMessageEvent._parse_onebot_json(message_chain)
+        match session.message_type.value:
+            case MessageType.GROUP_MESSAGE.value:
+                if "_" in session.session_id:
+                    # 独立会话
+                    _, group_id = session.session_id.split("_")
+                    await self.bot.send_group_msg(group_id=group_id, message=ret)
+                else:
+                    await self.bot.send_group_msg(group_id=session.session_id, message=ret)
+            case MessageType.FRIEND_MESSAGE.value:
+                await self.bot.send_private_msg(user_id=session.session_id, message=ret)
+        await super().send_by_session(session, message_chain)
+        
+    async def convert_message(self, event: Event) -> AstrBotMessage:
+        abm = AstrBotMessage()
+        abm.self_id = str(event.self_id)
+        abm.tag = "aiocqhttp"
+        
+        abm.sender = MessageMember(str(event.sender['user_id']), event.sender['nickname'])        
+
+        if event['message_type'] == 'group':
+            abm.type = MessageType.GROUP_MESSAGE
+            abm.group_id = str(event.group_id)
+        elif event['message_type'] == 'private':
+            abm.type = MessageType.FRIEND_MESSAGE
+        
+        if self.unique_session:
+            abm.session_id = abm.sender.user_id + "_" + str(event.group_id) # 也保留群组 id
+        else:
+            abm.session_id = str(event.group_id) if abm.type == MessageType.GROUP_MESSAGE else abm.sender.user_id
+        
+        abm.message_id = str(event.message_id)
+        abm.message = []
+        
+        message_str = ""
+        if not isinstance(event.message, list):
+            err = f"aiocqhttp: 无法识别的消息类型: {str(event.message)}，此条消息将被忽略。如果您在使用 go-cqhttp，请将其配置文件中的 message.post-format 更改为 array。"
+            logger.critical(err)
+            try:
+                self.bot.send(event, err)
+            except BaseException as e:
+                logger.error(f"回复消息失败: {e}")
+            return
+        logger.debug(f"aiocqhttp: 收到消息: {event.message}")
+        for m in event.message:
+            t = m['type']
+            a = None
+            if t == 'text':
+                message_str += m['data']['text'].strip()
+            elif t == 'file':
+                try:
+                    # Napcat, LLBot
+                    ret = await self.bot.call_action(action="get_file", file_id=event.message[0]['data']['file_id'])
+                    if not ret.get('file', None):
+                        raise ValueError(f"无法解析文件响应: {ret}")
+                    if not os.path.exists(ret['file']):
+                        raise FileNotFoundError(f"文件不存在: {ret['file']}。如果您使用 Docker 部署了 AstrBot 或者消息协议端(Napcat等),暂时无法获取用户上传的文件。")
+                    
+                    m['data'] = {
+                        "file": ret['file'],
+                        "name": ret['file_name']
+                    }
+                except ActionFailed as e:
+                    logger.error(f"获取文件失败: {e}，此消息段将被忽略。")
+                except BaseException as e:
+                    logger.error(f"获取文件失败: {e}，此消息段将被忽略。")
+                    
+            a = ComponentTypes[t](**m['data'])  # noqa: F405
+            abm.message.append(a)
+        abm.timestamp = int(time.time())
+        abm.message_str = message_str
+        abm.raw_message = event
+        return abm
+    
+    def run(self) -> Awaitable[Any]:
+        if not self.host or not self.port:
+            return
+        self.bot = CQHttp(use_ws_reverse=True, import_name='aiocqhttp', api_timeout_sec=180)
+        @self.bot.on_message('group')
+        async def group(event: Event):
+            abm = await self.convert_message(event)
+            if abm:
+                await self.handle_msg(abm)
+        
+        @self.bot.on_message('private')
+        async def private(event: Event):
+            abm = await self.convert_message(event)
+            if abm:
+                await self.handle_msg(abm)
+                
+        @self.bot.on_websocket_connection
+        def on_websocket_connection(_):
+            logger.info("aiocqhttp 适配器已连接。")
+        
+        bot = self.bot.run_task(host=self.host, port=int(self.port), shutdown_trigger=self.shutdown_trigger_placeholder)
+        
+        for handler in logging.root.handlers[:]:
+            logging.root.removeHandler(handler)
+        logging.getLogger('aiocqhttp').setLevel(logging.ERROR)
+        
+        return bot
+    
+    def meta(self) -> PlatformMetadata:
+        return self.metadata
+    
+    async def shutdown_trigger_placeholder(self):
+        while not self._event_queue.closed:
+            await asyncio.sleep(1)
+        logger.info("aiocqhttp 适配器已关闭。")
+
+    async def handle_msg(self, message: AstrBotMessage):
+        
+        message_event = AiocqhttpMessageEvent(
+            message_str=message.message_str,
+            message_obj=message,
+            platform_meta=self.meta(),
+            session_id=message.session_id,
+            bot=self.bot
+        )
+        
+        self.commit_event(message_event)

astrbot/core/platform/sources/qqofficial/qqofficial_message_event.py

@@ -0,0 +1,83 @@
+import botpy
+import botpy.message
+import botpy.types
+import botpy.types.message
+from astrbot.core.utils.io import file_to_base64, download_image_by_url
+from astrbot.api.event import AstrMessageEvent, MessageChain
+from astrbot.api.platform import AstrBotMessage, PlatformMetadata
+from astrbot.api.message_components import Plain, Image
+from botpy import Client
+from botpy.http import Route
+
+
+class QQOfficialMessageEvent(AstrMessageEvent):
+    def __init__(self, message_str: str, message_obj: AstrBotMessage, platform_meta: PlatformMetadata, session_id: str, bot: Client):
+        super().__init__(message_str, message_obj, platform_meta, session_id)
+        self.bot = bot
+        
+    async def send(self, message: MessageChain):
+        source = self.message_obj.raw_message
+        assert isinstance(source, (botpy.message.Message, botpy.message.GroupMessage, botpy.message.DirectMessage, botpy.message.C2CMessage))
+        
+        plain_text, image_base64, image_path = await QQOfficialMessageEvent._parse_to_qqofficial(message)
+        
+        payload = {
+            'content': plain_text,
+            'msg_id': self.message_obj.message_id,
+        }
+        
+        match type(source):
+            case botpy.message.GroupMessage:
+                if image_base64:
+                    media = await self.upload_group_and_c2c_image(image_base64, 1, group_openid=source.group_openid)
+                    payload['media'] = media
+                    payload['msg_type'] = 7
+                await self.bot.api.post_group_message(group_openid=source.group_openid, **payload)
+            case botpy.message.C2CMessage:
+                if image_base64:
+                    media = await self.upload_group_and_c2c_image(image_base64, 1, openid=source.author.user_openid)
+                    payload['media'] = media
+                    payload['msg_type'] = 7
+                await self.bot.api.post_c2c_message(openid=source.author.user_openid, **payload)
+            case botpy.message.Message:
+                if image_path:
+                    payload['file_image'] = image_path
+                await self.bot.api.post_message(channel_id=source.channel_id, **payload)
+            case botpy.message.DirectMessage:
+                if image_path:
+                    payload['file_image'] = image_path
+                await self.bot.api.post_dms(guild_id=source.guild_id, **payload)
+
+        await super().send(message)
+            
+    async def upload_group_and_c2c_image(self, image_base64: str, file_type: int, **kwargs) -> botpy.types.message.Media:
+        payload = {
+            'file_data': image_base64,
+            'file_type': file_type,
+            "srv_send_msg": False
+        }
+        if 'openid' in kwargs:
+            payload['openid'] = kwargs['openid']
+            route = Route("POST", "/v2/users/{openid}/files", openid=kwargs['openid'])
+            return await self.bot.api._http.request(route, json=payload)
+        elif 'group_openid' in kwargs:
+            payload['group_openid'] = kwargs['group_openid']
+            route = Route("POST", "/v2/groups/{group_openid}/files", group_openid=kwargs['group_openid'])
+            return await self.bot.api._http.request(route, json=payload)
+            
+    @staticmethod
+    async def _parse_to_qqofficial(message: MessageChain):
+        plain_text = ""
+        image_base64 = None  # only one img supported
+        image_file_path = None
+        for i in message.chain:
+            if isinstance(i, Plain):
+                plain_text += i.text
+            elif isinstance(i, Image) and not image_base64:
+                if i.file and i.file.startswith("file:///"):
+                    image_base64 = file_to_base64(i.file[8:]).replace("base64://", "")
+                    image_file_path = i.file[8:]
+                elif i.file and i.file.startswith("http"):
+                    image_file_path = await download_image_by_url(i.file)
+                    image_base64 = file_to_base64(image_file_path).replace("base64://", "")
+        return plain_text, image_base64, image_file_path

astrbot/core/platform/sources/qqofficial/qqofficial_platform_adapter.py

@@ -0,0 +1,179 @@
+import botpy
+import logging
+import time
+import asyncio
+import botpy.message
+import botpy.types
+import botpy.types.message
+import os
+
+from botpy import Client
+from astrbot.api.platform import Platform, AstrBotMessage, MessageMember, MessageType, PlatformMetadata
+from astrbot.api.event import MessageChain
+from typing import Union, List
+from astrbot.api.message_components import Image, Plain, At
+from astrbot.core.platform.astr_message_event import MessageSesion
+from .qqofficial_message_event import QQOfficialMessageEvent
+from ...register import register_platform_adapter
+from astrbot.core.message.components import BaseMessageComponent
+
+# remove logger handler
+for handler in logging.root.handlers[:]:
+    logging.root.removeHandler(handler)
+
+# QQ 机器人官方框架
+class botClient(Client):
+    def set_platform(self, platform: 'QQOfficialPlatformAdapter'):
+        self.platform = platform
+        
+    # 收到群消息
+    async def on_group_at_message_create(self, message: botpy.message.GroupMessage):
+        abm = self.platform._parse_from_qqofficial(message, MessageType.GROUP_MESSAGE)
+        abm.session_id = abm.sender.user_id if self.platform.unique_session else message.group_openid
+        self._commit(abm)
+
+    # 收到频道消息
+    async def on_at_message_create(self, message: botpy.message.Message):
+        abm = self.platform._parse_from_qqofficial(message, MessageType.GROUP_MESSAGE)
+        abm.session_id = abm.sender.user_id if self.platform.unique_session else message.channel_id
+        self._commit(abm)
+        
+    # 收到私聊消息
+    async def on_direct_message_create(self, message: botpy.message.DirectMessage):
+        abm = self.platform._parse_from_qqofficial(message, MessageType.FRIEND_MESSAGE)
+        abm.session_id = abm.sender.user_id
+        self._commit(abm)
+        
+    # 收到 C2C 消息
+    async def on_c2c_message_create(self, message: botpy.message.C2CMessage):
+        abm = self.platform._parse_from_qqofficial(message, MessageType.FRIEND_MESSAGE)
+        abm.session_id = abm.sender.user_id
+        self._commit(abm)
+        
+    def _commit(self, abm: AstrBotMessage):
+        self.platform.commit_event(QQOfficialMessageEvent(
+            abm.message_str,
+            abm,
+            self.platform.meta(),
+            abm.session_id,
+            self.platform.client
+        ))
+@register_platform_adapter("qq_official", "QQ 机器人官方 API 适配器")
+class QQOfficialPlatformAdapter(Platform):
+
+    def __init__(self, platform_config: dict, platform_settings: dict, event_queue: asyncio.Queue) -> None:
+        super().__init__(event_queue)
+        
+        self.config = platform_config
+        
+        self.appid = platform_config['appid']
+        self.secret = platform_config['secret']
+        self.unique_session = platform_settings['unique_session']
+        qq_group = platform_config['enable_group_c2c']
+        guild_dm = platform_config['enable_guild_direct_message']
+
+        if qq_group:
+            self.intents = botpy.Intents(
+                public_messages=True,
+                public_guild_messages=True,
+                direct_message=guild_dm
+            )
+        else:
+            self.intents = botpy.Intents(
+                public_guild_messages=True,
+                direct_message=guild_dm
+            )
+        self.client = botClient(
+            intents=self.intents,
+            bot_log=False,
+            timeout=20,
+        )
+
+        self.client.set_platform(self)
+        
+        self.test_mode = os.environ.get('TEST_MODE', 'off') == 'on'
+        
+    async def send_by_session(self, session: MessageSesion, message_chain: MessageChain):
+        raise NotImplementedError("QQ 机器人官方 API 适配器不支持 send_by_session")
+        
+    def meta(self) -> PlatformMetadata:
+        return PlatformMetadata(
+            "qq_official",
+            "QQ 机器人官方 API 适配器",
+        )
+
+    def _parse_from_qqofficial(self, message: Union[botpy.message.Message, botpy.message.GroupMessage],
+                                  message_type: MessageType):
+        abm = AstrBotMessage()
+        abm.type = message_type
+        abm.timestamp = int(time.time())
+        abm.raw_message = message
+        abm.message_id = message.id
+        abm.tag = "qq_official"
+        msg: List[BaseMessageComponent] = []
+        
+
+        if isinstance(message, botpy.message.GroupMessage) or isinstance(message, botpy.message.C2CMessage):
+            if isinstance(message, botpy.message.GroupMessage):
+                abm.sender = MessageMember(
+                    message.author.member_openid,
+                    ""
+                )
+                abm.group_id = message.group_openid
+            else:
+                abm.sender = MessageMember(
+                    message.author.user_openid,
+                    ""
+                )
+            abm.message_str = message.content.strip()
+            abm.self_id = "unknown_selfid"
+            msg.append(At(qq="qq_official"))
+            msg.append(Plain(abm.message_str))
+            if message.attachments:
+                for i in message.attachments:
+                    if i.content_type.startswith("image"):
+                        url = i.url
+                        if not url.startswith("http"):
+                            url = "https://"+url
+                        img = Image.fromURL(url)
+                        msg.append(img)
+            abm.message = msg
+
+        elif isinstance(message, botpy.message.Message) or isinstance(message, botpy.message.DirectMessage):
+            try:
+                abm.self_id = str(message.mentions[0].id)
+            except BaseException as _:
+                abm.self_id = ""
+
+            plain_content = message.content.replace(
+                "<@!"+str(abm.self_id)+">", "").strip()
+
+            if message.attachments:
+                for i in message.attachments:
+                    if i.content_type.startswith("image"):
+                        url = i.url
+                        if not url.startswith("http"):
+                            url = "https://"+url
+                        img = Image.fromURL(url)
+                        msg.append(img)
+            abm.message = msg
+            abm.message_str = plain_content
+            abm.sender = MessageMember(
+                str(message.author.id),
+                str(message.author.username)
+            )
+            msg.append(At(qq="qq_official"))
+            msg.append(Plain(plain_content))
+            
+            if isinstance(message, botpy.message.Message):
+                abm.group_id = message.channel_id
+        else:
+            raise ValueError(f"Unknown message type: {message_type}")
+        abm.self_id = "qq_official"
+        return abm
+
+    def run(self):
+        return self.client.start(
+            appid=self.appid,
+            secret=self.secret
+        )

astrbot/core/platform/sources/vchat/vchat_message_event.py

@@ -0,0 +1,44 @@
+import random
+import asyncio
+from astrbot.core.utils.io import download_image_by_url
+from astrbot.api import logger
+from astrbot.api.event import AstrMessageEvent, MessageChain
+from astrbot.api.platform import AstrBotMessage, PlatformMetadata
+from astrbot.api.message_components import Plain, Image
+from vchat import Core
+
+class VChatPlatformEvent(AstrMessageEvent):
+    def __init__(self, message_str: str, message_obj: AstrBotMessage, platform_meta: PlatformMetadata, session_id: str, client: Core):
+        super().__init__(message_str, message_obj, platform_meta, session_id)
+        self.client = client
+        
+    @staticmethod
+    async def send_with_client(client: Core, message: MessageChain, user_name: str):
+        plain = ""
+        for comp in message.chain:
+            if isinstance(comp, Plain):
+                if message.is_split_:
+                    await client.send_msg(comp.text, user_name)
+                else:
+                    plain += comp.text
+            elif isinstance(comp, Image):
+                if comp.file and comp.file.startswith("file:///"):
+                    file_path = comp.file.replace("file:///", "")
+                    with open(file_path, "rb") as f:
+                        await client.send_image(user_name, fd=f)
+                elif comp.file and comp.file.startswith("http"):
+                    image_path = await download_image_by_url(comp.file)
+                    with open(image_path, "rb") as f:
+                        await client.send_image(user_name, fd=f)
+            else:
+                logger.error(f"不支持的 vchat(微信适配器) 消息类型: {comp}")
+            await asyncio.sleep(random.uniform(0.5, 1.5)) # 🤓
+        
+        if plain:
+            await client.send_msg(plain, user_name)
+                
+        
+    async def send(self, message: MessageChain):
+        await VChatPlatformEvent.send_with_client(self.client, message, self.message_obj.raw_message.from_.username)
+        await super().send(message)
+        

astrbot/core/platform/sources/vchat/vchat_platform_adapter.py

@@ -0,0 +1,120 @@
+import sys
+import time
+import uuid
+import asyncio
+import os
+
+from astrbot.api.platform import Platform, AstrBotMessage, MessageMember, MessageType, PlatformMetadata
+from astrbot.api.event import MessageChain
+from astrbot.api.message_components import *
+from astrbot.api import logger
+from astrbot.core.platform.astr_message_event import MessageSesion
+from .vchat_message_event import VChatPlatformEvent
+from ...register import register_platform_adapter
+
+from vchat import Core
+from vchat import model
+
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+    from typing_extensions import override
+
+@register_platform_adapter("vchat", "基于 VChat 的 Wechat 适配器")
+class VChatPlatformAdapter(Platform):
+
+    def __init__(self, platform_config: dict, platform_settings: dict, event_queue: asyncio.Queue) -> None:
+        super().__init__(event_queue)
+        self.config = platform_config
+        self.settingss = platform_settings
+        self.test_mode = os.environ.get('TEST_MODE', 'off') == 'on'
+        self.client_self_id = uuid.uuid4().hex[:8]
+    
+    @override
+    async def send_by_session(self, session: MessageSesion, message_chain: MessageChain):
+        from_username = session.session_id.split('$$')[0]
+        await VChatPlatformEvent.send_with_client(self.client, message_chain, from_username)
+        await super().send_by_session(session, message_chain)
+    
+    @override
+    def meta(self) -> PlatformMetadata:
+        return PlatformMetadata(
+            "vchat",
+            "基于 VChat 的 Wechat 适配器",
+        )
+
+    @override
+    def run(self):
+        self.client = Core()
+        @self.client.msg_register(msg_types=model.ContentTypes.TEXT, 
+                                  contact_type=model.ContactTypes.CHATROOM | model.ContactTypes.USER)
+        async def _(msg: model.Message):
+            if isinstance(msg.content, model.UselessContent):
+                return
+            if msg.create_time < self.start_time:
+                logger.debug(f"忽略旧消息: {msg}")
+                return
+            logger.debug(f"收到消息: {msg.todict()}")
+            abmsg = self.convert_message(msg)
+            # await self.handle_msg(abmsg) # 不能直接调用，否则会阻塞
+            asyncio.create_task(self.handle_msg(abmsg))
+        
+        # TODO: 对齐微信服务器时间
+        self.start_time = int(time.time())
+        return self._run()
+    
+
+    async def _run(self):
+        await self.client.init()
+        await self.client.auto_login(hot_reload=True, enable_cmd_qr=True)
+        await self.client.run()
+    
+    def convert_message(self, msg: model.Message) -> AstrBotMessage:
+        # credits: https://github.com/z2z63/astrbot_plugin_vchat/blob/master/main.py#L49
+        assert isinstance(msg.content, model.TextContent)
+        amsg = AstrBotMessage()
+        amsg.message = [Plain(msg.content.content)]
+        amsg.self_id = self.client_self_id
+        if msg.content.is_at_me:
+            amsg.message.insert(0, At(qq=amsg.self_id))
+        
+        sender = msg.chatroom_sender or msg.from_
+        amsg.sender = MessageMember(sender.username, sender.nickname)
+        
+        if msg.content.is_at_me:
+            amsg.message_str = msg.content.content.split("\u2005")[1].strip()
+        else:
+            amsg.message_str = msg.content.content
+        amsg.message_id = msg.message_id
+        if isinstance(msg.from_, model.User):
+            amsg.type = MessageType.FRIEND_MESSAGE
+        elif isinstance(msg.from_, model.Chatroom):
+            amsg.type = MessageType.GROUP_MESSAGE
+            amsg.group_id = msg.from_.username
+        else:
+            logger.error(f"不支持的 Wechat 消息类型: {msg.from_}")
+            
+        amsg.raw_message = msg
+        
+        if self.settingss['unique_session']:
+            session_id = msg.from_.username + "$$" + msg.to.username
+            if msg.chatroom_sender is not None:
+                session_id += '$$' + msg.chatroom_sender.username
+        else:
+            session_id = msg.from_.username
+                
+        amsg.session_id = session_id
+        return amsg
+    
+    async def handle_msg(self, message: AstrBotMessage):
+        message_event = VChatPlatformEvent(
+            message_str=message.message_str,
+            message_obj=message,
+            platform_meta=self.meta(),
+            session_id=message.session_id,
+            client=self.client
+        )
+        
+        logger.info(f"处理消息: {message_event}")
+        
+        self.commit_event(message_event)

astrbot/core/platform/sources/webchat/webchat_adapter.py

@@ -0,0 +1,102 @@
+import time
+import asyncio
+import uuid
+import os
+from typing import Awaitable, Any
+from astrbot.api.platform import Platform, AstrBotMessage, MessageMember, MessageType, PlatformMetadata
+from astrbot.api.event import MessageChain
+from astrbot.api.message_components import Plain, Image  # noqa: F403
+from astrbot.api import logger
+from astrbot.core import web_chat_queue, web_chat_back_queue
+from .webchat_event import WebChatMessageEvent
+from astrbot.core.platform.astr_message_event import MessageSesion
+from ...register import register_platform_adapter
+
+class QueueListener:
+    def __init__(self, queue: asyncio.Queue, callback: callable) -> None:
+        self.queue = queue
+        self.callback = callback
+        
+    async def run(self):
+        while True:
+            data = await self.queue.get()
+            await self.callback(data)
+
+@register_platform_adapter("webchat", "webchat")
+class WebChatAdapter(Platform):
+    def __init__(self, platform_config: dict, platform_settings: dict, event_queue: asyncio.Queue) -> None:
+        super().__init__(event_queue)
+        
+        self.config = platform_config
+        self.settings = platform_settings
+        self.unique_session = platform_settings['unique_session']
+        self.imgs_dir = "data/webchat/imgs"
+
+        self.metadata = PlatformMetadata(
+            "webchat",
+            "webchat",
+        )
+        
+    async def send_by_session(self, session: MessageSesion, message_chain: MessageChain):
+        plain = ""
+        for comp in message_chain.chain:
+            if isinstance(comp, Plain):
+                plain += comp.text
+        web_chat_back_queue.put_nowait(plain)
+        
+        await super().send_by_session(session, message_chain)
+        
+    async def convert_message(self, data: tuple) -> AstrBotMessage:
+        username, cid, payload = data
+        
+        
+        abm = AstrBotMessage()
+        abm.self_id = "webchat"
+        abm.tag = "webchat"
+        abm.sender = MessageMember(username, username)        
+
+        abm.type = MessageType.FRIEND_MESSAGE
+        
+        abm.session_id = f"webchat!{username}!{cid}"
+        
+        abm.message_id = str(uuid.uuid4())
+        abm.message = []
+        
+        if payload['message']:
+            abm.message.append(Plain(payload['message']))
+        if payload['image_url']:
+            if isinstance(payload['image_url'], list):
+                for img in payload['image_url']:
+                    abm.message.append(Image.fromFileSystem(os.path.join(self.imgs_dir, img)))
+            else:
+                abm.message.append(Image.fromFileSystem(os.path.join(self.imgs_dir, payload['image_url'])))
+            
+        logger.debug(f"WebChatAdapter: {abm.message}")
+        
+        message_str = payload['message']
+        abm.timestamp = int(time.time())
+        abm.message_str = message_str
+        abm.raw_message = data
+        return abm
+    
+    def run(self) -> Awaitable[Any]:
+        async def callback(data: tuple):
+            abm = await self.convert_message(data)
+            await self.handle_msg(abm)
+            
+        bot = QueueListener(web_chat_queue, callback)
+        return bot.run()
+    
+    def meta(self) -> PlatformMetadata:
+        return self.metadata
+
+    async def handle_msg(self, message: AstrBotMessage):
+        
+        message_event = WebChatMessageEvent(
+            message_str=message.message_str,
+            message_obj=message,
+            platform_meta=self.meta(),
+            session_id=message.session_id
+        )
+        
+        self.commit_event(message_event)

astrbot/core/platform/sources/webchat/webchat_event.py

@@ -0,0 +1,31 @@
+import os
+import uuid
+from astrbot.api.event import AstrMessageEvent, MessageChain
+from astrbot.api.message_components import Plain, Image
+from astrbot.core.utils.io import file_to_base64, download_image_by_url
+from astrbot.core import web_chat_back_queue
+
+class WebChatMessageEvent(AstrMessageEvent):
+    def __init__(self, message_str, message_obj, platform_meta, session_id):
+        super().__init__(message_str, message_obj, platform_meta, session_id)
+        self.imgs_dir = "data/webchat/imgs"
+        os.makedirs(self.imgs_dir, exist_ok=True)        
+
+    async def send(self, message: MessageChain):
+        for comp in message.chain:
+            if isinstance(comp, Plain):
+                await web_chat_back_queue.put(comp.text)
+            elif isinstance(comp, Image):
+                # save image to local
+                filename = str(uuid.uuid4()) + ".jpg"
+                path = os.path.join(self.imgs_dir, filename)
+                if comp.file and comp.file.startswith("file:///"):
+                    ph = comp.file[8:]
+                    with open(path, "wb") as f:
+                        with open(ph, "rb") as f2:
+                            f.write(f2.read())
+                elif comp.file and comp.file.startswith("http"):
+                    await download_image_by_url(comp.file, path=path)
+                await web_chat_back_queue.put(f"[IMAGE]{filename}")
+        await web_chat_back_queue.put(None)
+        await super().send(message)

astrbot/core/provider/__init__.py

@@ -0,0 +1,9 @@
+from .provider import Provider, Personality
+
+from .entites import ProviderMetaData
+
+__all__ = [
+    "Provider",
+    "Personality",
+    "ProviderMetaData",
+]

astrbot/core/provider/entites.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass, field
+from typing import List, Dict
+from .func_tool_manager import FuncCall
+
+
+@dataclass
+class ProviderMetaData():
+    type: str # 提供商适配器名称，如 openai, ollama
+    desc: str = "" # 提供商适配器描述.
+    
+
+@dataclass
+class ProviderRequest():
+    prompt: str
+    '''提示词'''
+    session_id: str = ""
+    '''会话 ID'''
+    image_urls: List[str] = None
+    '''图片 URL 列表'''
+    func_tool: FuncCall = None
+    '''工具'''
+    contexts: List = None
+    '''上下文。格式与 openai 的上下文格式一致：
+    参考 https://platform.openai.com/docs/api-reference/chat/create#chat-create-messages
+    '''
+    
+    system_prompt: str = ""
+    '''系统提示词'''
+    
+    
+@dataclass
+class LLMResponse:
+    role: str
+    '''角色'''
+    completion_text: str = ""
+    '''LLM 返回的文本'''
+    tools_call_args: List[Dict[str, any]] = field(default_factory=list)
+    '''工具调用参数'''
+    tools_call_name: List[str] = field(default_factory=list)
+    '''工具调用名称'''

astrbot/core/provider/func_tool_manager.py

@@ -0,0 +1,198 @@
+import json
+import textwrap
+from typing import Dict, List, Awaitable
+from dataclasses import dataclass
+
+
+@dataclass
+class FuncTool:
+    """
+    用于描述一个函数调用工具。
+    """
+
+    name: str
+    parameters: Dict
+    description: str
+    handler: Awaitable
+    handler_module_path: str = None # 必须要保留这个，handler 在初始化会被 functools.partial 包装，导致 handler 的 __module__ 为 functools
+
+    active: bool = True
+    '''是否激活'''
+
+SUPPORTED_TYPES = [
+    "string",
+    "number",
+    "object",
+    "array",
+    "boolean",
+]  # json schema 支持的数据类型
+
+
+class FuncCall:
+    def __init__(self) -> None:
+        self.func_list: List[FuncTool] = []
+
+    def empty(self) -> bool:
+        return len(self.func_list) == 0
+
+    def add_func(
+        self,
+        name: str,
+        func_args: list,
+        desc: str,
+        handler: Awaitable,
+    ) -> None:
+        """
+        为函数调用（function-calling / tools-use）添加工具。
+
+        @param name: 函数名
+        @param func_args: 函数参数列表，格式为 [{"type": "string", "name": "arg_name", "description": "arg_description"}, ...]
+        @param desc: 函数描述
+        @param func_obj: 处理函数
+        """
+        params = {
+            "type": "object",  # hard-coded here
+            "properties": {},
+        }
+        for param in func_args:
+            params["properties"][param["name"]] = {
+                "type": param["type"],
+                "description": param["description"],
+            }
+        _func = FuncTool(
+            name=name,
+            parameters=params,
+            description=desc,
+            handler=handler,
+        )
+        self.func_list.append(_func)
+
+    def remove_func(self, name: str) -> None:
+        """
+        删除一个函数调用工具。
+        """
+        for i, f in enumerate(self.func_list):
+            if f["name"] == name:
+                self.func_list.pop(i)
+                break
+
+    def get_func(self, name) -> FuncTool:
+        for f in self.func_list:
+            if f.name == name:
+                return f
+        return None
+
+    def get_func_desc_openai_style(self) -> list:
+        """
+        获得 OpenAI API 风格的**已经激活**的工具描述
+        """
+        _l = []
+        for f in self.func_list:
+            if not f.active:
+                continue
+            _l.append(
+                {
+                    "type": "function",
+                    "function": {
+                        "name": f.name,
+                        "parameters": f.parameters,
+                        "description": f.description,
+                    },
+                }
+            )
+        return _l
+    
+    def get_func_desc_google_genai_style(self) -> Dict:
+        declarations = {}
+        tools = []
+        for f in self.func_list:
+            if not f.active:
+                continue
+            tools.append(
+                {
+                    "name": f.name,
+                    "parameters": f.parameters,
+                    "description": f.description,
+                }
+            )
+        declarations["function_declarations"] = tools
+        return declarations
+        
+
+    async def func_call(self, question: str, session_id: str, provider) -> tuple:
+        _l = []
+        for f in self.func_list:
+            if not f.active:
+                continue
+            _l.append(
+                {
+                    "name": f["name"],
+                    "parameters": f["parameters"],
+                    "description": f["description"],
+                }
+            )
+        func_definition = json.dumps(_l, ensure_ascii=False)
+
+        prompt = textwrap.dedent(f"""
+            ROLE:
+            你是一个 Function calling AI Agent, 你的任务是将用户的提问转化为函数调用。
+
+            TOOLS:
+            可用的函数列表:
+
+            {func_definition}
+
+            LIMIT:
+            1. 你返回的内容应当能够被 Python 的 json 模块解析的 Json 格式字符串。
+            2. 你的 Json 返回的格式如下：`[{{"name": "<func_name>", "args": <arg_dict>}}, ...]`。参数根据上面提供的函数列表中的参数来填写。
+            3. 允许必要时返回多个函数调用，但需保证这些函数调用的顺序正确。
+            4. 如果用户的提问中不需要用到给定的函数，请直接返回 `{{"res": False}}`。
+
+            EXAMPLE:
+            1. `用户提问`：请问一下天气怎么样？ `函数调用`：[{{"name": "get_weather", "args": {{"city": "北京"}}}}]
+
+            用户的提问是：{question}
+        """)
+
+        _c = 0
+        while _c < 3:
+            try:
+                res = await provider.text_chat(prompt, session_id)
+                if res.find("```") != -1:
+                    res = res[res.find("```json") + 7 : res.rfind("```")]
+                res = json.loads(res)
+                break
+            except Exception as e:
+                _c += 1
+                if _c == 3:
+                    raise e
+                if "The message you submitted was too long" in str(e):
+                    raise e
+
+        if "res" in res and not res["res"]:
+            return "", False
+
+        tool_call_result = []
+        for tool in res:
+            # 说明有函数调用
+            func_name = tool["name"]
+            args = tool["args"]
+            # 调用函数
+            tool_callable = None
+            for func in self.func_list:
+                if func.name == func_name:
+                    tool_callable = func.star_handler_metadata.handler
+                    break
+            if not tool_callable:
+                raise Exception(f"Request function {func_name} not found.")
+            ret = await tool_callable(**args)
+            if ret:
+                tool_call_result.append(str(ret))
+        return tool_call_result, True
+
+    
+    def __str__(self):
+        return str(self.func_list)
+    
+    def __repr__(self):
+        return str(self.func_list)

astrbot/core/provider/manager.py

@@ -0,0 +1,80 @@
+import traceback
+from astrbot.core.config.astrbot_config import AstrBotConfig
+from .provider import Provider
+from typing import List
+from astrbot.core.db import BaseDatabase
+from collections import defaultdict
+from .register import provider_cls_map, llm_tools
+from astrbot.core import logger, sp
+
+class ProviderManager():
+    def __init__(self, config: AstrBotConfig, db_helper: BaseDatabase):
+        self.providers_config: List = config['provider']
+        self.provider_settings: dict = config['provider_settings']
+        self.provider_insts: List[Provider] = []
+        '''加载的 Provider 的实例'''
+        self.llm_tools = llm_tools
+        self.curr_provider_inst: Provider = None
+        self.loaded_ids = defaultdict(bool)
+        self.db_helper = db_helper
+        
+        self.curr_kdb_name = ""
+        kdb_cfg = config.get("knowledge_db", {})
+        if kdb_cfg and len(kdb_cfg):
+            self.curr_kdb_name = list(kdb_cfg.keys())[0]
+        
+        for provider_cfg in self.providers_config:
+            if not provider_cfg['enable']:
+                continue
+            
+            if provider_cfg['id'] in self.loaded_ids:
+                raise ValueError(f"Provider ID 重复：{provider_cfg['id']}。")
+            self.loaded_ids[provider_cfg['id']] = True
+            
+            match provider_cfg['type']:
+                case "openai_chat_completion":
+                    from .sources.openai_source import ProviderOpenAIOfficial # noqa: F401
+                case "zhipu_chat_completion":
+                    from .sources.zhipu_source import ProviderZhipu # noqa: F401
+                case "llm_tuner":
+                    logger.info("加载 LLM Tuner 工具 ...")
+                    from .sources.llmtuner_source import LLMTunerModelLoader # noqa: F401
+                case "dify":
+                    from .sources.dify_source import ProviderDify # noqa: F401
+                case "googlegenai_chat_completion":
+                    from .sources.gemini_source import ProviderGoogleGenAI # noqa: F401
+                    
+            
+    async def initialize(self):
+        for provider_config in self.providers_config:
+            if not provider_config['enable']:
+                continue
+            if provider_config['type'] not in provider_cls_map:
+                logger.error(f"未找到适用于 {provider_config['type']}({provider_config['id']}) 的提供商适配器，请检查是否已经安装或者名称填写错误。已跳过。")
+                continue
+            selected_provider_id = sp.get("curr_provider")
+            cls_type = provider_cls_map[provider_config['type']]
+            logger.info(f"尝试实例化 {provider_config['type']}({provider_config['id']}) 提供商适配器 ...")
+            try:
+                inst = cls_type(provider_config, self.provider_settings, self.db_helper, self.provider_settings.get('persistant_history', True))
+                self.provider_insts.append(inst)
+                if selected_provider_id == provider_config['id']:
+                    self.curr_provider_inst = inst
+                    logger.info(f"已选择 {provider_config['type']}({provider_config['id']}) 作为当前提供商适配器。")
+            except Exception as e:
+                traceback.print_exc()
+                logger.error(f"实例化 {provider_config['type']}({provider_config['id']}) 提供商适配器失败：{e}")
+        
+        if len(self.provider_insts) > 0 and not self.curr_provider_inst:
+            self.curr_provider_inst = self.provider_insts[0]
+            
+        if not self.curr_provider_inst:
+            logger.warning("未启用任何提供商适配器。")
+
+    def get_insts(self):
+        return self.provider_insts
+    
+    async def terminate(self):
+        for provider_inst in self.provider_insts:
+            if hasattr(provider_inst, "terminate"):
+                await provider_inst.terminate()

astrbot/core/provider/provider.py

@@ -0,0 +1,134 @@
+import abc
+import json
+from collections import defaultdict
+from typing import List
+from astrbot.core.db import BaseDatabase
+from astrbot.core import logger
+from typing import TypedDict
+from astrbot.core.provider.func_tool_manager import FuncCall
+from astrbot.core.provider.entites import LLMResponse
+from dataclasses import dataclass
+class Personality(TypedDict):
+    prompt: str = ""
+    name: str = ""
+    
+@dataclass
+class ProviderMeta():
+    id: str
+    model: str
+    type: str
+
+
+class Provider(abc.ABC):
+    def __init__(
+        self, 
+        provider_config: dict,
+        provider_settings: dict, 
+        persistant_history: bool = True,
+        db_helper: BaseDatabase = None
+    ) -> None:
+        self.model_name = ""
+        '''当前使用的模型名称'''
+        
+        self.session_memory = defaultdict(list)
+        '''维护了 session_id 的上下文，**不包含 system 指令**。'''
+        
+        self.provider_config = provider_config
+        
+        self.provider_settings = provider_settings
+        
+        self.curr_personality = Personality(prompt=provider_settings['default_personality'])
+        '''维护了当前的使用的 persona，即人格。'''
+        
+        self.db_helper = db_helper
+        '''用于持久化的数据库操作对象。'''
+
+        if persistant_history:
+            # 读取历史记录
+            try:
+                for history in db_helper.get_llm_history(provider_type=provider_config['type']):
+                    self.session_memory[history.session_id] = json.loads(history.content)
+            except BaseException as e:
+                logger.warning(f"读取 LLM 对话历史记录 失败：{e}。仍可正常使用。")
+
+    def set_model(self, model_name: str):
+        '''设置当前使用的模型名称'''
+        self.model_name = model_name
+    
+    def get_model(self) -> str:
+        '''获得当前使用的模型名称'''
+        return self.model_name
+    
+    @abc.abstractmethod
+    def get_current_key(self) -> str:
+        raise NotImplementedError()
+    
+    def get_keys(self) -> List[str]:
+        '''获得提供商 Key'''
+        return self.provider_config.get("key", [])
+    
+    @abc.abstractmethod
+    def set_key(self, key: str):
+        raise NotImplementedError()
+    
+    @abc.abstractmethod
+    def get_models(self) -> List[str]:
+        '''获得支持的模型列表'''
+        raise NotImplementedError()
+    
+    @abc.abstractmethod
+    async def get_human_readable_context(self, session_id: str, page: int, page_size: int):
+        '''获取人类可读的上下文
+        
+        page 从 1 开始
+
+        Example:
+            
+            ["User: 你好", "Assistant: 你好！"]
+            
+        Return:
+            contexts: List[str]: 上下文列表
+            total_pages: int: 总页数
+        '''
+        raise NotImplementedError()
+    
+    @abc.abstractmethod
+    async def text_chat(self,
+                        prompt: str,
+                        session_id: str=None,
+                        image_urls: List[str]=None,
+                        func_tool: FuncCall=None,
+                        contexts: List=None,
+                        system_prompt: str=None,
+                        **kwargs) -> LLMResponse:
+        '''获得 LLM 的文本对话结果。会使用当前的模型进行对话。
+        
+        Args:
+            prompt: 提示词
+            session_id: 会话 ID
+            image_urls: 图片 URL 列表
+            tools: Function-calling 工具
+            contexts: 上下文
+            kwargs: 其他参数
+            
+        Notes:
+            - 如果传入了 contexts，将会提前加上上下文。否则使用 session_memory 中的上下文。
+            - 可以选择性地传入 session_id，如果传入了 session_id，将会使用 session_id 对应的上下文进行对话，
+            并且也会记录相应的对话上下文，实现多轮对话。如果不传入则不会记录上下文。
+            - 如果传入了 image_urls，将会在对话时附上图片。如果模型不支持图片输入，将会抛出错误。
+            - 如果传入了 tools，将会使用 tools 进行 Function-calling。如果模型不支持 Function-calling，将会抛出错误。
+        '''
+        raise NotImplementedError()
+    
+    @abc.abstractmethod
+    async def forget(self, session_id: str) -> bool:
+        '''重置某一个 session_id 的上下文'''
+        raise NotImplementedError()
+
+    def meta(self) -> ProviderMeta:
+        '''获取 Provider 的元数据'''
+        return ProviderMeta(
+            id=self.provider_config['id'],
+            model=self.get_model(),
+            type=self.provider_config['type']
+        )

astrbot/core/provider/register.py

@@ -0,0 +1,28 @@
+from typing import List, Dict, Type
+from .entites import ProviderMetaData
+from astrbot.core import logger
+from .func_tool_manager import FuncCall
+
+provider_registry: List[ProviderMetaData] = []
+'''维护了通过装饰器注册的 Provider'''
+provider_cls_map: Dict[str, Type] = {}
+'''维护了 Provider 类型名称和 Provider 类的映射'''
+
+llm_tools = FuncCall()
+
+def register_provider_adapter(provider_type_name: str, desc: str):
+    '''用于注册平台适配器的带参装饰器'''
+    def decorator(cls):
+        if provider_type_name in provider_cls_map:
+            raise ValueError(f"检测到大模型提供商适配器 {provider_type_name} 已经注册，可能发生了大模型提供商适配器类型命名冲突。")
+
+        pm = ProviderMetaData(
+            type=provider_type_name,
+            desc=desc,
+        )
+        provider_registry.append(pm)
+        provider_cls_map[provider_type_name] = cls
+        logger.debug(f"Provider {provider_type_name} 已注册")
+        return cls
+    
+    return decorator

astrbot/core/provider/sources/dify_source.py

@@ -0,0 +1,137 @@
+from typing import List
+from .. import Provider
+from ..entites import LLMResponse
+from ..func_tool_manager import FuncCall
+from astrbot.core.db import BaseDatabase
+from ..register import register_provider_adapter
+from astrbot.core.utils.dify_api_client import DifyAPIClient
+from astrbot.core.utils.io import download_image_by_url
+from astrbot.core import logger, sp
+
+@register_provider_adapter("dify", "Dify APP 适配器。")
+class ProviderDify(Provider):
+    def __init__(
+        self,
+        provider_config: dict,
+        provider_settings: dict,
+        db_helper: BaseDatabase,
+        persistant_history=False,
+    ) -> None:
+        super().__init__(
+            provider_config, provider_settings, persistant_history, db_helper
+        )
+        self.api_key = provider_config.get("dify_api_key", "")
+        if not self.api_key:
+            raise Exception("Dify API Key 不能为空。")
+        api_base = provider_config.get("dify_api_base", "https://api.dify.ai/v1")
+        self.api_client = DifyAPIClient(self.api_key, api_base)
+        self.api_type = provider_config.get("dify_api_type", "")
+        if not self.api_type:
+            raise Exception("Dify API 类型不能为空。")
+        self.model_name = "dify"
+        self.workflow_output_key = provider_config.get("dify_workflow_output_key", "astrbot_wf_output")
+        
+        self.conversation_ids = {}
+
+
+    async def text_chat(
+        self,
+        prompt: str,
+        session_id: str = None,
+        image_urls: List[str] = None,
+        func_tool: FuncCall = None,
+        contexts: List = None,
+        system_prompt: str = None,
+        **kwargs,
+    ) -> LLMResponse:
+        result = ""
+        conversation_id = self.conversation_ids.get(session_id, "")
+        
+        files_payload = []
+        for image_url in image_urls:
+            if image_url.startswith("http"):
+                image_path = await download_image_by_url(image_url)
+                file_response = await self.api_client.file_upload(image_path, user=session_id)
+                if 'id' not in file_response:
+                    logger.warning(f"上传图片后得到未知的 Dify 响应：{file_response}，图片将忽略。")
+                    continue
+                files_payload.append({
+                    "type": "image",
+                    "transfer_method": "local_file",
+                    "upload_file_id": file_response['id'],
+                })
+            else:
+                # TODO: 处理更多情况
+                logger.warning(f"未知的图片链接：{image_url}，图片将忽略。")
+            
+        logger.debug(files_payload)
+        
+        # 获得会话变量
+        session_vars = sp.get("session_variables", {})
+        session_var = session_vars.get(session_id, {})
+        
+        match self.api_type:
+            case "chat" | "agent":
+                async for chunk in self.api_client.chat_messages(
+                    inputs={
+                        **session_var
+                    },
+                    query=prompt,
+                    user=session_id,
+                    conversation_id=conversation_id,
+                    files=files_payload
+                ):
+                    logger.debug(f"dify resp chunk: {chunk}")
+                    if chunk['event'] == "message" or \
+                        chunk['event'] == "agent_message":
+                        result += chunk['answer']
+                        if not conversation_id:
+                            self.conversation_ids[session_id] = chunk['conversation_id']
+                            conversation_id = chunk['conversation_id']
+            
+            case "workflow":
+                async for chunk in self.api_client.workflow_run(
+                    inputs={
+                        "astrbot_text_query": prompt,
+                        "astrbot_session_id": session_id,
+                        **session_var
+                    },
+                    user=session_id,
+                    files=files_payload
+                ):
+                    match chunk['event']:
+                        case "workflow_started":
+                            logger.info(f"Dify 工作流(ID: {chunk['workflow_run_id']})开始运行。")
+                        case "node_finished":
+                            logger.debug(f"Dify 工作流节点(ID: {chunk['data']['node_id']} Title: {chunk['data'].get('title', '')})运行结束。")
+                        case "workflow_finished":
+                            logger.info(f"Dify 工作流(ID: {chunk['workflow_run_id']})运行结束。")
+                            if chunk['data']['error']:
+                                logger.error(f"Dify 工作流出现错误：{chunk['data']['error']}")
+                                raise Exception(f"Dify 工作流出现错误：{chunk['data']['error']}")
+                            if self.workflow_output_key not in chunk['data']['outputs']:
+                                raise Exception(f"Dify 工作流的输出不包含指定的键名：{self.workflow_output_key}")
+                            result = chunk['data']['outputs'][self.workflow_output_key]
+            case _:
+                raise Exception(f"未知的 Dify API 类型：{self.api_type}")
+
+        return LLMResponse(role="assistant", completion_text=result)
+
+    async def forget(self, session_id):
+        self.conversation_ids.pop(session_id, None)
+        return True
+
+    async def get_current_key(self):
+        return self.api_key
+
+    async def set_key(self, key):
+        raise Exception("Dify 适配器不支持设置 API Key。")
+
+    async def get_models(self):
+        return [self.get_model()]
+
+    async def get_human_readable_context(self, session_id, page, page_size):
+        raise Exception("暂不支持获得 Dify 的历史消息记录。")
+
+    async def terminate(self):
+        await self.api_client.close()

astrbot/core/provider/sources/gemini_source.py

@@ -0,0 +1,287 @@
+import traceback
+import base64
+import json
+import aiohttp
+from astrbot.core.utils.io import download_image_by_url
+from astrbot.core.db import BaseDatabase
+from astrbot.api.provider import Provider
+from astrbot import logger
+from astrbot.core.provider.func_tool_manager import FuncCall
+from typing import List
+from ..register import register_provider_adapter
+from astrbot.core.provider.entites import LLMResponse
+
+class SimpleGoogleGenAIClient():
+    def __init__(self, api_key: str, api_base: str):
+        self.api_key = api_key
+        if api_base.endswith("/"):
+            self.api_base = api_base[:-1]
+        else:
+            self.api_base = api_base
+        self.client = aiohttp.ClientSession()
+        
+    async def models_list(self) -> List[str]:
+        request_url = f"{self.api_base}/v1beta/models?key={self.api_key}"
+        async with self.client.get(request_url, timeout=10) as resp:
+            response = await resp.json()
+            
+            models = []
+            for model in response["models"]:
+                if 'generateContent' in model["supportedGenerationMethods"]:
+                    models.append(model["name"].replace("models/", ""))
+            return models
+
+    async def generate_content(
+        self, 
+        contents: List[dict], 
+        model: str="gemini-1.5-flash", 
+        system_instruction: str="",
+        tools: dict=None
+    ):
+        payload = {}
+        if system_instruction:
+            payload["system_instruction"] = {
+                "parts": {"text": system_instruction}
+            }
+        if tools:
+            payload["tools"] = [tools]
+        payload["contents"] = contents
+        logger.debug(f"payload: {payload}")
+        request_url = f"{self.api_base}/v1beta/models/{model}:generateContent?key={self.api_key}"
+        async with self.client.post(request_url, json=payload, timeout=10) as resp:
+            response = await resp.json()
+            return response
+
+
+@register_provider_adapter("googlegenai_chat_completion", "Google Gemini Chat Completion 提供商适配器")
+class ProviderGoogleGenAI(Provider):
+    def __init__(
+        self, 
+        provider_config: dict, 
+        provider_settings: dict,
+        db_helper: BaseDatabase, 
+        persistant_history = True
+    ) -> None:
+        super().__init__(provider_config, provider_settings, persistant_history, db_helper)
+        self.chosen_api_key = None
+        self.api_keys: List = provider_config.get("key", [])
+        self.chosen_api_key = self.api_keys[0] if len(self.api_keys) > 0 else None
+        
+        self.client = SimpleGoogleGenAIClient(
+            api_key=self.chosen_api_key,
+            api_base=provider_config.get("api_base", None)
+        )
+        self.set_model(provider_config['model_config']['model'])
+    
+    async def get_human_readable_context(self, session_id, page, page_size):
+        if session_id not in self.session_memory:
+            raise Exception("会话 ID 不存在")
+        contexts = []
+        temp_contexts = []
+        for record in self.session_memory[session_id]:
+            if record['role'] == "user":
+                temp_contexts.append(f"User: {record['content']}")
+            elif record['role'] == "assistant":
+                temp_contexts.append(f"Assistant: {record['content']}")
+                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
+
+    async def get_models(self):
+        return await self.client.models_list()
+    
+    async def pop_record(self, session_id: str, pop_system_prompt: bool = False):
+        '''
+        弹出第一条记录
+        '''
+        if session_id not in self.session_memory:
+            raise Exception("会话 ID 不存在")
+
+        if len(self.session_memory[session_id]) == 0:
+            return None
+
+        for i in range(len(self.session_memory[session_id])):
+            # 检查是否是 system prompt
+            if not pop_system_prompt and self.session_memory[session_id][i]['user']['role'] == "system":
+                # 如果只有一个 system prompt，才不删掉
+                f = False
+                for j in range(i+1, len(self.session_memory[session_id])):
+                    if self.session_memory[session_id][j]['user']['role'] == "system":
+                        f = True
+                        break
+                if not f:
+                    continue
+            record = self.session_memory[session_id].pop(i)
+            break
+
+        return record
+    
+    async def _query(self, payloads: dict, tools: FuncCall) -> LLMResponse:
+        tool = None
+        if tools:
+            tool = tools.get_func_desc_google_genai_style()
+        
+        system_instruction = ""
+        for message in payloads["messages"]:
+            if message["role"] == "system":
+                system_instruction = message["content"]
+                break
+        
+        google_genai_conversation = []
+        for message in payloads["messages"]:
+            if message["role"] == "user":
+                if isinstance(message["content"], str):
+                    google_genai_conversation.append({
+                        "role": "user",
+                        "parts": [{"text": message["content"]}]
+                    })
+                elif isinstance(message["content"], list):
+                    # images
+                    parts = []
+                    for part in message["content"]:
+                        if part["type"] == "text":
+                            parts.append({"text": part["text"]})
+                        elif part["type"] == "image_url":
+                            parts.append({"inline_data": {
+                                "mime_type": "image/jpeg",
+                                "data": part["image_url"]["url"].replace("data:image/jpeg;base64,", "") # base64
+                            }})
+                    google_genai_conversation.append({
+                        "role": "user",
+                        "parts": parts
+                    })
+                        
+            elif message["role"] == "assistant":
+                google_genai_conversation.append({
+                    "role": "model",
+                    "parts": [{"text": message["content"]}]
+                })
+                
+        
+        logger.debug(f"google_genai_conversation: {google_genai_conversation}")
+        
+        result = await self.client.generate_content(
+            contents=google_genai_conversation,
+            model=self.get_model(),
+            system_instruction=system_instruction,
+            tools=tool
+        )
+        logger.debug(f"result: {result}")
+        
+        candidates = result["candidates"][0]['content']['parts']
+        llm_response = LLMResponse("assistant")
+        for candidate in candidates:
+            if 'text' in candidate:
+                llm_response.completion_text += candidate['text']
+            elif 'functionCall' in candidate:
+                llm_response.role = "tool"
+                llm_response.tools_call_args.append(candidate['functionCall']['args'])
+                llm_response.tools_call_name.append(candidate['functionCall']['name'])
+            
+        return llm_response
+
+
+    async def text_chat(
+        self,
+        prompt: str,
+        session_id: str,
+        image_urls: List[str]=None,
+        func_tool: FuncCall=None,
+        contexts=None,
+        system_prompt=None,
+        **kwargs
+    ) -> LLMResponse: 
+        new_record = await self.assemble_context(prompt, image_urls)
+        context_query = []
+        if not contexts:
+            context_query = [*self.session_memory[session_id], new_record]
+        else:
+            context_query = [*contexts, new_record]
+        if system_prompt:
+            context_query.insert(0, {"role": "system", "content": system_prompt})
+
+        payloads = {
+            "messages": context_query,
+            **self.provider_config.get("model_config", {})
+        }
+
+        try:
+            llm_response = await self._query(payloads, func_tool)
+        except Exception as e:
+            if "maximum context length" in str(e):
+                logger.warning(f"请求失败：{e}。上下文长度超过限制。尝试弹出最早的记录然后重试。")
+                self.pop_record(session_id)
+            logger.warning(traceback.format_exc())
+            
+        await self.save_history(contexts, new_record, session_id, llm_response)
+
+        return llm_response
+    
+    async def save_history(self, contexts: List, new_record: dict, session_id: str, llm_response: LLMResponse):
+        if llm_response.role == "assistant" and session_id:
+            # 文本回复
+            if not contexts:
+                # 添加用户 record
+                self.session_memory[session_id].append(new_record)
+                # 添加 assistant record
+                self.session_memory[session_id].append({
+                    "role": "assistant",
+                    "content": llm_response.completion_text
+                })
+            else:
+                self.session_memory[session_id] = [*contexts, new_record, {
+                    "role": "assistant",
+                    "content": llm_response.completion_text
+                }]
+            self.db_helper.update_llm_history(session_id, json.dumps(self.session_memory[session_id]), self.provider_config['type'])
+        
+    async def forget(self, session_id: str) -> bool:
+        self.session_memory[session_id] = []
+        return True
+
+    def get_current_key(self) -> str:
+        return self.client.api_key
+
+    def get_keys(self) -> List[str]:
+        return self.api_keys
+    
+    def set_key(self, key):
+        self.client.api_key = key
+        
+    async def assemble_context(self, text: str, image_urls: List[str] = None):
+        '''
+        组装上下文。
+        '''
+        if image_urls:
+            user_content = {"role": "user","content": [{"type": "text", "text": text}]}
+            for image_url in image_urls:
+                if image_url.startswith("http"):
+                    image_path = await download_image_by_url(image_url)
+                    image_data = await self.encode_image_bs64(image_path)
+                else:
+                    image_data = await self.encode_image_bs64(image_url)
+                user_content["content"].append({"type": "image_url", "image_url": {"url": image_data}})
+            return user_content
+        else:
+            return {"role": "user","content": text}
+
+    async def encode_image_bs64(self, image_url: str) -> str:
+        '''
+        将图片转换为 base64
+        '''
+        if image_url.startswith("base64://"):
+            return image_url.replace("base64://", "data:image/jpeg;base64,")
+        with open(image_url, "rb") as f:
+            image_bs64 = base64.b64encode(f.read()).decode('utf-8')
+            return "data:image/jpeg;base64," + image_bs64
+        return ''

astrbot/core/provider/sources/llmtuner_source.py

@@ -0,0 +1,142 @@
+import json
+import os
+from llmtuner.chat import ChatModel
+from typing import List
+from .. import Provider
+from ..entites import LLMResponse
+from ..func_tool_manager import FuncCall
+from astrbot.core.db import BaseDatabase
+from ..register import register_provider_adapter
+
+
+@register_provider_adapter(
+    "llm_tuner", "LLMTuner 适配器, 用于装载使用 LlamaFactory 微调后的模型"
+)
+class LLMTunerModelLoader(Provider):
+    def __init__(
+        self,
+        provider_config: dict,
+        provider_settings: dict,
+        db_helper: BaseDatabase,
+        persistant_history=True,
+    ) -> None:
+        super().__init__(
+            provider_config, provider_settings, persistant_history, db_helper
+        )
+        if not os.path.exists(provider_config["base_model_path"]) or not os.path.exists(
+            provider_config["adapter_model_path"]
+        ):
+            raise FileNotFoundError("模型文件路径不存在。")
+        self.base_model_path = provider_config["base_model_path"]
+        self.adapter_model_path = provider_config["adapter_model_path"]
+        self.model = ChatModel(
+            {
+                "model_name_or_path": self.base_model_path,
+                "adapter_name_or_path": self.adapter_model_path,
+                "template": provider_config["llmtuner_template"],
+                "finetuning_type": provider_config["finetuning_type"],
+                "quantization_bit": provider_config["quantization_bit"],
+            }
+        )
+        self.set_model(
+            os.path.basename(self.base_model_path)
+            + "_"
+            + os.path.basename(self.adapter_model_path)
+        )
+
+    async def assemble_context(self, text: str, image_urls: List[str] = None):
+        """
+        组装上下文。
+        """
+        return {"role": "user", "content": text}
+
+    async def text_chat(
+        self,
+        prompt: str,
+        session_id: str = None,
+        image_urls: List[str] = None,
+        func_tool: FuncCall = None,
+        contexts: List = None,
+        system_prompt: str = None,
+        **kwargs,
+    ) -> LLMResponse:
+        system_prompt = ""
+        if not contexts:
+            query_context = [
+                *self.session_memory[session_id],
+                {"role": "user", "content": prompt},
+            ]
+            system_prompt = self.curr_personality["prompt"]
+        else:
+            query_context = [*contexts, {"role": "user", "content": prompt}]
+
+        # 提取出系统提示
+        system_idxs = []
+        for idx, context in enumerate(query_context):
+            if context["role"] == "system":
+                system_idxs.append(idx)
+        for idx in reversed(system_idxs):
+            system_prompt += " " + query_context.pop(idx)["content"]
+
+        conf = {
+            "messages": query_context,
+            "system": system_prompt,
+        }
+        if func_tool:
+            conf["tools"] = func_tool
+
+        responses = await self.model.achat(**conf)
+
+        if session_id:
+            if not contexts:
+                self.session_memory[session_id].append(
+                    {"role": "user", "content": prompt}
+                )
+                self.session_memory[session_id].append(
+                    {"role": "assistant", "content": responses[-1].response_text}
+                )
+            else:
+                self.session_memory[session_id] = [
+                    *contexts,
+                    {"role": "user", "content": prompt},
+                    {"role": "assistant", "content": responses[-1].response_text},
+                ]
+            self.db_helper.update_llm_history(session_id, json.dumps(self.session_memory[session_id]), self.meta().type)
+        return responses[-1].response_text
+
+    async def forget(self, session_id):
+        self.session_memory[session_id] = []
+        return True
+
+    async def get_current_key(self):
+        return "none"
+
+    async def set_key(self, key):
+        pass
+
+    async def get_models(self):
+        return [self.get_model()]
+
+    async def get_human_readable_context(self, session_id, page, page_size):
+        if session_id not in self.session_memory:
+            raise Exception("会话 ID 不存在")
+        contexts = []
+        temp_contexts = []
+        for record in self.session_memory[session_id]:
+            if record["role"] == "user":
+                temp_contexts.append(f"User: {record['content']}")
+            elif record["role"] == "assistant":
+                temp_contexts.append(f"Assistant: {record['content']}")
+                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/provider/sources/openai_source.py

@@ -0,0 +1,229 @@
+import traceback
+import base64
+import json
+
+from openai import AsyncOpenAI, NOT_GIVEN
+from openai.types.chat.chat_completion import ChatCompletion
+from openai._exceptions import NotFoundError
+from astrbot.core.utils.io import download_image_by_url
+
+from astrbot.core.db import BaseDatabase
+from astrbot.api.provider import Provider
+from astrbot import logger
+from astrbot.core.provider.func_tool_manager import FuncCall
+from typing import List
+from ..register import register_provider_adapter
+from astrbot.core.provider.entites import LLMResponse
+
+@register_provider_adapter("openai_chat_completion", "OpenAI API Chat Completion 提供商适配器")
+class ProviderOpenAIOfficial(Provider):
+    def __init__(
+        self, 
+        provider_config: dict, 
+        provider_settings: dict,
+        db_helper: BaseDatabase, 
+        persistant_history = True
+    ) -> None:
+        super().__init__(provider_config, provider_settings, persistant_history, db_helper)
+        self.chosen_api_key = None
+        self.api_keys: List = provider_config.get("key", [])
+        self.chosen_api_key = self.api_keys[0] if len(self.api_keys) > 0 else None
+
+        self.client = AsyncOpenAI(
+            api_key=self.chosen_api_key,
+            base_url=provider_config.get("api_base", None),
+            timeout=provider_config.get("timeout", NOT_GIVEN),
+        )
+        self.set_model(provider_config['model_config']['model'])
+    
+    async def get_human_readable_context(self, session_id, page, page_size):
+        if session_id not in self.session_memory:
+            raise Exception("会话 ID 不存在")
+        contexts = []
+        temp_contexts = []
+        for record in self.session_memory[session_id]:
+            if record['role'] == "user":
+                temp_contexts.append(f"User: {record['content']}")
+            elif record['role'] == "assistant":
+                temp_contexts.append(f"Assistant: {record['content']}")
+                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
+
+    async def get_models(self):
+        try:
+            models_str = []
+            models = await self.client.models.list()
+            models = models.data
+            for model in models:
+                models_str.append(model.id)
+            return models_str
+        except NotFoundError as e:
+            raise Exception(f"获取模型列表失败：{e}")
+    
+    async def pop_record(self, session_id: str, pop_system_prompt: bool = False):
+        '''
+        弹出第一条记录
+        '''
+        if session_id not in self.session_memory:
+            raise Exception("会话 ID 不存在")
+
+        if len(self.session_memory[session_id]) == 0:
+            return None
+
+        for i in range(len(self.session_memory[session_id])):
+            # 检查是否是 system prompt
+            if not pop_system_prompt and self.session_memory[session_id][i]['user']['role'] == "system":
+                # 如果只有一个 system prompt，才不删掉
+                f = False
+                for j in range(i+1, len(self.session_memory[session_id])):
+                    if self.session_memory[session_id][j]['user']['role'] == "system":
+                        f = True
+                        break
+                if not f:
+                    continue
+            record = self.session_memory[session_id].pop(i)
+            break
+
+        return record
+    
+    async def _query(self, payloads: dict, tools: FuncCall) -> LLMResponse:
+        if tools:
+            payloads["tools"] = tools.get_func_desc_openai_style()
+        
+        completion = await self.client.chat.completions.create(
+            **payloads,
+            stream=False
+        )
+        
+        assert isinstance(completion, ChatCompletion)
+        logger.debug(f"completion: {completion.usage}")
+
+        if len(completion.choices) == 0:
+            raise Exception("API 返回的 completion 为空。")
+        choice = completion.choices[0]
+        
+        if choice.message.content:
+            # text completion
+            completion_text = str(choice.message.content).strip()
+            return LLMResponse("assistant", completion_text)
+        elif choice.message.tool_calls:
+            # tools call (function calling)
+            args_ls = []
+            func_name_ls = []
+            for tool_call in choice.message.tool_calls:
+                for tool in tools.func_list:
+                    if tool.name == tool_call.function.name:
+                        args = json.loads(tool_call.function.arguments)
+                        args_ls.append(args)
+                        func_name_ls.append(tool_call.function.name)
+            return LLMResponse(role="tool", tools_call_args=args_ls, tools_call_name=func_name_ls)
+        else:
+            raise Exception("Internal Error")
+
+    async def text_chat(
+        self,
+        prompt: str,
+        session_id: str,
+        image_urls: List[str]=None,
+        func_tool: FuncCall=None,
+        contexts=None,
+        system_prompt=None,
+        **kwargs
+    ) -> LLMResponse: 
+        new_record = await self.assemble_context(prompt, image_urls)
+        context_query = []
+        if not contexts:
+            context_query = [*self.session_memory[session_id], new_record]
+        else:
+            context_query = [*contexts, new_record]
+        if system_prompt:
+            context_query.insert(0, {"role": "system", "content": system_prompt})
+
+        payloads = {
+            "messages": context_query,
+            **self.provider_config.get("model_config", {})
+        }
+
+        try:
+            llm_response = await self._query(payloads, func_tool)
+        except Exception as e:
+            if "maximum context length" in str(e):
+                logger.warning(f"请求失败：{e}。上下文长度超过限制。尝试弹出最早的记录然后重试。")
+                self.pop_record(session_id)
+            logger.warning(traceback.format_exc())
+            
+        await self.save_history(contexts, new_record, session_id, llm_response)
+
+        return llm_response
+    
+    async def save_history(self, contexts: List, new_record: dict, session_id: str, llm_response: LLMResponse):
+        if llm_response.role == "assistant" and session_id:
+            # 文本回复
+            if not contexts:
+                # 添加用户 record
+                self.session_memory[session_id].append(new_record)
+                # 添加 assistant record
+                self.session_memory[session_id].append({
+                    "role": "assistant",
+                    "content": llm_response.completion_text
+                })
+            else:
+                self.session_memory[session_id] = [*contexts, new_record, {
+                    "role": "assistant",
+                    "content": llm_response.completion_text
+                }]
+            self.db_helper.update_llm_history(session_id, json.dumps(self.session_memory[session_id]), self.provider_config['type'])
+        
+    async def forget(self, session_id: str) -> bool:
+        self.session_memory[session_id] = []
+        return True
+
+    def get_current_key(self) -> str:
+        return self.client.api_key
+
+    def get_keys(self) -> List[str]:
+        return self.api_keys
+    
+    def set_key(self, key):
+        self.client.api_key = key
+        
+    async def assemble_context(self, text: str, image_urls: List[str] = None):
+        '''
+        组装上下文。
+        '''
+        if image_urls:
+            user_content = {"role": "user","content": [{"type": "text", "text": text}]}
+            for image_url in image_urls:
+                if image_url.startswith("http"):
+                    image_path = await download_image_by_url(image_url)
+                    image_data = await self.encode_image_bs64(image_path)
+                else:
+                    if image_url.startswith("file:///"):
+                        image_url = image_url.replace("file:///", "")
+                    image_data = await self.encode_image_bs64(image_url)
+                user_content["content"].append({"type": "image_url", "image_url": {"url": image_data}})
+            return user_content
+        else:
+            return {"role": "user","content": text}
+
+    async def encode_image_bs64(self, image_url: str) -> str:
+        '''
+        将图片转换为 base64
+        '''
+        if image_url.startswith("base64://"):
+            return image_url.replace("base64://", "data:image/jpeg;base64,")
+        with open(image_url, "rb") as f:
+            image_bs64 = base64.b64encode(f.read()).decode('utf-8')
+            return "data:image/jpeg;base64," + image_bs64
+        return ''

astrbot/core/provider/sources/zhipu_source.py

@@ -0,0 +1,73 @@
+import traceback
+from astrbot.core.db import BaseDatabase
+from astrbot import logger
+from astrbot.core.provider.func_tool_manager import FuncCall
+from typing import List
+from ..register import register_provider_adapter
+from astrbot.core.provider.entites import LLMResponse
+from .openai_source import ProviderOpenAIOfficial
+
+@register_provider_adapter("zhipu_chat_completion", "智浦 Chat Completion 提供商适配器")
+class ProviderZhipu(ProviderOpenAIOfficial):
+    def __init__(
+        self, 
+        provider_config: dict, 
+        provider_settings: dict,
+        db_helper: BaseDatabase, 
+        persistant_history = True
+    ) -> None:
+        super().__init__(provider_config, provider_settings, db_helper, persistant_history)
+    
+    async def text_chat(
+        self,
+        prompt: str,
+        session_id: str,
+        image_urls: List[str]=None,
+        func_tool: FuncCall=None,
+        contexts=None,
+        system_prompt=None,
+        **kwargs
+    ) -> LLMResponse: 
+        new_record = await self.assemble_context(prompt, image_urls)
+        context_query = []
+        
+        if not contexts:
+            context_query = [*self.session_memory[session_id], new_record]
+        else:
+            context_query = [*contexts, new_record]
+        
+        model_cfgs: dict = self.provider_config.get("model_config", {})
+        # glm-4v-flash 只支持一张图片
+        model: str = model_cfgs.get("model", "")
+        if model.lower() == 'glm-4v-flash' and image_urls and len(context_query) > 1:
+            logger.debug("glm-4v-flash 只支持一张图片，将只保留最后一张图片")
+            logger.debug(context_query)
+            new_context_query_ = []
+            for i in range(0, len(context_query) - 1, 2):
+                if isinstance(context_query[i].get("content", ""), list):
+                    continue
+                new_context_query_.append(context_query[i])
+                new_context_query_.append(context_query[i+1])
+            new_context_query_.append(context_query[-1]) # 保留最后一条记录
+            context_query = new_context_query_
+            logger.debug(context_query)
+            
+        if system_prompt:
+            context_query.insert(0, {"role": "system", "content": system_prompt})
+            
+        payloads = {
+            "messages": context_query,
+            **model_cfgs
+        }
+        llm_response = None
+        try:
+            llm_response = await self._query(payloads, func_tool)
+        except Exception as e:
+            if "maximum context length" in str(e):
+                logger.warning(f"请求失败：{e}。上下文长度超过限制。尝试弹出最早的记录然后重试。")
+                self.pop_record(session_id)
+            logger.warning(traceback.format_exc())
+            
+        await self.save_history(contexts, new_record, session_id, llm_response)
+
+        return llm_response

astrbot/core/rag/embedding/openai_source.py

@@ -0,0 +1,25 @@
+from typing import List
+from openai import AsyncOpenAI
+
+class SimpleOpenAIEmbedding():
+    def __init__(
+        self, 
+        model,
+        api_key,
+        api_base=None,
+    ) -> None:
+        self.client = AsyncOpenAI(
+            api_key=api_key,
+            base_url=api_base
+        )
+        self.model = model
+        
+    async def get_embedding(self, text) -> List[float]:
+        '''
+        获取文本的嵌入
+        '''
+        embedding = await self.client.embeddings.create(
+            input=text,
+            model=self.model
+        )
+        return embedding.data[0].embedding

astrbot/core/rag/knowledge_db_mgr.py

@@ -0,0 +1,92 @@
+import os
+from typing import List, Dict
+from astrbot.core import logger
+from .store import Store
+from astrbot.core.config import AstrBotConfig
+
+class KnowledgeDBManager():
+    def __init__(self, astrbot_config: AstrBotConfig) -> None:
+        self.db_path = "data/knowledge_db/"
+        self.config = astrbot_config.get("knowledge_db", {})
+        self.astrbot_config = astrbot_config
+        if not os.path.exists(self.db_path):
+            os.makedirs(self.db_path)
+        self.store_insts: Dict[str, Store] = {}
+        for name, cfg in self.config.items():
+            if cfg["strategy"] == "embedding":
+                logger.info(f"加载 Chroma Vector Store：{name}")
+                try:
+                    from .store.chroma_db import ChromaVectorStore
+                except ImportError as ie:
+                    logger.error(f"{ie} 可能未安装 chromadb 库。")
+                    continue
+                self.store_insts[name] = ChromaVectorStore(name, cfg["embedding_config"])
+            else:
+                logger.error(f"不支持的策略：{cfg['strategy']}")
+
+
+    async def list_knowledge_db(self) -> List[str]:
+        return [f for f in os.listdir(self.db_path) if os.path.isfile(os.path.join(self.db_path, f))]
+    
+    
+    async def create_knowledge_db(self, name: str, config: Dict):
+        '''
+        config 格式：
+        ```
+        {
+            "strategy": "embedding", # 目前只支持 embedding
+            "chunk_method": {
+                "strategy": "fixed", 
+                "chunk_size": 100,
+                "overlap_size": 10
+            },
+            "embedding_config": {
+                "strategy": "openai",
+                "base_url": "",
+                "model": "",
+                "api_key": ""
+            }
+        }
+        ```
+        '''
+        if name in self.config:
+            raise ValueError(f"知识库已存在：{name}")
+        
+        self.config[name] = config
+        self.astrbot_config["knowledge_db"] = self.config
+        self.astrbot_config.save_config()
+    
+    
+    async def insert_record(self, name: str, text: str):
+        if name not in self.store_insts:
+            raise ValueError(f"未找到知识库：{name}")
+        
+        ret = []
+        match self.config[name]["chunk_method"]['strategy']:
+            case "fixed":
+                chunk_size = self.config[name]["chunk_method"]["chunk_size"]
+                chunk_overlap = self.config[name]["chunk_method"]["overlap_size"]
+                ret = self._fixed_chunk(text, chunk_size, chunk_overlap)
+            case _:
+                pass
+            
+        for chunk in ret:
+            await self.store_insts[name].save(chunk)
+
+    
+    async def retrive_records(self, name: str, query: str, top_n: int = 3) -> List[str]:
+        if name not in self.store_insts:
+            raise ValueError(f"未找到知识库：{name}")
+        
+        inst = self.store_insts[name]
+        return await inst.query(query, top_n)
+    
+    
+    def _fixed_chunk(self, text: str, chunk_size: int, chunk_overlap: int) -> List[str]:
+        chunks = []
+        start = 0
+        while start < len(text):
+            end = start + chunk_size
+            chunks.append(text[start:end])
+            start += chunk_size - chunk_overlap
+        return chunks

astrbot/core/rag/store/__init__.py

@@ -0,0 +1,8 @@
+from typing import List
+
+class Store():
+    async def save(self, text: str):
+        pass
+    
+    async def query(self, query: str, top_n: int = 3) -> List[str]:
+        pass

astrbot/core/rag/store/chroma_db.py

@@ -0,0 +1,39 @@
+import chromadb
+import uuid
+from typing import List, Dict
+from astrbot.api import logger
+from ..embedding.openai_source import SimpleOpenAIEmbedding
+from . import Store
+
+class ChromaVectorStore(Store):
+    def __init__(self, name: str, embedding_cfg: Dict) -> None:
+        self.chroma_client = chromadb.PersistentClient(path='data/long_term_memory_chroma.db')
+        self.collection = self.chroma_client.get_or_create_collection(name=name)
+        self.embedding = None
+        if embedding_cfg["strategy"] == "openai":
+            self.embedding = SimpleOpenAIEmbedding(
+                model=embedding_cfg["model"],
+                api_key=embedding_cfg["api_key"],
+                api_base=embedding_cfg.get("base_url", None)
+            )
+    
+    async def save(self, text: str, metadata: Dict = None):
+        logger.debug(f"Saving text: {text}")
+        embedding = await self.embedding.get_embedding(text)
+        
+        self.collection.upsert(
+            documents=text, 
+            metadatas=metadata,
+            ids=str(uuid.uuid4()),
+            embeddings=embedding
+        )
+    
+    async def query(self, query: str, top_n=3, metadata_filter: Dict = None) -> List[str]:
+        embedding = await self.embedding.get_embedding(query)
+        
+        results = self.collection.query(
+            query_embeddings=embedding,
+            n_results=top_n,
+            where=metadata_filter
+        )
+        return results['documents'][0]

astrbot/core/star/README.md

@@ -0,0 +1,5 @@
+# AstrBot Star
+
+`AstrBot Star` 就是插件。
+
+在 AstrBot v4.0 版本后，AstrBot 内部将插件命名为 `star`。插件的 handler 称作 `star_handler`。

astrbot/core/star/__init__.py

@@ -0,0 +1,19 @@
+from .star import StarMetadata
+from .star_manager import PluginManager
+from .context import Context
+from astrbot.core.provider import Provider
+from astrbot.core.utils.command_parser import CommandParserMixin
+from astrbot.core import html_renderer
+
+class Star(CommandParserMixin):
+    '''所有插件（Star）的父类，所有插件都应该继承于这个类'''
+    def __init__(self, context: Context):
+        self.context = context
+    
+    async def text_to_image(self, text: str, return_url = True) -> str:
+        '''将文本转换为图片'''
+        return await html_renderer.render_t2i(text, return_url=return_url)
+    
+    async def html_render(self, tmpl: str, data: dict, return_url = True) -> str:
+        '''渲染 HTML'''
+        return await html_renderer.render_custom_template(tmpl, data, return_url=return_url)

astrbot/core/star/context.py

@@ -0,0 +1,244 @@
+from asyncio import Queue
+from typing import List, TypedDict, Union
+
+from astrbot.core import sp
+from astrbot.core.provider.provider import Provider
+from astrbot.core.db import BaseDatabase
+from astrbot.core.config.astrbot_config import AstrBotConfig
+from astrbot.core.provider.func_tool_manager import FuncCall
+from astrbot.core.platform.astr_message_event import MessageSesion
+from astrbot.core.message.message_event_result import MessageChain
+from astrbot.core.provider.manager import ProviderManager
+from astrbot.core.platform.manager import PlatformManager
+from .star import star_registry, StarMetadata
+from .star_handler import star_handlers_registry, StarHandlerMetadata, EventType
+from .filter.command import CommandFilter
+from .filter.regex import RegexFilter
+from typing import Awaitable
+from astrbot.core.rag.knowledge_db_mgr import KnowledgeDBManager
+
+class StarCommand(TypedDict):
+    full_command_name: str
+    command_name: str
+
+class Context:
+    '''
+    暴露给插件的接口上下文。
+    '''
+    _event_queue: Queue = None
+    '''事件队列。消息平台通过事件队列传递消息事件。'''
+    
+    _config: AstrBotConfig = None
+    '''AstrBot 配置信息'''
+    
+    _db: BaseDatabase = None
+    '''AstrBot 数据库'''
+    
+    provider_manager: ProviderManager = None
+    
+    platform_manager: PlatformManager = None
+    
+    # back compatibility
+    _register_tasks: List[Awaitable] = []
+    _star_manager = None
+
+    def __init__(self, 
+        event_queue: Queue, 
+        config: AstrBotConfig, 
+        db: BaseDatabase, 
+        provider_manager: ProviderManager = None, 
+        platform_manager: PlatformManager = None,
+        knowledge_db_manager: KnowledgeDBManager = None
+    ):
+        self._event_queue = event_queue
+        self._config = config
+        self._db = db
+        self.provider_manager = provider_manager
+        self.platform_manager = platform_manager
+        self.knowledge_db_manager = knowledge_db_manager
+
+    def get_registered_star(self, star_name: str) -> StarMetadata:
+        for star in star_registry:
+            if star.name == star_name:
+                return star
+
+    def get_all_stars(self) -> List[StarMetadata]:
+        return star_registry
+    
+    def get_llm_tool_manager(self) -> FuncCall:
+        '''
+        获取 LLM Tool Manager
+        '''
+        return self.provider_manager.llm_tools
+        
+    def register_llm_tool(self, name: str, func_args: list, desc: str, func_obj: Awaitable) -> None:
+        '''
+        为函数调用（function-calling / tools-use）添加工具。
+        
+        @param name: 函数名
+        @param func_args: 函数参数列表，格式为 [{"type": "string", "name": "arg_name", "description": "arg_description"}, ...]
+        @param desc: 函数描述
+        @param func_obj: 异步处理函数。
+        
+        异步处理函数会接收到额外的的关键词参数：event: AstrMessageEvent, context: Context。
+        '''
+        md = StarHandlerMetadata(
+            event_type=EventType.OnLLMRequestEvent,
+            handler_full_name=func_obj.__module__ + "_" + func_obj.__name__,
+            handler_name=func_obj.__name__,
+            handler_module_path=func_obj.__module__,
+            handler=func_obj,
+            event_filters=[],
+            desc=desc
+        )
+        star_handlers_registry.append(md)
+        self.provider_manager.llm_tools.add_func(name, func_args, desc, func_obj, func_obj)
+    
+    def unregister_llm_tool(self, name: str) -> None:
+        '''删除一个函数调用工具。如果再要启用，需要重新注册。'''
+        self.provider_manager.llm_tools.remove_func(name)
+        
+    def activate_llm_tool(self, name: str) -> bool:
+        '''激活一个已经注册的函数调用工具。注册的工具默认是激活状态。
+        
+        Returns:
+            如果没找到，会返回 False
+        '''
+        func_tool = self.provider_manager.llm_tools.get_func(name)
+        if func_tool is not None:
+            func_tool.active = True
+            
+            inactivated_llm_tools: list = sp.get("inactivated_llm_tools", [])
+            if name in inactivated_llm_tools:
+                inactivated_llm_tools.remove(name)
+                sp.put("inactivated_llm_tools", inactivated_llm_tools)
+            
+            return True
+        return False
+            
+    def deactivate_llm_tool(self, name: str) -> bool:
+        '''停用一个已经注册的函数调用工具。
+        
+        Returns:
+            如果没找到，会返回 False'''
+        func_tool = self.provider_manager.llm_tools.get_func(name)
+        if func_tool is not None:
+            func_tool.active = False
+            
+            inactivated_llm_tools: list = sp.get("inactivated_llm_tools", [])
+            if name not in inactivated_llm_tools:
+                inactivated_llm_tools.append(name)
+                sp.put("inactivated_llm_tools", inactivated_llm_tools)
+                
+            return True
+        return False
+    
+    def register_commands(self, star_name: str, command_name: str, desc: str, priority: int, awaitable: Awaitable, use_regex=False, ignore_prefix=False):
+        '''
+        注册一个命令。
+        
+        [Deprecated] 推荐使用装饰器注册指令。该方法将在未来的版本中被移除。
+        
+        @param star_name: 插件（Star）名称。
+        @param command_name: 命令名称。
+        @param desc: 命令描述。
+        @param priority: 优先级。1-10。
+        @param awaitable: 异步处理函数。
+        
+        '''
+        md = StarHandlerMetadata(
+            event_type=EventType.AdapterMessageEvent,
+            handler_full_name=awaitable.__module__ + "_" + awaitable.__name__,
+            handler_name=awaitable.__name__,
+            handler_module_path=awaitable.__module__,
+            handler=awaitable,
+            event_filters=[],
+            desc=desc
+        )
+        if use_regex:
+            md.event_filters.append(RegexFilter(
+                regex=command_name
+            ))
+        else:
+            md.event_filters.append(CommandFilter(
+                command_name=command_name,
+                handler_md=md
+            ))
+        star_handlers_registry.append(md)
+    
+    def register_provider(self, provider: Provider):
+        '''
+        注册一个 LLM Provider。
+        '''
+        self.provider_manager.provider_insts.append(provider)
+        
+    def get_provider_by_id(self, provider_id: str) -> Provider:
+        '''
+        通过 ID 获取 LLM Provider。
+        '''
+        for provider in self.provider_manager.provider_insts:
+            if provider.meta().id == provider_id:
+                return provider
+        return None
+    
+    def get_all_providers(self) -> List[Provider]:
+        '''
+        获取所有 LLM Provider。
+        '''
+        return self.provider_manager.provider_insts
+    
+    def get_using_provider(self) -> Provider:
+        '''
+        获取当前使用的 LLM Provider。
+        
+        通过 /provider 指令切换。
+        '''
+        return self.provider_manager.curr_provider_inst
+    
+    def get_config(self) -> AstrBotConfig:
+        '''
+        获取 AstrBot 配置信息。
+        '''
+        return self._config
+    
+    def get_db(self) -> BaseDatabase:
+        '''
+        获取 AstrBot 数据库。
+        '''
+        return self._db
+    
+    def get_event_queue(self) -> Queue:
+        '''
+        获取事件队列。
+        '''
+        return self._event_queue
+    
+    async def send_message(self, session: Union[str, MessageSesion], message_chain: MessageChain) -> bool:
+        '''
+        根据 session(unified_msg_origin) 发送消息。
+        
+        @param session: 消息会话。通过 event.session 或者 event.unified_msg_origin 获取。
+        @param message_chain: 消息链。
+        
+        @return: 是否找到匹配的平台。
+        
+        当 session 为字符串时，会尝试解析为 MessageSesion 对象，如果解析失败，会抛出 ValueError 异常。
+        '''
+        
+        if isinstance(session, str):
+            try:
+                session = MessageSesion.from_str(session)
+            except BaseException as e:
+                raise ValueError("不合法的 session 字符串: " + str(e))
+
+        for platform in self.platform_manager.platform_insts:
+            if platform.meta().name == session.platform_name:
+                await platform.send_by_session(session, message_chain)
+                return True
+        return False
+
+    def register_task(self, task: Awaitable, desc: str):
+        '''
+        注册一个异步任务。
+        '''
+        self._register_tasks.append(task)

astrbot/core/star/filter/__init__.py

@@ -0,0 +1,10 @@
+import abc
+from astrbot.core.platform.message_type import MessageType
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core.config import AstrBotConfig
+
+class HandlerFilter(abc.ABC):
+    @abc.abstractmethod
+    def filter(self, event: AstrMessageEvent, cfg: AstrBotConfig) -> bool:
+        '''是否应当被过滤'''
+        raise NotImplementedError

astrbot/core/star/filter/command.py

@@ -0,0 +1,70 @@
+
+import re
+import inspect
+from . import HandlerFilter
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core.config import AstrBotConfig
+from astrbot.core.utils.param_validation_mixin import ParameterValidationMixin
+from ..star_handler import StarHandlerMetadata
+
+# 标准指令受到 wake_prefix 的制约。
+class CommandFilter(HandlerFilter, ParameterValidationMixin):
+    '''标准指令过滤器'''
+    def __init__(self, command_name: str, handler_md: StarHandlerMetadata = None):
+        self.command_name = command_name
+        if handler_md:
+            self.init_handler_md(handler_md)
+            
+    def print_types(self):
+        result = ""
+        for k, v in self.handler_params.items():
+            if isinstance(v, type):
+                result += f"{k}({v.__name__}),"
+            else:
+                result += f"{k}({type(v).__name__})={v},"
+        return result
+                
+    def init_handler_md(self, handle_md: StarHandlerMetadata):
+        self.handler_md = handle_md
+        signature = inspect.signature(self.handler_md.handler)
+        self.handler_params = {} # 参数名 -> 参数类型，如果有默认值则为默认值
+        idx = 0
+        for k, v in signature.parameters.items():
+            if idx < 2:
+                # 忽略前两个参数，即 self 和 event
+                idx += 1
+                continue
+            if v.default == inspect.Parameter.empty:
+                self.handler_params[k] = v.annotation
+            else:
+                self.handler_params[k] = v.default
+                
+    def get_handler_md(self) -> StarHandlerMetadata:
+        return self.handler_md
+
+    def filter(self, event: AstrMessageEvent, cfg: AstrBotConfig) -> bool:
+        if not event.is_wake_up():
+            return False
+        
+        message_str = event.get_message_str().strip()
+        # 分割为列表（每个参数之间可能会有多个空格）
+        ls = re.split(r"\s+", message_str)
+        if self.command_name != ls[0]:
+            return False
+        # if len(self.handler_params) == 0 and len(ls) > 1:
+        #     # 一定程度避免 LLM 聊天时误判为指令
+        #     return False
+        # params_str = message_str[len(self.command_name):].strip()
+        ls = ls[1:]
+        # 去除空字符串
+        ls = [param for param in ls if param]
+        params = {}
+        try:
+            params = self.validate_and_convert_params(ls, self.handler_params)
+            
+        except ValueError as e:
+            raise e
+        
+        event.set_extra("parsed_params", params)
+        
+        return True

astrbot/core/star/filter/command_group.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import re
+from typing import List, Union, Tuple
+from . import HandlerFilter
+from .command import CommandFilter
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core.config import AstrBotConfig
+from ..star_handler import StarHandlerMetadata
+
+# 指令组受到 wake_prefix 的制约。
+class CommandGroupFilter(HandlerFilter):
+    def __init__(self, group_name: str):
+        self.group_name = group_name
+        self.sub_command_filters: List[Union[CommandFilter, CommandGroupFilter]] = []
+    
+    def add_sub_command_filter(self, sub_command_filter: Union[CommandFilter, CommandGroupFilter]):
+        self.sub_command_filters.append(sub_command_filter)
+    
+    # 以树的形式打印出来
+    def print_cmd_tree(self, sub_command_filters: List[Union[CommandFilter, CommandGroupFilter]], prefix: str = "") -> str:
+        result = ""
+        for sub_filter in sub_command_filters:
+            if isinstance(sub_filter, CommandFilter):
+                cmd_th = sub_filter.print_types()
+                result += f"{prefix}├── {sub_filter.command_name}"
+                if cmd_th:
+                    result += f" ({cmd_th})"
+                else:
+                    result += " (无参数指令)"
+                
+                result += "\n"
+            elif isinstance(sub_filter, CommandGroupFilter):
+                result += f"{prefix}├── {sub_filter.group_name}"
+                result += "\n"
+                result += sub_filter.print_cmd_tree(sub_filter.sub_command_filters, prefix+"│   ")
+        return result
+        
+    def filter(self, event: AstrMessageEvent, cfg: AstrBotConfig) -> Tuple[bool, StarHandlerMetadata]:
+        if not event.is_wake_up():
+            return False, None
+        
+        message_str = event.get_message_str().strip()
+        ls = re.split(r"\s+", message_str)
+        
+        if ls[0] != self.group_name:
+            return False, None
+        # 改写 message_str
+        ls = ls[1:]
+        event.message_str = " ".join(ls)
+        event.message_str = event.message_str.strip()
+        
+        if event.message_str == "":
+            # 当前还是指令组
+            tree = self.group_name + "\n" + self.print_cmd_tree(self.sub_command_filters)
+            raise ValueError(f"指令组 {self.group_name} 未填写完全。这个指令组下有如下指令：\n"+tree)
+        
+        child_command_handler_md = None
+        for sub_filter in self.sub_command_filters:
+            if isinstance(sub_filter, CommandFilter):
+                if sub_filter.filter(event, cfg):
+                    child_command_handler_md = sub_filter.get_handler_md()
+                    return True, child_command_handler_md
+            elif isinstance(sub_filter, CommandGroupFilter):
+                ok, handler = sub_filter.filter(event, cfg)
+                if ok:
+                    child_command_handler_md = handler
+                    return True, child_command_handler_md
+        tree = self.group_name + "\n" + self.print_cmd_tree(self.sub_command_filters)
+        raise ValueError(f"指令组 {self.group_name} 下没有找到对应的指令。这个指令组下有如下指令：\n"+tree)

astrbot/core/star/filter/event_message_type.py

@@ -0,0 +1,28 @@
+import enum
+from . import HandlerFilter
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core.config import AstrBotConfig
+from astrbot.core.platform.message_type import MessageType
+
+class EventMessageType(enum.Flag):
+    GROUP_MESSAGE = enum.auto()
+    PRIVATE_MESSAGE = enum.auto()
+    OTHER_MESSAGE = enum.auto()
+    ALL = GROUP_MESSAGE | PRIVATE_MESSAGE | OTHER_MESSAGE
+    
+MESSAGE_TYPE_2_EVENT_MESSAGE_TYPE = {
+    MessageType.GROUP_MESSAGE: EventMessageType.GROUP_MESSAGE,
+    MessageType.FRIEND_MESSAGE: EventMessageType.PRIVATE_MESSAGE,
+    MessageType.OTHER_MESSAGE: EventMessageType.OTHER_MESSAGE
+}
+
+class EventMessageTypeFilter(HandlerFilter):
+    def __init__(self, event_message_type: EventMessageType):
+        self.event_message_type = event_message_type
+        
+    def filter(self, event: AstrMessageEvent, cfg: AstrBotConfig) -> bool:
+        message_type = event.get_message_type()
+        if message_type in MESSAGE_TYPE_2_EVENT_MESSAGE_TYPE:
+            event_message_type = MESSAGE_TYPE_2_EVENT_MESSAGE_TYPE[message_type]
+            return bool(event_message_type & self.event_message_type)
+        return False

astrbot/core/star/filter/permission.py

@@ -0,0 +1,25 @@
+import enum
+from . import HandlerFilter
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core.config import AstrBotConfig
+
+class PermissionType(enum.Flag):
+    '''权限类型。当选择 MEMBER，ADMIN 也可以通过。
+    '''
+    ADMIN = enum.auto()
+    MEMBER = enum.auto()
+
+class PermissionTypeFilter(HandlerFilter):
+    def __init__(self, permission_type: PermissionType, raise_error: bool = True):
+        self.permission_type = permission_type
+        self.raise_error = raise_error
+        
+    def filter(self, event: AstrMessageEvent, cfg: AstrBotConfig) -> bool:
+        '''过滤器
+        '''
+        if self.permission_type == PermissionType.ADMIN:
+            if not event.is_admin():
+                event.stop_event()
+                raise ValueError("您没有权限执行此操作。")
+
+        return True

astrbot/core/star/filter/platform_adapter_type.py

@@ -0,0 +1,27 @@
+import enum
+from . import HandlerFilter
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core.config import AstrBotConfig
+from typing import Union
+
+class PlatformAdapterType(enum.Flag):
+    AIOCQHTTP = enum.auto()
+    QQOFFICIAL = enum.auto()
+    VCHAT = enum.auto()
+    ALL = AIOCQHTTP | QQOFFICIAL | VCHAT
+    
+ADAPTER_NAME_2_TYPE = {
+    "aiocqhttp": PlatformAdapterType.AIOCQHTTP,
+    "qq_official": PlatformAdapterType.QQOFFICIAL,
+    "vchat": PlatformAdapterType.VCHAT
+}
+
+class PlatformAdapterTypeFilter(HandlerFilter):
+    def __init__(self, platform_adapter_type_or_str: Union[PlatformAdapterType, str]):
+        self.type_or_str = platform_adapter_type_or_str
+        
+    def filter(self, event: AstrMessageEvent, cfg: AstrBotConfig) -> bool:
+        adapter_name = event.get_platform_name()
+        if adapter_name in ADAPTER_NAME_2_TYPE:
+            return ADAPTER_NAME_2_TYPE[adapter_name] & self.type_or_str
+        return False

astrbot/core/star/filter/regex.py

@@ -0,0 +1,14 @@
+
+import re
+from . import HandlerFilter
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core.config import AstrBotConfig
+
+# 正则表达式过滤器不会受到 wake_prefix 的制约。
+class RegexFilter(HandlerFilter):
+    '''正则表达式过滤器'''
+    def __init__(self, regex: str):
+        self.regex = re.compile(regex)
+        
+    def filter(self, event: AstrMessageEvent, cfg: AstrBotConfig) -> bool:
+        return bool(self.regex.match(event.get_message_str().strip()))

astrbot/core/star/register/__init__.py

@@ -0,0 +1,27 @@
+from .star import register_star
+from .star_handler import (
+    register_command,
+    register_command_group,
+    register_event_message_type,
+    register_platform_adapter_type,
+    register_regex,
+    register_permission_type,
+    register_on_llm_request,
+    register_llm_tool,
+    register_on_decorating_result,
+    register_after_message_sent
+)
+
+__all__ = [
+    'register_star',
+    'register_command',
+    'register_command_group',
+    'register_event_message_type',
+    'register_platform_adapter_type',
+    'register_regex',
+    'register_permission_type',
+    'register_on_llm_request',
+    'register_llm_tool',
+    'register_on_decorating_result',
+    'register_after_message_sent'
+]

astrbot/core/star/register/star.py

@@ -0,0 +1,36 @@
+from ..star import star_registry, StarMetadata, star_map
+
+def register_star(name: str, author: str, desc: str, version: str, repo: str = None):
+    '''注册一个插件(Star)。
+    
+    Args:
+        name: 插件名称。
+        author: 作者。
+        desc: 插件的简述。
+        version: 版本号。
+        repo: 仓库地址。如果没有填写仓库地址，将无法更新这个插件。
+        
+    如果需要为插件填写帮助信息，请使用如下格式：
+    
+    ```python
+    class MyPlugin(star.Star):
+        \'\'\'这是帮助信息\'\'\'
+        ...
+        
+    帮助信息会被自动提取。使用 `/plugin <插件名> 可以查看帮助信息。`
+    '''
+    def decorator(cls):
+        star_metadata = StarMetadata(
+            name=name,
+            author=author,
+            desc=desc,
+            version=version,
+            repo=repo,
+            star_cls_type=cls,
+            module_path=cls.__module__,
+        )
+        star_registry.append(star_metadata)
+        star_map[cls.__module__] = star_metadata
+        return cls
+    
+    return decorator

astrbot/core/star/register/star_handler.py

@@ -0,0 +1,209 @@
+from __future__ import annotations
+import docstring_parser
+
+from ..star_handler import star_handlers_registry, StarHandlerMetadata, EventType
+from ..filter.command import CommandFilter
+from ..filter.command_group import CommandGroupFilter
+from ..filter.event_message_type import EventMessageTypeFilter, EventMessageType
+from ..filter.platform_adapter_type import PlatformAdapterTypeFilter, PlatformAdapterType
+from ..filter.permission import PermissionTypeFilter, PermissionType
+from ..filter.regex import RegexFilter
+from typing import Awaitable
+from astrbot.core.provider.func_tool_manager import SUPPORTED_TYPES
+from astrbot.core.provider.register import llm_tools
+from astrbot.core import logger
+
+def get_handler_full_name(awaitable: Awaitable) -> str:
+    '''获取 Handler 的全名'''
+    return f"{awaitable.__module__}_{awaitable.__name__}"
+
+def get_handler_or_create(handler: Awaitable, event_type: EventType, dont_add = False) -> StarHandlerMetadata:
+    '''获取 Handler 或者创建一个新的 Handler'''
+    handler_full_name = get_handler_full_name(handler)
+    md = star_handlers_registry.get_handler_by_full_name(handler_full_name)
+    if md:
+        return md
+    else:
+        md = StarHandlerMetadata(
+            event_type=event_type,
+            handler_full_name=handler_full_name,
+            handler_name=handler.__name__,
+            handler_module_path=handler.__module__,
+            handler=handler,
+            event_filters=[]
+        )
+        if not dont_add:
+            star_handlers_registry.append(md)
+        return md
+
+def register_command(command_name: str = None, *args):
+    '''注册一个 Command'''
+    
+    new_command = None
+    add_to_event_filters = False
+    if isinstance(command_name, RegisteringCommandable):
+        # 子指令
+        new_command = CommandFilter(args[0], None)
+        command_name.parent_group.add_sub_command_filter(new_command)
+    else:
+        # 裸指令
+        new_command = CommandFilter(command_name, None)
+        add_to_event_filters = True
+    
+    def decorator(awaitable):
+        handler_md = get_handler_or_create(awaitable, EventType.AdapterMessageEvent)
+        new_command.init_handler_md(handler_md)
+        if add_to_event_filters:
+            # 裸指令
+            handler_md.event_filters.append(new_command)
+        
+        return awaitable
+
+    return decorator
+
+def register_command_group(command_group_name: str = None, *args):
+    '''注册一个 CommandGroup'''
+    
+    new_group = None
+    add_to_event_filters = False
+    if isinstance(command_group_name, RegisteringCommandable):
+        # 子指令组
+        new_group = CommandGroupFilter(args[0])
+        command_group_name.parent_group.add_sub_command_filter(new_group)
+    else:
+        # 根指令组
+        new_group = CommandGroupFilter(command_group_name)
+        add_to_event_filters = True
+    
+    def decorator(obj):
+        if add_to_event_filters:
+            # 根指令组
+            handler_md = get_handler_or_create(obj, EventType.AdapterMessageEvent)
+            handler_md.event_filters.append(new_group)
+        
+        return RegisteringCommandable(new_group)
+
+    return decorator
+
+class RegisteringCommandable():
+    '''用于指令组级联注册'''
+    group = register_command_group
+    command = register_command
+    
+    def __init__(self, parent_group: CommandGroupFilter):
+        self.parent_group = parent_group
+
+def register_event_message_type(event_message_type: EventMessageType):
+    '''注册一个 EventMessageType'''
+    def decorator(awaitable):
+        handler_md = get_handler_or_create(awaitable, EventType.AdapterMessageEvent)
+        handler_md.event_filters.append(EventMessageTypeFilter(event_message_type))
+        return awaitable
+
+    return decorator
+
+def register_platform_adapter_type(platform_adapter_type: PlatformAdapterType):
+    '''注册一个 PlatformAdapterType'''
+    def decorator(awaitable):
+        handler_md = get_handler_or_create(awaitable, EventType.AdapterMessageEvent)
+        handler_md.event_filters.append(PlatformAdapterTypeFilter(platform_adapter_type))
+        return awaitable
+
+    return decorator
+
+def register_regex(regex: str):
+    '''注册一个 Regex'''
+    def decorator(awaitable):
+        handler_md = get_handler_or_create(awaitable, EventType.AdapterMessageEvent)
+        handler_md.event_filters.append(RegexFilter(regex))
+        return awaitable
+
+    return decorator
+
+def register_permission_type(permission_type: PermissionType, raise_error: bool = True):
+    '''注册一个 PermissionType
+    
+    Args:
+        permission_type: PermissionType
+        raise_error: 如果没有权限，是否抛出错误到消息平台，并且停止事件传播。默认为 True
+    '''
+    def decorator(awaitable):
+        handler_md = get_handler_or_create(awaitable, EventType.AdapterMessageEvent)
+        handler_md.event_filters.append(PermissionTypeFilter(permission_type, raise_error))
+        return awaitable
+
+    return decorator
+
+def register_on_llm_request():
+    '''当有 LLM 请求时的事件
+    
+    Examples:
+    ```py
+    @on_llm_request()
+    async def test(self, event: AstrMessageEvent, request: ProviderRequest) -> None:
+        request.system_prompt += "你是一个猫娘..."
+    ```
+    
+    请务必接收两个参数：event, request
+    '''
+    def decorator(awaitable):
+        _ = get_handler_or_create(awaitable, EventType.OnLLMRequestEvent)
+        return awaitable
+    
+    return decorator
+
+def register_llm_tool(name: str = None):
+    '''为函数调用（function-calling / tools-use）添加工具。
+    
+    请务必按照以下格式编写一个工具（包括函数注释，AstrBot 会尝试解析该函数注释）
+    
+    ```
+    @llm_tool(name="get_weather") # 如果 name 不填，将使用函数名
+    async def get_weather(event: AstrMessageEvent, location: str) -> MessageEventResult:
+        \'\'\'获取天气信息。
+        
+        Args:
+            location(string): 地点
+        \'\'\'
+        # 处理逻辑
+    ```
+    
+    可接受的参数类型有：string, number, object, array, boolean。
+    '''
+    name_ = name
+    
+    def decorator(awaitable: Awaitable):
+        llm_tool_name = name_ if name_ else awaitable.__name__
+        docstring = docstring_parser.parse(awaitable.__doc__)
+        args = []
+        for arg in docstring.params:
+            if arg.type_name not in SUPPORTED_TYPES:
+                raise ValueError(f"LLM 函数工具 {awaitable.__module__}_{llm_tool_name} 不支持的参数类型：{arg.type_name}")
+            args.append({
+                "type": arg.type_name,
+                "name": arg.arg_name,
+                "description": arg.description
+            })
+        md = get_handler_or_create(awaitable, EventType.OnCallingFuncToolEvent)
+        llm_tools.add_func(llm_tool_name, args, docstring.description, md.handler)
+        
+        logger.debug(f"LLM 函数工具 {llm_tool_name} 已注册")
+        return awaitable
+    
+    return decorator
+
+def register_on_decorating_result():
+    '''在发送消息前的事件'''
+    def decorator(awaitable):
+        _ = get_handler_or_create(awaitable, EventType.OnDecoratingResultEvent)
+        return awaitable
+    
+    return decorator
+
+def register_after_message_sent():
+    '''在消息发送后的事件'''
+    def decorator(awaitable):
+        _ = get_handler_or_create(awaitable, EventType.OnAfterMessageSentEvent)
+        return awaitable
+    
+    return decorator

astrbot/core/star/star.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from types import ModuleType
+from typing import List, Dict
+from dataclasses import dataclass
+
+star_registry: List[StarMetadata] = []
+star_map: Dict[str, StarMetadata] = {}
+'''key 是模块路径，__module__'''
+
+@dataclass
+class StarMetadata:
+    '''
+    Star 的元数据。
+    '''
+    name: str
+    author: str  # 插件作者
+    desc: str  # 插件简介
+    version: str  # 插件版本
+    repo: str = None  # 插件仓库地址
+
+    star_cls_type: type = None
+    '''Star 的类对象的类型'''
+    module_path: str = None
+    '''Star 的模块路径'''
+    
+    star_cls: object = None
+    '''Star 的类对象'''
+    module: ModuleType = None
+    '''Star 的模块对象'''
+    root_dir_name: str = None
+    '''Star 的根目录名'''
+    reserved: bool = False
+    '''是否是 AstrBot 的保留 Star'''
+    
+    activated: bool = True
+    '''是否被激活'''
+
+    def __str__(self) -> str:
+        return f"StarMetadata({self.name}, {self.desc}, {self.version}, {self.repo})"

astrbot/core/star/star_handler.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+import enum
+from dataclasses import dataclass
+from typing import Awaitable, List, Dict, TypeVar, Generic
+from .filter import HandlerFilter
+from .star import star_map
+
+T = TypeVar('T', bound='StarHandlerMetadata')
+class StarHandlerRegistry(Generic[T], List[T]):
+    '''用于存储所有的 Star Handler'''
+    
+    star_handlers_map: Dict[str, StarHandlerMetadata] = {}
+    '''用于快速查找。key 是 handler_full_name'''
+    
+    def append(self, handler: StarHandlerMetadata):
+        '''添加一个 Handler'''
+        super().append(handler)
+        self.star_handlers_map[handler.handler_full_name] = handler
+        
+    def get_handlers_by_event_type(self, event_type: EventType, only_activated = True) -> List[StarHandlerMetadata]:
+        '''通过事件类型获取 Handler'''
+        if only_activated:
+            return [
+                handler 
+                for handler in self 
+                if handler.event_type == event_type and 
+                star_map[handler.handler_module_path] and 
+                star_map[handler.handler_module_path].activated
+            ]
+        else:
+            return [handler for handler in self if handler.event_type == event_type]
+    
+    def get_handler_by_full_name(self, full_name: str) -> StarHandlerMetadata:
+        '''通过 Handler 的全名获取 Handler'''
+        return self.star_handlers_map.get(full_name, None)
+    
+    def get_handlers_by_module_name(self, module_name: str) -> List[StarHandlerMetadata]:
+        '''通过模块名获取 Handler'''
+        return [handler for handler in self if handler.handler_module_path == module_name]
+    
+star_handlers_registry = StarHandlerRegistry()
+
+class EventType(enum.Enum):
+    '''表示一个 AstrBot 内部事件的类型。如适配器消息事件、LLM 请求事件、发送消息前的事件等
+    
+    用于对 Handler 的职能分组。
+    '''
+    AdapterMessageEvent = enum.auto() # 收到适配器发来的消息
+    OnLLMRequestEvent = enum.auto() # 收到 LLM 请求（可以是用户也可以是插件）
+    OnDecoratingResultEvent = enum.auto() # 发送消息前
+    OnCallingFuncToolEvent = enum.auto() # 调用函数工具
+    OnAfterMessageSentEvent = enum.auto() # 发送消息后
+
+@dataclass
+class StarHandlerMetadata():
+    '''描述一个 Star 所注册的某一个 Handler。'''
+    
+    event_type: EventType
+    '''Handler 的事件类型'''
+    
+    handler_full_name: str
+    '''格式为 f"{handler.__module__}_{handler.__name__}"'''
+    
+    handler_name: str
+    '''Handler 的名字，也就是方法名'''
+    
+    handler_module_path: str
+    '''Handler 所在的模块路径。'''
+    
+    handler: Awaitable
+    '''Handler 的函数对象，应当是一个异步函数'''
+    
+    event_filters: List[HandlerFilter]
+    '''一个适配器消息事件过滤器，用于描述这个 Handler 能够处理、应该处理的适配器消息事件'''
+    
+    desc: str = ""
+    '''Handler 的描述信息'''

astrbot/core/star/star_manager.py

@@ -0,0 +1,338 @@
+import inspect
+import functools
+import os
+import sys
+import traceback
+import yaml
+import logging
+from types import ModuleType
+from typing import List
+from pip import main as pip_main
+from astrbot.core.config.astrbot_config import AstrBotConfig
+from astrbot.core import logger, sp, pip_installer
+from .context import Context
+from . import StarMetadata
+from .updator import PluginUpdator
+from astrbot.core.utils.io import remove_dir
+from .star import star_registry, star_map
+from .star_handler import star_handlers_registry
+from astrbot.core.provider.register import llm_tools
+
+class PluginManager:
+    def __init__(
+        self, 
+        context: Context,
+        config: AstrBotConfig    
+    ):
+        self.updator = PluginUpdator(config['plugin_repo_mirror'])
+        
+        self.context = context
+        self.context._star_manager = self # 就这样吧，不想改了
+                
+        self.config = config
+        self.plugin_store_path = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../../data/plugins"))
+        self.reserved_plugin_path = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../../packages"))
+
+    def _get_classes(self, arg: ModuleType):
+        classes = []
+        clsmembers = inspect.getmembers(arg, inspect.isclass)
+        for (name, _) in clsmembers:
+            if name.lower().endswith("plugin") or name.lower() == "main":
+                classes.append(name)
+                break
+        return classes
+
+    def _get_modules(self, path):
+        modules = []
+
+        dirs = os.listdir(path)
+        # 遍历文件夹，找到 main.py 或者和文件夹同名的文件
+        for d in dirs:
+            if os.path.isdir(os.path.join(path, d)):
+                if os.path.exists(os.path.join(path, d, "main.py")):
+                    module_str = 'main'
+                elif os.path.exists(os.path.join(path, d, d + ".py")):
+                    module_str = d
+                else:
+                    print(f"插件 {d} 未找到 main.py 或者 {d}.py，跳过。")
+                    continue
+                if os.path.exists(os.path.join(path, d, "main.py")) or os.path.exists(os.path.join(path, d, d + ".py")):
+                    modules.append({
+                        "pname": d,
+                        "module": module_str,
+                        "module_path": os.path.join(path, d, module_str)
+                    })
+        return modules
+    
+    def _get_plugin_modules(self) -> List[dict]:
+        plugins = []
+        if os.path.exists(self.plugin_store_path):
+            plugins.extend(self._get_modules(self.plugin_store_path))
+        if os.path.exists(self.reserved_plugin_path):
+            _p = self._get_modules(self.reserved_plugin_path)
+            for p in _p:
+                p['reserved'] = True
+            plugins.extend(_p)
+        return plugins
+        
+    def _check_plugin_dept_update(self, target_plugin: str = None):
+        '''检查插件的依赖
+        如果 target_plugin 为 None，则检查所有插件的依赖
+        '''
+        plugin_dir = self.plugin_store_path
+        if not os.path.exists(plugin_dir):
+            return False
+        to_update = []
+        if target_plugin:
+            to_update.append(target_plugin)
+        else:
+            for p in self.context.get_all_stars():
+                to_update.append(p.root_dir_name)
+        for p in to_update:
+            plugin_path = os.path.join(plugin_dir, p)
+            if os.path.exists(os.path.join(plugin_path, "requirements.txt")):
+                pth = os.path.join(plugin_path, "requirements.txt")
+                logger.info(f"正在安装插件 {p} 所需的依赖库: {pth}")
+                try:
+                    pip_installer.install(requirements_path=pth)
+                except Exception as e:
+                    logger.error(f"更新插件 {p} 的依赖失败。Code: {str(e)}")
+
+    def _load_plugin_metadata(self, plugin_path: str, plugin_obj = None) -> StarMetadata:
+        '''v3.4.0 以前的方式载入插件元数据
+        
+        先寻找 metadata.yaml 文件，如果不存在，则使用插件对象的 info() 函数获取元数据。
+        '''
+        metadata = None
+        
+        if not os.path.exists(plugin_path):
+            raise Exception("插件不存在。")
+        
+        if os.path.exists(os.path.join(plugin_path, "metadata.yaml")):
+            with open(os.path.join(plugin_path, "metadata.yaml"), "r", encoding='utf-8') as f:
+                metadata = yaml.safe_load(f)
+        elif plugin_obj:
+            # 使用 info() 函数
+            metadata = plugin_obj.info()
+        
+        if isinstance(metadata, dict):
+            if 'name' not in metadata or 'desc' not in metadata or 'version' not in metadata or 'author' not in metadata:
+                raise Exception("插件元数据信息不完整。")
+            metadata = StarMetadata(
+                name=metadata['name'],
+                author=metadata['author'],
+                desc=metadata['desc'],
+                version=metadata['version'],
+                repo=metadata['repo'] if 'repo' in metadata else None
+            )
+            
+        return metadata
+    
+    async def reload(self):
+        '''扫描并加载所有的 Star'''
+        for smd in star_registry:
+            logger.debug(f"尝试终止插件 {smd.name} ...")
+            if hasattr(smd.star_cls, "__del__"):
+                smd.star_cls.__del__()
+            
+        star_handlers_registry.clear()
+        star_handlers_registry.star_handlers_map.clear()
+        star_map.clear()
+        star_registry.clear()
+        for key in list(sys.modules.keys()):
+            if key.startswith("data.plugins") or key.startswith("packages"):
+                del sys.modules[key]
+        
+        plugin_modules = self._get_plugin_modules()
+        if plugin_modules is None:
+            return False, "未找到任何插件模块"
+        fail_rec = ""
+        
+        inactivated_plugins: list = sp.get("inactivated_plugins", [])
+        inactivated_llm_tools: list = sp.get("inactivated_llm_tools", [])
+        
+        # 导入 Star 模块，并尝试实例化 Star 类
+        for plugin_module in plugin_modules:
+            try:
+                module_str = plugin_module['module']
+                # module_path = plugin_module['module_path']
+                root_dir_name = plugin_module['pname']
+                reserved = plugin_module.get('reserved', False)
+                
+                logger.info(f"正在载入插件 {root_dir_name} ...")
+                
+                # 尝试导入模块
+                path = "data.plugins." if not reserved else "packages."
+                path += root_dir_name + "." + module_str
+                try:
+                    module = __import__(path, fromlist=[module_str])
+                except (ModuleNotFoundError, ImportError):
+                    # 尝试安装依赖
+                    self._check_plugin_dept_update(target_plugin=root_dir_name)
+                    module = __import__(path, fromlist=[module_str])
+                except Exception as e:
+                    logger.error(traceback.format_exc())
+                    logger.error(f"插件 {root_dir_name} 导入失败。原因：{str(e)}")
+                    continue
+
+                if path in star_map:
+                    # 通过装饰器的方式注册插件
+                    metadata = star_map[path]
+                    metadata.star_cls = metadata.star_cls_type(context=self.context)
+                    metadata.module = module
+                    metadata.root_dir_name = root_dir_name
+                    metadata.reserved = reserved
+                    
+                    related_handlers = star_handlers_registry.get_handlers_by_module_name(metadata.module_path)
+                    for handler in related_handlers:
+                        logger.debug(f"bind handler {handler.handler_name} to {metadata.name}")
+                        # handler.handler.__self__ = star_metadata.star_cls # 绑定 handler 的 self
+                        handler.handler = functools.partial(handler.handler, metadata.star_cls)
+                    # llm_tool
+                    for func_tool in llm_tools.func_list:
+                        if func_tool.handler.__module__ == metadata.module_path:
+                            func_tool.handler_module_path = metadata.module_path
+                            func_tool.handler = functools.partial(func_tool.handler, metadata.star_cls)
+                        if func_tool.name in inactivated_llm_tools:
+                            func_tool.active = False
+                    
+                else:
+                    # v3.4.0 以前的方式注册插件
+                    logger.debug(f"插件 {path} 未通过装饰器注册。尝试通过旧版本方式载入。")
+                    classes = self._get_classes(module)
+                    try:
+                        obj = getattr(module, classes[0])(context=self.context)
+                    except BaseException as e:
+                        logger.error(f"插件 {root_dir_name} 实例化失败。")
+                        raise e
+                    
+                    metadata = None
+                    plugin_path = os.path.join(self.plugin_store_path, root_dir_name) if not reserved else os.path.join(self.reserved_plugin_path, root_dir_name)
+                    metadata = self._load_plugin_metadata(plugin_path=plugin_path, plugin_obj=obj)
+                    metadata.star_cls = obj
+                    metadata.module = module
+                    metadata.root_dir_name = root_dir_name
+                    metadata.reserved = reserved
+                    metadata.star_cls_type = obj.__class__
+                    metadata.module_path = path
+                    star_map[path] = metadata
+                    star_registry.append(metadata)
+                    logger.debug(f"插件 {root_dir_name} 载入成功。")
+                
+                if metadata.module_path in inactivated_plugins:
+                    metadata.activated = False
+                    
+                # 执行 initialize 函数
+                if hasattr(metadata.star_cls, "initialize"):
+                    await metadata.star_cls.initialize()
+                    
+            except BaseException as e:
+                traceback.print_exc()
+                fail_rec += f"加载 {path} 插件时出现问题，原因 {str(e)}\n"
+
+        # 清除 pip.main 导致的多余的 logging handlers
+        for handler in logging.root.handlers[:]:
+            logging.root.removeHandler(handler)
+        
+        if not fail_rec:
+            return True, None
+        else:
+            return False, fail_rec
+        
+    async def install_plugin(self, repo_url: str):
+        plugin_path = await self.updator.install(repo_url)
+        # reload the plugin
+        await self.reload()
+        return plugin_path
+    
+    async def uninstall_plugin(self, plugin_name: str):
+        plugin = self.context.get_registered_star(plugin_name)
+        if not plugin:
+            raise Exception("插件不存在。")
+        if plugin.reserved:
+            raise Exception("该插件是 AstrBot 保留插件，无法卸载。")
+        root_dir_name = plugin.root_dir_name
+        ppath = self.plugin_store_path
+        
+        # 从 star_registry 和 star_map 中删除
+        await self._unbind_plugin(plugin_name, plugin.module_path)
+        
+        if not remove_dir(os.path.join(ppath, root_dir_name)):
+            raise Exception("移除插件成功，但是删除插件文件夹失败。您可以手动删除该文件夹，位于 addons/plugins/ 下。")
+        
+    async def _unbind_plugin(self, plugin_name: str, plugin_module_path: str):
+        del star_map[plugin_module_path]
+        for i, p in enumerate(star_registry):
+            if p.name == plugin_name:
+                del star_registry[i]
+                break
+        for handler in star_handlers_registry.get_handlers_by_module_name(plugin_module_path):
+            logger.debug(f"unbind handler {handler.handler_name} from {plugin_name}")
+            star_handlers_registry.remove(handler)
+        keys_to_delete = [k for k, v in star_handlers_registry.star_handlers_map.items() if k.startswith(plugin_module_path)]
+        for k in keys_to_delete:
+            v = star_handlers_registry.star_handlers_map[k]
+            logger.debug(f"unbind handler {v.handler_name} from {plugin_name} (map)")
+            del star_handlers_registry.star_handlers_map[k]
+
+    async def update_plugin(self, plugin_name: str):
+        plugin = self.context.get_registered_star(plugin_name)
+        if not plugin:
+            raise Exception("插件不存在。")
+        if plugin.reserved:
+            raise Exception("该插件是 AstrBot 保留插件，无法更新。")
+        
+        await self.updator.update(plugin)
+        await self.reload()
+    
+    async def turn_off_plugin(self, plugin_name: str):
+        plugin = self.context.get_registered_star(plugin_name)
+        if not plugin:
+            raise Exception("插件不存在。")
+        inactivated_plugins: list = sp.get("inactivated_plugins", [])
+        if plugin.module_path not in inactivated_plugins:
+            inactivated_plugins.append(plugin.module_path)
+            
+        inactivated_llm_tools: list = sp.get("inactivated_llm_tools", [])
+        
+        # 禁用插件启用的 llm_tool
+        for func_tool in llm_tools.func_list:
+            if func_tool.handler_module_path == plugin.module_path:
+                func_tool.active = False
+                inactivated_llm_tools.append(func_tool.name)
+    
+        sp.put("inactivated_plugins", inactivated_plugins)
+        sp.put("inactivated_llm_tools", inactivated_llm_tools)
+        
+        plugin.activated = False
+        
+    async def turn_on_plugin(self, plugin_name: str):
+        plugin = self.context.get_registered_star(plugin_name)
+        inactivated_plugins: list = sp.get("inactivated_plugins", [])
+        inactivated_llm_tools: list = sp.get("inactivated_llm_tools", [])
+        if plugin.module_path in inactivated_plugins:
+            inactivated_plugins.remove(plugin.module_path)
+        sp.put("inactivated_plugins", inactivated_plugins)
+        
+        # 启用插件启用的 llm_tool
+        for func_tool in llm_tools.func_list:
+            if func_tool.handler_module_path == plugin.module_path:
+                inactivated_llm_tools.remove(func_tool.name)
+                func_tool.active = True
+        sp.put("inactivated_llm_tools", inactivated_llm_tools)
+        
+        plugin.activated = True
+        
+        
+    def install_plugin_from_file(self, zip_file_path: str):
+        desti_dir = os.path.join(self.plugin_store_path, os.path.basename(zip_file_path))
+        self.updator.unzip_file(zip_file_path, desti_dir)
+
+        # remove the zip
+        try:
+            os.remove(zip_file_path)
+        except BaseException as e:
+            logger.warning(f"删除插件压缩包失败: {str(e)}")
+        
+        self._check_plugin_dept_update()
+

astrbot/core/star/updator.py

@@ -0,0 +1,70 @@
+import os
+import zipfile
+import shutil
+
+from ..updator import RepoZipUpdator
+from astrbot.core.utils.io import remove_dir, on_error
+from ..star.star import StarMetadata
+from astrbot.core import logger
+
+class PluginUpdator(RepoZipUpdator):
+    def __init__(self, repo_mirror: str = "") -> None:
+        super().__init__(repo_mirror)
+        self.plugin_store_path = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../../data/plugins"))
+        
+    def get_plugin_store_path(self) -> str:
+        return self.plugin_store_path
+    
+    async def install(self, repo_url: str) -> str:
+        repo_name = self.format_repo_name(repo_url)
+        plugin_path = os.path.join(self.plugin_store_path, repo_name)
+        await self.download_from_repo_url(plugin_path, repo_url)
+        self.unzip_file(plugin_path + ".zip", plugin_path)
+        
+        return plugin_path
+
+    async def update(self, plugin: StarMetadata) -> str:
+        repo_url = plugin.repo
+        
+        if not repo_url:
+            raise Exception(f"插件 {plugin.name} 没有指定仓库地址。")
+        
+        plugin_path = os.path.join(self.plugin_store_path, plugin.root_dir_name)
+            
+        logger.info(f"正在更新插件，路径: {plugin_path}，仓库地址: {repo_url}")
+        await self.download_from_repo_url(plugin_path, repo_url)
+        
+        try:
+            remove_dir(plugin_path)
+        except BaseException as e:
+            logger.error(f"删除旧版本插件 {plugin_path} 文件夹失败: {str(e)}，使用覆盖安装。")
+        
+        self.unzip_file(plugin_path + ".zip", plugin_path)
+        
+        return plugin_path
+
+    def unzip_file(self, zip_path: str, target_dir: str):
+        os.makedirs(target_dir, exist_ok=True)
+        update_dir = ""
+        logger.info(f"解压文件: {zip_path}")
+        with zipfile.ZipFile(zip_path, 'r') as z:
+            update_dir = z.namelist()[0]
+            z.extractall(target_dir)
+
+        files = os.listdir(os.path.join(target_dir, update_dir))
+        for f in files:
+            if os.path.isdir(os.path.join(target_dir, update_dir, f)):
+                if os.path.exists(os.path.join(target_dir, f)):
+                    shutil.rmtree(os.path.join(target_dir, f), onerror=on_error)
+            else:
+                if os.path.exists(os.path.join(target_dir, f)):
+                    os.remove(os.path.join(target_dir, f))
+            shutil.move(os.path.join(target_dir, update_dir, f), target_dir)
+        
+        try:
+            logger.info(f"删除临时文件: {zip_path} 和 {os.path.join(target_dir, update_dir)}")
+            shutil.rmtree(os.path.join(target_dir, update_dir), onerror=on_error)
+            os.remove(zip_path)
+        except BaseException:
+            logger.warning(f"删除更新文件失败，可以手动删除 {zip_path} 和 {os.path.join(target_dir, update_dir)}")
+            

astrbot/core/updator.py

@@ -1,14 +1,15 @@
-import os, psutil, sys, time
-from util.updator.zip_updator import ReleaseInfo, RepoZipUpdator
-from SparkleLogging.utils.core import LogManager
-from logging import Logger
-from type.config import VERSION
-from util.io import on_error, download_file
-
-logger: Logger = LogManager.GetLogger(log_name='astrbot')
+import os
+import psutil
+import sys
+import time
+from .zip_updator import ReleaseInfo, RepoZipUpdator
+from astrbot.core import logger
+from astrbot.core.config.default import VERSION
+from astrbot.core.utils.io import download_file
 
 class AstrBotUpdator(RepoZipUpdator):
-    def __init__(self):
+    def __init__(self, repo_mirror: str = "") -> None:
+        super().__init__(repo_mirror)
         self.MAIN_PATH = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../"))
         self.ASTRBOT_RELEASE_API = "https://api.github.com/repos/Soulter/AstrBot/releases"
 
@@ -30,11 +31,12 @@ class AstrBotUpdator(RepoZipUpdator):
         except psutil.NoSuchProcess:
             pass
     
-    def _reboot(self, delay: int = None, context = None):
-        # if delay: time.sleep(delay)
+    def _reboot(self, delay: int = 3):
+        if os.environ.get('TEST_MODE', 'off') == 'on':
+            logger.info("测试模式下不会重启。")
+            return
         py = sys.executable
-        context.running = False
-        time.sleep(3)
+        time.sleep(delay)
         self.terminate_child_processes()
         py = py.replace(" ", "\\ ")
         try:
@@ -43,11 +45,11 @@ class AstrBotUpdator(RepoZipUpdator):
             logger.error(f"重启失败（{py}, {e}），请尝试手动重启。")
             raise e
         
-    def check_update(self, url: str, current_version: str) -> ReleaseInfo:
-        return super().check_update(self.ASTRBOT_RELEASE_API, VERSION)
+    async def check_update(self, url: str, current_version: str) -> ReleaseInfo:
+        return await super().check_update(self.ASTRBOT_RELEASE_API, VERSION)
         
-    def update(self, reboot = False, latest = True, version = None):
-        update_data = self.fetch_release_info(self.ASTRBOT_RELEASE_API, latest)
+    async def update(self, reboot = False, latest = True, version = None):
+        update_data = await self.fetch_release_info(self.ASTRBOT_RELEASE_API, latest)
         file_url = None
         
         if latest:
@@ -55,26 +57,25 @@ class AstrBotUpdator(RepoZipUpdator):
             if self.compare_version(VERSION, latest_version) >= 0:
                 raise Exception("当前已经是最新版本。")
             file_url = update_data[0]['zipball_url']
-        else:
+        elif str(version).startswith("v"):
             # 更新到指定版本
-            print(f"请求更新到指定版本: {version}")
+            logger.info(f"正在更新到指定版本: {version}")
             for data in update_data:
                 if data['tag_name'] == version:
                     file_url = data['zipball_url']
             if not file_url:
                 raise Exception(f"未找到版本号为 {version} 的更新文件。")
+        else:
+            if len(str(version)) != 40:
+                raise Exception("commit hash 长度不正确，应为 40")
+            logger.info(f"正在尝试更新到指定 commit: {version}")
+            file_url = "https://github.com/Soulter/AstrBot/archive/" + version + ".zip"
             
         try:
-            download_file(file_url, "temp.zip")
+            await download_file(file_url, "temp.zip")
             self.unzip_file("temp.zip", self.MAIN_PATH)
         except BaseException as e:
             raise e
         
         if reboot:
             self._reboot()
-            
-    def unzip_file(self, zip_path: str, target_dir: str):
-        '''
-        解压缩文件, 并将压缩包内**第一个**文件夹内的文件移动到 target_dir
-        '''
-        pass

astrbot/core/utils/command_parser.py

@@ -10,13 +10,10 @@ class CommandTokens():
             return None
         return self.tokens[idx].strip()
 
-class CommandParser():
-    def __init__(self):
-        pass
-        
-    def parse(self, message: str):
+class CommandParserMixin():
+    def parse_commands(self, message: str):
         cmd_tokens = CommandTokens()
-        cmd_tokens.tokens = message.split(" ")
+        cmd_tokens.tokens = re.split(r"\s+", message)
         cmd_tokens.len = len(cmd_tokens.tokens)
         return cmd_tokens
     

astrbot/core/utils/dify_api_client.py

@@ -0,0 +1,90 @@
+import json
+from astrbot.core import logger
+from aiohttp import ClientSession
+from typing import Dict, List, Any, AsyncGenerator
+
+
+class DifyAPIClient:
+    def __init__(self, api_key: str, api_base: str = "https://api.dify.ai/v1"):
+        self.api_key = api_key
+        self.api_base = api_base
+        self.session = ClientSession()
+        self.headers = {
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+    async def chat_messages(
+        self,
+        inputs: Dict,
+        query: str,
+        user: str,
+        response_mode: str = "streaming",
+        conversation_id: str = "",
+        files: List[Dict[str, Any]] = [],
+        timeout: float = 60,
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        url = f"{self.api_base}/chat-messages"
+        payload = locals()
+        payload.pop("self")
+        payload.pop("timeout")
+        async with self.session.post(
+            url, json=payload, headers=self.headers, timeout=timeout
+        ) as resp:
+            while True:
+                data = await resp.content.read(8192) # 防止数据过大导致高水位报错
+                if not data:
+                    break
+                if not data.strip():
+                    continue
+                elif data.startswith(b"data:"):
+                    try:
+                        json_ = json.loads(data[5:])
+                        yield json_
+                    except BaseException:
+                        pass
+                    
+    async def workflow_run(
+        self,
+        inputs: Dict,
+        user: str,
+        response_mode: str = "streaming",
+        files: List[Dict[str, Any]] = [],
+        timeout: float = 60,
+    ):
+        url = f"{self.api_base}/workflows/run"
+        payload = locals()
+        payload.pop("self")
+        payload.pop("timeout")
+        async with self.session.post(
+            url, json=payload, headers=self.headers, timeout=timeout
+        ) as resp:
+            while True:
+                data = await resp.content.read(8192) # 防止数据过大导致高水位报错
+                if not data:
+                    break
+                if not data.strip():
+                    continue
+                elif data.startswith(b"data:"):
+                    try:
+                        json_ = json.loads(data[5:])
+                        yield json_
+                    except BaseException:
+                        pass
+                    
+    async def file_upload(
+        self,
+        file_path: str,
+        user: str,
+    ) -> Dict[str, Any]:
+        url = f"{self.api_base}/files/upload"
+        payload = {
+            "user": user,
+            "file": open(file_path, "rb"),
+        }
+        async with self.session.post(
+            url, data=payload, headers=self.headers
+        ) as resp:
+            return await resp.json() # {"id": "xxx", ...}
+                
+    async def close(self):
+        await self.session.close()