mirror of
https://github.com/langbot-app/LangBot.git
synced 2026-06-10 07:46:02 +00:00
744 lines
24 KiB
Markdown
744 lines
24 KiB
Markdown
# 事件路由与编排
|
||
|
||
## 1. 概述
|
||
|
||
事件路由是 EBA 架构的核心机制：事件从适配器产生后，经由 EventBus 进入 EventRouter，由 EventRouter 根据 Bot 的配置将事件分发到对应的处理器（Handler）。
|
||
|
||
**配置方式**：用户在 WebUI 的 Bot 管理页面通过可视化编排面板管理事件处理器配置，配置数据存储在数据库的 Bot 表 `event_handlers` JSON 字段中。
|
||
|
||
## 2. 数据模型
|
||
|
||
### 2.1 Bot 实体扩展
|
||
|
||
在 `bots` 表新增 `event_handlers` 字段：
|
||
|
||
```python
|
||
class Bot(Base):
|
||
__tablename__ = "bots"
|
||
|
||
uuid: str # 主键
|
||
name: str
|
||
description: str
|
||
adapter: str
|
||
adapter_config: dict # JSON
|
||
enable: bool
|
||
|
||
# 新增
|
||
event_handlers: list # JSON — 事件处理器配置列表
|
||
|
||
# 保留（过渡期后弃用）
|
||
use_pipeline_name: str # deprecated
|
||
use_pipeline_uuid: str # deprecated
|
||
|
||
created_at: datetime
|
||
updated_at: datetime
|
||
```
|
||
|
||
### 2.2 EventHandler 配置结构
|
||
|
||
`event_handlers` 字段存储一个 JSON 数组，每个元素定义一条事件路由规则：
|
||
|
||
```python
|
||
class EventHandlerConfig(pydantic.BaseModel):
|
||
"""单条事件处理器配置"""
|
||
|
||
event_type: str
|
||
"""匹配的事件类型
|
||
|
||
支持精确匹配和通配符：
|
||
- "message.received" — 精确匹配
|
||
- "message.*" — 匹配 message 命名空间下所有事件
|
||
- "group.*" — 匹配 group 命名空间下所有事件
|
||
- "*" — 匹配所有事件（兜底）
|
||
"""
|
||
|
||
handler_type: str
|
||
"""处理器类型: "pipeline" | "agent" | "webhook" | "plugin" """
|
||
|
||
handler_config: dict = {}
|
||
"""处理器的具体配置，结构取决于 handler_type"""
|
||
|
||
enabled: bool = True
|
||
"""是否启用此规则"""
|
||
|
||
priority: int = 0
|
||
"""优先级，数字越大越先匹配（同一事件类型有多条规则时）"""
|
||
|
||
description: str = ""
|
||
"""规则描述（供 WebUI 显示）"""
|
||
```
|
||
|
||
### 2.3 各 Handler 类型的 handler_config 结构
|
||
|
||
#### pipeline
|
||
|
||
```json
|
||
{
|
||
"handler_type": "pipeline",
|
||
"handler_config": {
|
||
"pipeline_uuid": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
|
||
}
|
||
}
|
||
```
|
||
|
||
将事件作为消息事件传入现有 Pipeline 流水线。仅适用于 `message.received` 事件。
|
||
|
||
#### agent
|
||
|
||
```json
|
||
{
|
||
"handler_type": "agent",
|
||
"handler_config": {
|
||
"runner": "local-agent",
|
||
"runner_config": {
|
||
"model_uuid": "...",
|
||
"prompt": "你是一个群组助理，请处理以下事件：{event_summary}",
|
||
"tools_enabled": true
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
```json
|
||
{
|
||
"handler_type": "agent",
|
||
"handler_config": {
|
||
"runner": "dify-service-api",
|
||
"runner_config": {
|
||
"base_url": "https://api.dify.ai/v1",
|
||
"api_key": "...",
|
||
"app_type": "agent"
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
直接调用 RequestRunner 处理事件。可用的 runner 包括：
|
||
- `local-agent` — 内置 LLM Agent
|
||
- `dify-service-api` — Dify 平台
|
||
- `n8n-service-api` — n8n 工作流
|
||
- `coze-api` — Coze (扣子)
|
||
- `dashscope-app-api` — 阿里百炼
|
||
- `langflow-api` — Langflow
|
||
- `tbox-app-api` — 蚂蚁 Tbox
|
||
|
||
Agent 处理器不经过 Pipeline 的多 Stage 流程，而是直接构建上下文并调用 Runner。适用于所有事件类型。
|
||
|
||
**Agent Handler 与 Pipeline 的关系**：
|
||
- Pipeline 是完整的多 Stage 处理链（PreProcessor → MessageProcessor(内含Runner) → PostProcessor → ...），适合复杂消息处理
|
||
- Agent Handler 是轻量级的，直接调用 Runner，跳过 PreProcessor/PostProcessor 等阶段
|
||
- Pipeline 内部的 AI Stage 仍然使用 Runner，所以 Runner 本身被两种 Handler 共享
|
||
- 用户可以根据场景选择：消息处理用 Pipeline（更多控制），其他事件用 Agent（更直接）
|
||
|
||
#### webhook
|
||
|
||
```json
|
||
{
|
||
"handler_type": "webhook",
|
||
"handler_config": {
|
||
"url": "https://example.com/webhook/langbot-events",
|
||
"method": "POST",
|
||
"headers": {
|
||
"Authorization": "Bearer xxx"
|
||
},
|
||
"timeout": 30,
|
||
"retry_count": 3,
|
||
"retry_interval": 5,
|
||
"response_actions": true
|
||
}
|
||
}
|
||
```
|
||
|
||
将事件序列化为 JSON POST 到外部 URL。支持的特性：
|
||
- **认证**：通过 headers 配置（Bearer Token、API Key 等）
|
||
- **重试**：配置重试次数和间隔
|
||
- **响应动作**：如果 `response_actions` 为 true，解析响应 JSON 中的 `actions` 字段并执行（如发送消息、同意好友请求等）
|
||
|
||
Webhook 请求体格式：
|
||
|
||
```json
|
||
{
|
||
"event": {
|
||
"type": "group.member_joined",
|
||
"timestamp": 1700000000.0,
|
||
"bot_uuid": "...",
|
||
"adapter_name": "telegram",
|
||
"group": { "id": "...", "name": "..." },
|
||
"member": { "id": "...", "nickname": "..." }
|
||
},
|
||
"bot": {
|
||
"uuid": "...",
|
||
"name": "...",
|
||
"adapter": "telegram"
|
||
}
|
||
}
|
||
```
|
||
|
||
响应体格式（当 `response_actions` 为 true 时）：
|
||
|
||
```json
|
||
{
|
||
"actions": [
|
||
{
|
||
"type": "send_message",
|
||
"params": {
|
||
"target_type": "group",
|
||
"target_id": "123456",
|
||
"message": [{ "type": "Plain", "text": "欢迎新成员！" }]
|
||
}
|
||
},
|
||
{
|
||
"type": "call_platform_api",
|
||
"params": {
|
||
"action": "pin_message",
|
||
"params": { "chat_id": "123456", "message_id": "789" }
|
||
}
|
||
}
|
||
]
|
||
}
|
||
```
|
||
|
||
#### plugin
|
||
|
||
```json
|
||
{
|
||
"handler_type": "plugin",
|
||
"handler_config": {
|
||
"plugin_filter": []
|
||
}
|
||
}
|
||
```
|
||
|
||
将事件分发给插件的 EventListener 处理。
|
||
|
||
- `plugin_filter`：可选的插件名过滤列表，为空表示分发给所有插件
|
||
- 沿用现有的插件事件分发机制（按优先级遍历插件，支持 `prevent_postorder`）
|
||
|
||
### 2.4 完整配置示例
|
||
|
||
一个 Bot 的 `event_handlers` 配置示例：
|
||
|
||
```json
|
||
[
|
||
{
|
||
"event_type": "message.received",
|
||
"handler_type": "pipeline",
|
||
"handler_config": {
|
||
"pipeline_uuid": "default-pipeline-uuid"
|
||
},
|
||
"enabled": true,
|
||
"priority": 10,
|
||
"description": "消息事件使用默认流水线处理"
|
||
},
|
||
{
|
||
"event_type": "group.member_joined",
|
||
"handler_type": "agent",
|
||
"handler_config": {
|
||
"runner": "local-agent",
|
||
"runner_config": {
|
||
"model_uuid": "gpt-4o-mini",
|
||
"prompt": "有新成员 {member_name} 加入了群组 {group_name}，请生成一条欢迎消息。"
|
||
}
|
||
},
|
||
"enabled": true,
|
||
"priority": 0,
|
||
"description": "新成员入群时用 AI 生成欢迎消息"
|
||
},
|
||
{
|
||
"event_type": "friend.request_received",
|
||
"handler_type": "webhook",
|
||
"handler_config": {
|
||
"url": "https://my-server.com/api/friend-request",
|
||
"response_actions": true
|
||
},
|
||
"enabled": true,
|
||
"priority": 0,
|
||
"description": "好友请求转发到自建服务处理"
|
||
},
|
||
{
|
||
"event_type": "*",
|
||
"handler_type": "plugin",
|
||
"handler_config": {},
|
||
"enabled": true,
|
||
"priority": -100,
|
||
"description": "所有事件兜底发给插件处理"
|
||
}
|
||
]
|
||
```
|
||
|
||
## 3. EventBus 设计
|
||
|
||
EventBus 是事件的中转站，接收来自各个 RuntimeBot 的事件，交由 EventRouter 处理。
|
||
|
||
```python
|
||
class EventBus:
|
||
"""事件总线"""
|
||
|
||
def __init__(self, ap: Application):
|
||
self.ap = ap
|
||
self.event_router = EventRouter(ap)
|
||
|
||
async def emit(
|
||
self,
|
||
event: Event,
|
||
adapter: AbstractPlatformAdapter,
|
||
):
|
||
"""接收并分发事件
|
||
|
||
Args:
|
||
event: 统一事件对象
|
||
adapter: 产生此事件的适配器实例
|
||
"""
|
||
# 1. 全局事件日志
|
||
self.ap.logger.debug(
|
||
f"EventBus: {event.type} from bot {event.bot_uuid}"
|
||
)
|
||
|
||
# 2. 交由 EventRouter 路由处理
|
||
await self.event_router.route(event, adapter)
|
||
```
|
||
|
||
## 4. EventRouter 设计
|
||
|
||
EventRouter 是事件路由引擎，根据 Bot 的 `event_handlers` 配置决定事件的处理方式。
|
||
|
||
```python
|
||
class EventRouter:
|
||
"""事件路由引擎"""
|
||
|
||
def __init__(self, ap: Application):
|
||
self.ap = ap
|
||
self.handlers: dict[str, AbstractEventHandler] = {
|
||
"pipeline": PipelineHandler(ap),
|
||
"agent": AgentHandler(ap),
|
||
"webhook": WebhookHandler(ap),
|
||
"plugin": PluginHandler(ap),
|
||
}
|
||
|
||
async def route(
|
||
self,
|
||
event: Event,
|
||
adapter: AbstractPlatformAdapter,
|
||
):
|
||
"""路由事件到对应处理器"""
|
||
|
||
# 1. 获取 Bot 配置
|
||
bot = await self.ap.platform_mgr.get_bot_by_uuid(event.bot_uuid)
|
||
if not bot:
|
||
return
|
||
|
||
# 2. 获取事件处理器配置
|
||
event_handlers = bot.bot_entity.event_handlers or []
|
||
|
||
# 3. 匹配规则（按 priority 降序排列）
|
||
matched_handlers = self._match_handlers(event.type, event_handlers)
|
||
|
||
if not matched_handlers:
|
||
# 未匹配到任何规则 → 默认交给插件处理（向后兼容）
|
||
await self.handlers["plugin"].handle(event, adapter, {})
|
||
return
|
||
|
||
# 4. 执行第一个匹配的 Handler
|
||
# （未来可扩展为多个 Handler 串行/并行执行）
|
||
handler_config = matched_handlers[0]
|
||
handler = self.handlers.get(handler_config.handler_type)
|
||
|
||
if handler:
|
||
await handler.handle(event, adapter, handler_config.handler_config)
|
||
else:
|
||
self.ap.logger.warning(
|
||
f"Unknown handler type: {handler_config.handler_type}"
|
||
)
|
||
|
||
def _match_handlers(
|
||
self,
|
||
event_type: str,
|
||
handlers: list[EventHandlerConfig],
|
||
) -> list[EventHandlerConfig]:
|
||
"""匹配事件类型到处理器配置
|
||
|
||
匹配规则：
|
||
1. 精确匹配：event_type == handler.event_type
|
||
2. 命名空间通配：handler.event_type 为 "message.*" 时匹配所有 "message.xxx"
|
||
3. 全局通配：handler.event_type 为 "*" 时匹配所有事件
|
||
4. 按 priority 降序排列
|
||
5. 只返回 enabled=True 的规则
|
||
"""
|
||
matched = []
|
||
for handler in handlers:
|
||
if not handler.enabled:
|
||
continue
|
||
if self._event_type_matches(event_type, handler.event_type):
|
||
matched.append(handler)
|
||
|
||
matched.sort(key=lambda h: h.priority, reverse=True)
|
||
return matched
|
||
|
||
@staticmethod
|
||
def _event_type_matches(event_type: str, pattern: str) -> bool:
|
||
"""判断事件类型是否匹配模式"""
|
||
if pattern == "*":
|
||
return True
|
||
if pattern == event_type:
|
||
return True
|
||
if pattern.endswith(".*"):
|
||
namespace = pattern[:-2]
|
||
return event_type.startswith(namespace + ".")
|
||
return False
|
||
```
|
||
|
||
## 5. 事件处理器（Handler）实现
|
||
|
||
### 5.1 Handler 基类
|
||
|
||
```python
|
||
class AbstractEventHandler(abc.ABC):
|
||
"""事件处理器基类"""
|
||
|
||
def __init__(self, ap: Application):
|
||
self.ap = ap
|
||
|
||
@abc.abstractmethod
|
||
async def handle(
|
||
self,
|
||
event: Event,
|
||
adapter: AbstractPlatformAdapter,
|
||
config: dict,
|
||
) -> None:
|
||
"""处理事件
|
||
|
||
Args:
|
||
event: 统一事件对象
|
||
adapter: 适配器实例（用于调用平台 API 发送响应）
|
||
config: handler_config 配置
|
||
"""
|
||
...
|
||
```
|
||
|
||
### 5.2 PipelineHandler
|
||
|
||
将消息事件注入现有 Pipeline 流水线处理。
|
||
|
||
```python
|
||
class PipelineHandler(AbstractEventHandler):
|
||
"""Pipeline 处理器 — 将事件送入现有 Pipeline 流水线"""
|
||
|
||
async def handle(self, event, adapter, config):
|
||
pipeline_uuid = config.get("pipeline_uuid")
|
||
|
||
if not isinstance(event, MessageReceivedEvent):
|
||
self.ap.logger.warning(
|
||
f"PipelineHandler only supports MessageReceivedEvent, "
|
||
f"got {event.type}"
|
||
)
|
||
return
|
||
|
||
# 将 MessageReceivedEvent 转换为现有的 Query 并投入 QueryPool
|
||
# 复用现有的 MessageAggregator + QueryPool + Pipeline 机制
|
||
launcher_type = (
|
||
LauncherTypes.PERSON
|
||
if event.chat_type == ChatType.PRIVATE
|
||
else LauncherTypes.GROUP
|
||
)
|
||
|
||
await self.ap.msg_aggregator.add_message(
|
||
bot_uuid=event.bot_uuid,
|
||
launcher_type=launcher_type,
|
||
launcher_id=event.chat_id,
|
||
sender_id=event.sender.id,
|
||
message_event=event.to_legacy_event(), # 转换为 FriendMessage/GroupMessage
|
||
message_chain=event.message_chain,
|
||
adapter=adapter,
|
||
pipeline_uuid=pipeline_uuid,
|
||
)
|
||
```
|
||
|
||
### 5.3 AgentHandler
|
||
|
||
直接调用 RequestRunner 处理事件，不经过 Pipeline Stage 链。
|
||
|
||
```python
|
||
class AgentHandler(AbstractEventHandler):
|
||
"""Agent 处理器 — 直接调用 RequestRunner 处理事件"""
|
||
|
||
async def handle(self, event, adapter, config):
|
||
runner_name = config.get("runner", "local-agent")
|
||
runner_config = config.get("runner_config", {})
|
||
|
||
# 1. 查找 Runner 类
|
||
runner_cls = None
|
||
for r in preregistered_runners:
|
||
if r.name == runner_name:
|
||
runner_cls = r
|
||
break
|
||
|
||
if not runner_cls:
|
||
self.ap.logger.error(f"Runner not found: {runner_name}")
|
||
return
|
||
|
||
# 2. 构建事件上下文（将事件信息整理为 Runner 可处理的格式）
|
||
event_context = self._build_event_context(event, runner_config)
|
||
|
||
# 3. 实例化并调用 Runner
|
||
runner = runner_cls(self.ap, self._build_runner_pipeline_config(config))
|
||
|
||
response_messages = []
|
||
async for result in runner.run(event_context):
|
||
response_messages.append(result)
|
||
|
||
# 4. 发送响应（如果 Runner 产生了回复）
|
||
if response_messages and isinstance(event, MessageReceivedEvent):
|
||
# 将 Runner 输出转换为 MessageChain 并回复
|
||
reply_chain = self._build_reply_chain(response_messages)
|
||
await adapter.reply_message(event, reply_chain)
|
||
|
||
def _build_event_context(self, event, runner_config):
|
||
"""将事件构建为 Runner 可处理的上下文
|
||
|
||
对于消息事件，直接使用消息内容。
|
||
对于其他事件，根据 runner_config 中的 prompt 模板生成描述文本。
|
||
"""
|
||
...
|
||
|
||
def _build_runner_pipeline_config(self, config):
|
||
"""将 handler_config 转换为 Runner 需要的 pipeline_config 格式"""
|
||
...
|
||
```
|
||
|
||
### 5.4 WebhookHandler
|
||
|
||
将事件 POST 到外部 URL。
|
||
|
||
```python
|
||
class WebhookHandler(AbstractEventHandler):
|
||
"""Webhook 处理器 — 将事件 POST 到外部 URL"""
|
||
|
||
async def handle(self, event, adapter, config):
|
||
url = config.get("url")
|
||
method = config.get("method", "POST")
|
||
headers = config.get("headers", {})
|
||
timeout = config.get("timeout", 30)
|
||
retry_count = config.get("retry_count", 3)
|
||
response_actions = config.get("response_actions", False)
|
||
|
||
# 1. 构建请求体
|
||
bot = await self.ap.platform_mgr.get_bot_by_uuid(event.bot_uuid)
|
||
payload = {
|
||
"event": event.model_dump(),
|
||
"bot": {
|
||
"uuid": bot.bot_entity.uuid,
|
||
"name": bot.bot_entity.name,
|
||
"adapter": bot.bot_entity.adapter,
|
||
}
|
||
}
|
||
|
||
# 2. 发送请求（带重试）
|
||
response = await self._send_with_retry(
|
||
url, method, headers, payload, timeout, retry_count
|
||
)
|
||
|
||
# 3. 处理响应动作
|
||
if response_actions and response:
|
||
await self._execute_response_actions(
|
||
response, adapter, event
|
||
)
|
||
|
||
async def _execute_response_actions(self, response, adapter, event):
|
||
"""执行响应中的动作列表"""
|
||
actions = response.get("actions", [])
|
||
for action in actions:
|
||
action_type = action.get("type")
|
||
params = action.get("params", {})
|
||
|
||
if action_type == "send_message":
|
||
chain = MessageChain.model_validate(params.get("message", []))
|
||
await adapter.send_message(
|
||
params["target_type"],
|
||
params["target_id"],
|
||
chain,
|
||
)
|
||
elif action_type == "reply":
|
||
chain = MessageChain.model_validate(params.get("message", []))
|
||
await adapter.reply_message(event, chain)
|
||
elif action_type == "call_platform_api":
|
||
await adapter.call_platform_api(
|
||
params["action"],
|
||
params.get("params", {}),
|
||
)
|
||
elif action_type == "approve_friend_request":
|
||
await adapter.approve_friend_request(
|
||
params["request_id"],
|
||
params.get("approve", True),
|
||
)
|
||
# ... 更多动作类型
|
||
```
|
||
|
||
### 5.5 PluginHandler
|
||
|
||
将事件分发给插件的 EventListener。
|
||
|
||
```python
|
||
class PluginHandler(AbstractEventHandler):
|
||
"""Plugin 处理器 — 分发给插件 EventListener"""
|
||
|
||
async def handle(self, event, adapter, config):
|
||
plugin_filter = config.get("plugin_filter", [])
|
||
|
||
# 复用现有的插件事件分发机制
|
||
# 通过 plugin_connector 将事件发送给 Plugin Runtime
|
||
await self.ap.plugin_connector.emit_event(
|
||
event=event,
|
||
adapter=adapter,
|
||
plugin_filter=plugin_filter,
|
||
)
|
||
```
|
||
|
||
## 6. use_pipeline_uuid 迁移
|
||
|
||
### 6.1 自动迁移
|
||
|
||
数据库迁移脚本将现有的 `use_pipeline_uuid` 自动转换为 `event_handlers`：
|
||
|
||
```python
|
||
# 迁移逻辑
|
||
for bot in all_bots:
|
||
if bot.use_pipeline_uuid and not bot.event_handlers:
|
||
bot.event_handlers = [
|
||
{
|
||
"event_type": "message.received",
|
||
"handler_type": "pipeline",
|
||
"handler_config": {
|
||
"pipeline_uuid": bot.use_pipeline_uuid
|
||
},
|
||
"enabled": True,
|
||
"priority": 10,
|
||
"description": "Auto-migrated from use_pipeline_uuid"
|
||
},
|
||
{
|
||
"event_type": "*",
|
||
"handler_type": "plugin",
|
||
"handler_config": {},
|
||
"enabled": True,
|
||
"priority": -100,
|
||
"description": "Default plugin handler"
|
||
}
|
||
]
|
||
```
|
||
|
||
### 6.2 过渡期兼容
|
||
|
||
在过渡期内，如果 `event_handlers` 为空且 `use_pipeline_uuid` 非空，EventRouter 自动回退到旧行为：
|
||
|
||
```python
|
||
# EventRouter.route() 中的兼容逻辑
|
||
if not event_handlers and bot.bot_entity.use_pipeline_uuid:
|
||
# 回退：消息事件走 Pipeline，其他事件走 Plugin
|
||
if isinstance(event, MessageReceivedEvent):
|
||
await self.handlers["pipeline"].handle(
|
||
event, adapter,
|
||
{"pipeline_uuid": bot.bot_entity.use_pipeline_uuid}
|
||
)
|
||
else:
|
||
await self.handlers["plugin"].handle(event, adapter, {})
|
||
return
|
||
```
|
||
|
||
## 7. WebUI 编排面板数据模型
|
||
|
||
### 7.1 交互设计概要
|
||
|
||
在 WebUI 的 Bot 管理页面，新增"事件处理器"标签页（或区域），呈现为一个**规则列表**：
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────┐
|
||
│ 事件处理器 [+ 添加规则] │
|
||
├─────────────────────────────────────────────────────────────┤
|
||
│ │
|
||
│ ┌─ 规则 1 ─────────────────────────────────── [启用] [删除] ─┐ │
|
||
│ │ 事件类型: [message.received ▾] │ │
|
||
│ │ 处理器: [Pipeline ▾] │ │
|
||
│ │ Pipeline: [默认流水线 ▾] │ │
|
||
│ │ 优先级: [10] │ │
|
||
│ │ 描述: 消息事件使用默认流水线处理 │ │
|
||
│ └──────────────────────────────────────────────────────────┘ │
|
||
│ │
|
||
│ ┌─ 规则 2 ─────────────────────────────────── [启用] [删除] ─┐ │
|
||
│ │ 事件类型: [group.member_joined ▾] │ │
|
||
│ │ 处理器: [Agent ▾] │ │
|
||
│ │ Runner: [local-agent ▾] │ │
|
||
│ │ 模型: [gpt-4o-mini ▾] │ │
|
||
│ │ Prompt: [有新成员加入...] │ │
|
||
│ │ 优先级: [0] │ │
|
||
│ └──────────────────────────────────────────────────────────┘ │
|
||
│ │
|
||
│ ┌─ 规则 3 (兜底) ──────────────────────────── [启用] [删除] ─┐ │
|
||
│ │ 事件类型: [* ▾] │ │
|
||
│ │ 处理器: [Plugin ▾] │ │
|
||
│ │ 优先级: [-100] │ │
|
||
│ └──────────────────────────────────────────────────────────┘ │
|
||
│ │
|
||
└─────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
### 7.2 前端数据结构
|
||
|
||
```typescript
|
||
interface EventHandlerRule {
|
||
event_type: string; // 下拉选择，选项从适配器 manifest 的 supported_events 获取
|
||
handler_type: string; // "pipeline" | "agent" | "webhook" | "plugin"
|
||
handler_config: Record<string, any>; // 根据 handler_type 动态渲染不同的配置表单
|
||
enabled: boolean;
|
||
priority: number;
|
||
description: string;
|
||
}
|
||
|
||
// Bot 编辑接口扩展
|
||
interface BotConfig {
|
||
uuid: string;
|
||
name: string;
|
||
adapter: string;
|
||
adapter_config: Record<string, any>;
|
||
enable: boolean;
|
||
event_handlers: EventHandlerRule[]; // 新增
|
||
}
|
||
```
|
||
|
||
### 7.3 事件类型下拉选项
|
||
|
||
从 Bot 关联的适配器 manifest 中获取 `supported_events`，加上通配符选项：
|
||
|
||
```
|
||
- message.received
|
||
- message.edited
|
||
- message.deleted
|
||
- message.reaction
|
||
- feedback.received
|
||
- group.member_joined
|
||
- group.member_left
|
||
- group.member_banned
|
||
- group.info_updated
|
||
- friend.request_received
|
||
- friend.added
|
||
- bot.invited_to_group
|
||
- bot.removed_from_group
|
||
- bot.muted
|
||
- bot.unmuted
|
||
- platform.specific
|
||
─────────────────
|
||
- message.* (所有消息事件)
|
||
- feedback.* (所有反馈事件)
|
||
- group.* (所有群组事件)
|
||
- friend.* (所有好友事件)
|
||
- bot.* (所有 Bot 事件)
|
||
- * (所有事件)
|
||
```
|
||
|
||
### 7.4 HTTP API
|
||
|
||
```
|
||
GET /api/v1/bots/{uuid}/event-handlers 获取 Bot 的事件处理器配置
|
||
PUT /api/v1/bots/{uuid}/event-handlers 更新 Bot 的事件处理器配置
|
||
GET /api/v1/adapters/{name}/supported-events 获取适配器支持的事件类型
|
||
GET /api/v1/adapters/{name}/supported-apis 获取适配器支持的 API
|
||
```
|