mirror of
https://github.com/langbot-app/LangBot.git
synced 2026-06-02 03:55:55 +00:00
d9378c3a88
* feat: Support WebSocket mode and enhance message processing capabilities * feat: add steam * feat: enhance QQOfficialClient and QQOfficialAdapter with improved logging and stream context management
560 lines
22 KiB
Python
560 lines
22 KiB
Python
from __future__ import annotations
|
||
import typing
|
||
import re
|
||
import asyncio
|
||
import traceback
|
||
|
||
import datetime
|
||
import time
|
||
|
||
import langbot_plugin.api.definition.abstract.platform.adapter as abstract_platform_adapter
|
||
import langbot_plugin.api.entities.builtin.platform.message as platform_message
|
||
import langbot_plugin.api.entities.builtin.platform.events as platform_events
|
||
import langbot_plugin.api.entities.builtin.platform.entities as platform_entities
|
||
from langbot.libs.qq_official_api.api import QQOfficialClient
|
||
from langbot.libs.qq_official_api.qqofficialevent import QQOfficialEvent
|
||
from ...utils import image
|
||
from ..logger import EventLogger
|
||
|
||
|
||
def _is_base64_data(value: str) -> bool:
|
||
"""Check if a string contains base64-encoded data rather than a URL."""
|
||
if not value:
|
||
return False
|
||
# data: URI scheme (e.g. data:image/png;base64,xxx)
|
||
if value.startswith('data:'):
|
||
return True
|
||
# Only treat as base64 if it doesn't look like a URL/path and has valid base64 chars
|
||
if value.startswith(('http://', 'https://', '/', './', '../')):
|
||
return False
|
||
# Check if it looks like base64 (only valid chars, reasonable length)
|
||
return bool(re.fullmatch(r'[A-Za-z0-9+/=\s]{20,}', value))
|
||
|
||
|
||
class QQOfficialMessageConverter(abstract_platform_adapter.AbstractMessageConverter):
|
||
@staticmethod
|
||
async def yiri2target(message_chain: platform_message.MessageChain):
|
||
"""将 LangBot 消息链转换为 QQ Official 消息格式列表。"""
|
||
content_list = []
|
||
for msg in message_chain:
|
||
if type(msg) is platform_message.Plain:
|
||
content_list.append(
|
||
{
|
||
'type': 'text',
|
||
'content': msg.text,
|
||
}
|
||
)
|
||
elif type(msg) is platform_message.Image:
|
||
url = msg.url if hasattr(msg, 'url') and msg.url else None
|
||
b64 = msg.base64 if hasattr(msg, 'base64') and msg.base64 else None
|
||
# Some plugins (e.g. MimoTTS) store base64 data in the url field
|
||
if url and not b64 and _is_base64_data(url):
|
||
b64 = url
|
||
url = None
|
||
content_list.append(
|
||
{
|
||
'type': 'image',
|
||
'url': url,
|
||
'base64': b64,
|
||
}
|
||
)
|
||
elif type(msg) is platform_message.Voice:
|
||
url = msg.url if hasattr(msg, 'url') and msg.url else None
|
||
b64 = msg.base64 if hasattr(msg, 'base64') and msg.base64 else None
|
||
# Some plugins (e.g. MimoTTS) store base64 data in the url field
|
||
if url and not b64 and _is_base64_data(url):
|
||
b64 = url
|
||
url = None
|
||
content_list.append(
|
||
{
|
||
'type': 'voice',
|
||
'url': url,
|
||
'base64': b64,
|
||
}
|
||
)
|
||
elif type(msg) is platform_message.File:
|
||
url = msg.url if hasattr(msg, 'url') and msg.url else None
|
||
b64 = msg.base64 if hasattr(msg, 'base64') and msg.base64 else None
|
||
# Some plugins store base64 data in the url field
|
||
if url and not b64 and _is_base64_data(url):
|
||
b64 = url
|
||
url = None
|
||
content_list.append(
|
||
{
|
||
'type': 'file',
|
||
'url': url,
|
||
'base64': b64,
|
||
'name': msg.name if hasattr(msg, 'name') else 'file',
|
||
}
|
||
)
|
||
|
||
return content_list
|
||
|
||
@staticmethod
|
||
async def target2yiri(message: str, message_id: str, pic_url: str, content_type):
|
||
yiri_msg_list = []
|
||
yiri_msg_list.append(platform_message.Source(id=message_id, time=datetime.datetime.now()))
|
||
if pic_url is not None:
|
||
base64_url = await image.get_qq_official_image_base64(pic_url=pic_url, content_type=content_type)
|
||
yiri_msg_list.append(platform_message.Image(base64=base64_url))
|
||
|
||
yiri_msg_list.append(platform_message.Plain(text=message))
|
||
chain = platform_message.MessageChain(yiri_msg_list)
|
||
return chain
|
||
|
||
|
||
class QQOfficialEventConverter(abstract_platform_adapter.AbstractEventConverter):
|
||
@staticmethod
|
||
async def yiri2target(event: platform_events.MessageEvent) -> QQOfficialEvent:
|
||
return event.source_platform_object
|
||
|
||
@staticmethod
|
||
async def target2yiri(event: QQOfficialEvent):
|
||
"""
|
||
QQ官方消息转换为LB对象
|
||
"""
|
||
yiri_chain = await QQOfficialMessageConverter.target2yiri(
|
||
message=event.content,
|
||
message_id=event.d_id,
|
||
pic_url=event.attachments,
|
||
content_type=event.content_type,
|
||
)
|
||
|
||
if event.t == 'C2C_MESSAGE_CREATE':
|
||
friend = platform_entities.Friend(
|
||
id=event.user_openid,
|
||
nickname=event.t,
|
||
remark='',
|
||
)
|
||
return platform_events.FriendMessage(
|
||
sender=friend,
|
||
message_chain=yiri_chain,
|
||
time=int(datetime.datetime.strptime(event.timestamp, '%Y-%m-%dT%H:%M:%S%z').timestamp()),
|
||
source_platform_object=event,
|
||
)
|
||
|
||
if event.t == 'DIRECT_MESSAGE_CREATE':
|
||
friend = platform_entities.Friend(
|
||
id=event.guild_id,
|
||
nickname=event.t,
|
||
remark='',
|
||
)
|
||
return platform_events.FriendMessage(sender=friend, message_chain=yiri_chain, source_platform_object=event)
|
||
if event.t == 'GROUP_AT_MESSAGE_CREATE':
|
||
yiri_chain.insert(0, platform_message.At(target='justbot'))
|
||
|
||
sender = platform_entities.GroupMember(
|
||
id=event.group_openid,
|
||
member_name=event.t,
|
||
permission='MEMBER',
|
||
group=platform_entities.Group(
|
||
id=event.group_openid,
|
||
name='MEMBER',
|
||
permission=platform_entities.Permission.Member,
|
||
),
|
||
special_title='',
|
||
)
|
||
time = int(datetime.datetime.strptime(event.timestamp, '%Y-%m-%dT%H:%M:%S%z').timestamp())
|
||
return platform_events.GroupMessage(
|
||
sender=sender,
|
||
message_chain=yiri_chain,
|
||
time=time,
|
||
source_platform_object=event,
|
||
)
|
||
if event.t == 'AT_MESSAGE_CREATE':
|
||
yiri_chain.insert(0, platform_message.At(target='justbot'))
|
||
sender = platform_entities.GroupMember(
|
||
id=event.channel_id,
|
||
member_name=event.t,
|
||
permission='MEMBER',
|
||
group=platform_entities.Group(
|
||
id=event.channel_id,
|
||
name='MEMBER',
|
||
permission=platform_entities.Permission.Member,
|
||
),
|
||
special_title='',
|
||
)
|
||
time = int(datetime.datetime.strptime(event.timestamp, '%Y-%m-%dT%H:%M:%S%z').timestamp())
|
||
return platform_events.GroupMessage(
|
||
sender=sender,
|
||
message_chain=yiri_chain,
|
||
time=time,
|
||
source_platform_object=event,
|
||
)
|
||
|
||
|
||
class QQOfficialAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
|
||
bot: QQOfficialClient
|
||
config: dict
|
||
bot_account_id: str
|
||
bot_uuid: str = None
|
||
enable_webhook: bool = False
|
||
message_converter: QQOfficialMessageConverter = QQOfficialMessageConverter()
|
||
event_converter: QQOfficialEventConverter = QQOfficialEventConverter()
|
||
|
||
def __init__(self, config: dict, logger: EventLogger):
|
||
enable_webhook = config.get('enable-webhook', False)
|
||
|
||
bot = QQOfficialClient(
|
||
app_id=config['appid'],
|
||
secret=config['secret'],
|
||
token=config['token'],
|
||
logger=logger,
|
||
unified_mode=enable_webhook,
|
||
)
|
||
|
||
super().__init__(
|
||
config=config,
|
||
logger=logger,
|
||
bot=bot,
|
||
bot_account_id=config['appid'],
|
||
)
|
||
|
||
self.enable_webhook = enable_webhook
|
||
self._ws_task: asyncio.Task = None
|
||
self._stream_ctx: dict = {}
|
||
self._stream_ctx_ts: dict[str, float] = {}
|
||
self._fallback_text: dict[str, str] = {}
|
||
self._fallback_text_ts: dict[str, float] = {}
|
||
|
||
async def reply_message(
|
||
self,
|
||
message_source: platform_events.MessageEvent,
|
||
message: platform_message.MessageChain,
|
||
quote_origin: bool = False,
|
||
):
|
||
qq_official_event = await QQOfficialEventConverter.yiri2target(
|
||
message_source,
|
||
)
|
||
|
||
content_list = await QQOfficialMessageConverter.yiri2target(message)
|
||
|
||
# 确定 target_type 和 target_id
|
||
target_type = None
|
||
target_id = None
|
||
|
||
if qq_official_event.t == 'C2C_MESSAGE_CREATE':
|
||
target_type = 'c2c'
|
||
target_id = qq_official_event.user_openid
|
||
elif qq_official_event.t == 'GROUP_AT_MESSAGE_CREATE':
|
||
target_type = 'group'
|
||
target_id = qq_official_event.group_openid
|
||
elif qq_official_event.t == 'AT_MESSAGE_CREATE':
|
||
# 频道群聊使用频道 API，暂不支持富媒体
|
||
for content in content_list:
|
||
if content['type'] == 'text':
|
||
await self.bot.send_channle_group_text_msg(
|
||
qq_official_event.channel_id,
|
||
content['content'],
|
||
qq_official_event.d_id,
|
||
)
|
||
return
|
||
elif qq_official_event.t == 'DIRECT_MESSAGE_CREATE':
|
||
# 频道私聊使用频道 API，暂不支持富媒体
|
||
for content in content_list:
|
||
if content['type'] == 'text':
|
||
await self.bot.send_channle_private_text_msg(
|
||
qq_official_event.guild_id,
|
||
content['content'],
|
||
qq_official_event.d_id,
|
||
)
|
||
return
|
||
|
||
# C2C 和群聊：支持文字 + 富媒体
|
||
for content in content_list:
|
||
content_type = content.get('type', 'text')
|
||
|
||
if content_type == 'text':
|
||
if target_type == 'c2c':
|
||
await self.bot.send_private_text_msg(
|
||
target_id,
|
||
content['content'],
|
||
qq_official_event.d_id,
|
||
)
|
||
elif target_type == 'group':
|
||
await self.bot.send_group_text_msg(
|
||
target_id,
|
||
content['content'],
|
||
qq_official_event.d_id,
|
||
)
|
||
|
||
elif content_type == 'image':
|
||
file_url = content.get('url')
|
||
file_data = content.get('base64')
|
||
if file_url or file_data:
|
||
await self.bot.send_image_msg(
|
||
target_type,
|
||
target_id,
|
||
file_url=file_url,
|
||
file_data=file_data,
|
||
msg_id=qq_official_event.d_id,
|
||
)
|
||
|
||
elif content_type == 'voice':
|
||
file_url = content.get('url')
|
||
file_data = content.get('base64')
|
||
if file_url or file_data:
|
||
await self.bot.send_voice_msg(
|
||
target_type,
|
||
target_id,
|
||
file_url=file_url,
|
||
file_data=file_data,
|
||
msg_id=qq_official_event.d_id,
|
||
)
|
||
|
||
elif content_type == 'file':
|
||
file_url = content.get('url')
|
||
file_data = content.get('base64')
|
||
file_name = content.get('name', 'file')
|
||
if file_url or file_data:
|
||
await self.bot.send_file_msg(
|
||
target_type,
|
||
target_id,
|
||
file_url=file_url,
|
||
file_data=file_data,
|
||
file_name=file_name,
|
||
msg_id=qq_official_event.d_id,
|
||
)
|
||
|
||
async def send_message(self, target_type: str, target_id: str, message: platform_message.MessageChain):
|
||
pass
|
||
|
||
def register_listener(
|
||
self,
|
||
event_type: typing.Type[platform_events.Event],
|
||
callback: typing.Callable[
|
||
[platform_events.Event, abstract_platform_adapter.AbstractMessagePlatformAdapter], None
|
||
],
|
||
):
|
||
async def on_message(event: QQOfficialEvent):
|
||
self.bot_account_id = 'justbot'
|
||
try:
|
||
return await callback(await self.event_converter.target2yiri(event), self)
|
||
except Exception:
|
||
await self.logger.error(f'Error in qqofficial callback: {traceback.format_exc()}')
|
||
|
||
if event_type == platform_events.FriendMessage:
|
||
self.bot.on_message('DIRECT_MESSAGE_CREATE')(on_message)
|
||
self.bot.on_message('C2C_MESSAGE_CREATE')(on_message)
|
||
elif event_type == platform_events.GroupMessage:
|
||
self.bot.on_message('GROUP_AT_MESSAGE_CREATE')(on_message)
|
||
self.bot.on_message('AT_MESSAGE_CREATE')(on_message)
|
||
|
||
def set_bot_uuid(self, bot_uuid: str):
|
||
"""设置 bot UUID（用于生成 webhook URL）"""
|
||
self.bot_uuid = bot_uuid
|
||
|
||
async def handle_unified_webhook(self, bot_uuid: str, path: str, request):
|
||
"""处理统一 webhook 请求。
|
||
|
||
Args:
|
||
bot_uuid: Bot 的 UUID
|
||
path: 子路径（如果有的话）
|
||
request: Quart Request 对象
|
||
|
||
Returns:
|
||
响应数据
|
||
"""
|
||
return await self.bot.handle_unified_webhook(request)
|
||
|
||
async def run_async(self):
|
||
if not self.enable_webhook:
|
||
await self._run_websocket()
|
||
else:
|
||
# 统一 webhook 模式下，不启动独立的 Quart 应用
|
||
async def keep_alive():
|
||
while True:
|
||
await asyncio.sleep(1)
|
||
|
||
await keep_alive()
|
||
|
||
async def _run_websocket(self):
|
||
"""以 WebSocket 模式运行网关连接"""
|
||
await self.logger.info('QQ Official adapter starting in WebSocket mode')
|
||
|
||
async def on_ready():
|
||
await self.logger.info('QQ Official WebSocket connected and ready')
|
||
|
||
async def on_event(event_type: str, event_data: dict):
|
||
# 只处理消息事件，忽略 READY/RESUMED 等系统事件
|
||
message_event_types = {
|
||
'C2C_MESSAGE_CREATE',
|
||
'DIRECT_MESSAGE_CREATE',
|
||
'GROUP_AT_MESSAGE_CREATE',
|
||
'AT_MESSAGE_CREATE',
|
||
}
|
||
if event_type not in message_event_types:
|
||
return
|
||
if not isinstance(event_data, dict):
|
||
await self.logger.warning(f'Event data is not dict, skipping: {event_type} -> {type(event_data)}')
|
||
return
|
||
await self.logger.info(f'Processing message event: {event_type}')
|
||
# 构造与 webhook 模式相同的 payload 结构
|
||
payload = {'t': event_type, 'd': event_data}
|
||
message_data = await self.bot.get_message(payload)
|
||
if message_data:
|
||
event = QQOfficialEvent.from_payload(message_data)
|
||
await self.bot._handle_message(event)
|
||
|
||
async def on_error(error: Exception):
|
||
await self.logger.error(f'WebSocket error: {error}')
|
||
await self.logger.error(f'QQ Official WebSocket error: {error}')
|
||
|
||
self._ws_task = asyncio.create_task(self.bot.connect_gateway_loop(on_event, on_ready, on_error))
|
||
try:
|
||
await self._ws_task
|
||
except asyncio.CancelledError:
|
||
pass
|
||
|
||
async def kill(self) -> bool:
|
||
if self._ws_task:
|
||
self._ws_task.cancel()
|
||
try:
|
||
await self._ws_task
|
||
except asyncio.CancelledError:
|
||
pass
|
||
self._ws_task = None
|
||
return True
|
||
|
||
# --------------- 流式输出 ---------------
|
||
|
||
_STREAM_CTX_TTL = 300 # seconds
|
||
|
||
async def _cleanup_stale_streams(self):
|
||
"""Remove stream contexts that have not been updated for more than _STREAM_CTX_TTL seconds."""
|
||
now = time.time()
|
||
stale_ids = [mid for mid, ts in self._stream_ctx_ts.items() if now - ts > self._STREAM_CTX_TTL]
|
||
for mid in stale_ids:
|
||
self._stream_ctx.pop(mid, None)
|
||
self._stream_ctx_ts.pop(mid, None)
|
||
stale_fb = [mid for mid, ts in self._fallback_text_ts.items() if now - ts > self._STREAM_CTX_TTL]
|
||
for mid in stale_fb:
|
||
self._fallback_text.pop(mid, None)
|
||
self._fallback_text_ts.pop(mid, None)
|
||
if stale_ids or stale_fb:
|
||
await self.logger.debug(f'Cleaned up {len(stale_ids)} stream contexts, {len(stale_fb)} fallback texts')
|
||
|
||
async def is_stream_output_supported(self) -> bool:
|
||
return self.config.get('enable-stream-reply', False)
|
||
|
||
async def create_message_card(self, message_id: str, event: platform_events.MessageEvent) -> bool:
|
||
source = event.source_platform_object
|
||
# Streaming API only supports C2C private chat
|
||
if source.t != 'C2C_MESSAGE_CREATE':
|
||
return False
|
||
|
||
ctx = {
|
||
'user_openid': source.user_openid,
|
||
'msg_id': source.d_id,
|
||
'stream_msg_id': None,
|
||
'msg_seq': 1,
|
||
'index': 0,
|
||
'last_update_ts': 0,
|
||
'accumulated_text': '',
|
||
'sent_length': 0,
|
||
'session_started': False,
|
||
}
|
||
|
||
self._stream_ctx[message_id] = ctx
|
||
self._stream_ctx_ts[message_id] = time.time()
|
||
return True
|
||
|
||
async def reply_message_chunk(
|
||
self,
|
||
message_source: platform_events.MessageEvent,
|
||
bot_message: dict,
|
||
message: platform_message.MessageChain,
|
||
quote_origin: bool = False,
|
||
is_final: bool = False,
|
||
):
|
||
# Periodically clean up stale stream contexts
|
||
await self._cleanup_stale_streams()
|
||
# 提取纯文本内容（当前 chunk 的文本）
|
||
text_parts = []
|
||
for msg in message:
|
||
if type(msg) is platform_message.Plain:
|
||
text_parts.append(msg.text)
|
||
chunk_text = '\n\n'.join(text_parts)
|
||
|
||
message_id = (
|
||
bot_message.get('resp_message_id')
|
||
if isinstance(bot_message, dict)
|
||
else getattr(bot_message, 'resp_message_id', None)
|
||
)
|
||
if not message_id or message_id not in self._stream_ctx:
|
||
# 非流式场景（如群聊不支持流式），累积文本后一次性回复
|
||
if chunk_text:
|
||
self._fallback_text[message_id] = self._fallback_text.get(message_id, '') + chunk_text
|
||
self._fallback_text_ts[message_id] = time.time()
|
||
if is_final:
|
||
full_text = self._fallback_text.pop(message_id, '')
|
||
if full_text:
|
||
fallback_msg = platform_message.MessageChain([platform_message.Plain(text=full_text)])
|
||
await self.reply_message(message_source, fallback_msg, quote_origin)
|
||
return
|
||
|
||
ctx = self._stream_ctx[message_id]
|
||
|
||
# 累积文本
|
||
if chunk_text:
|
||
ctx['accumulated_text'] += chunk_text
|
||
|
||
# 未启动会话时，等第一个有内容的 chunk 来建立会话
|
||
if not ctx['session_started']:
|
||
if not ctx['accumulated_text']:
|
||
return
|
||
# 用第一个 chunk 的文本建立会话（不发 "..." 避免污染前缀）
|
||
ctx['session_started'] = True
|
||
|
||
# 发送内容 = 全量累积文本
|
||
# QQ API 的 replace 模式不允许修改已下发前缀，所以：
|
||
# - 首次：发送全部文本，建立会话
|
||
# - 后续：只能发送新增部分（append 行为）
|
||
content_to_send = ctx['accumulated_text'][ctx['sent_length'] :]
|
||
if not content_to_send and not is_final:
|
||
return
|
||
|
||
input_state = 10 if is_final else 1
|
||
|
||
# Rate limiting: skip non-final updates if last update was <0.5s ago
|
||
now = time.time()
|
||
if not is_final and (now - ctx['last_update_ts']) < 0.5:
|
||
return
|
||
ctx['last_update_ts'] = now
|
||
|
||
try:
|
||
resp = await self.bot.send_stream_msg(
|
||
user_openid=ctx['user_openid'],
|
||
content=content_to_send,
|
||
event_id=ctx['msg_id'],
|
||
msg_id=ctx['msg_id'],
|
||
msg_seq=ctx['msg_seq'],
|
||
index=ctx['index'],
|
||
stream_msg_id=ctx['stream_msg_id'],
|
||
input_state=input_state,
|
||
)
|
||
if resp and isinstance(resp, dict):
|
||
new_stream_id = resp.get('id')
|
||
if new_stream_id:
|
||
ctx['stream_msg_id'] = new_stream_id
|
||
ctx['sent_length'] = len(ctx['accumulated_text'])
|
||
ctx['index'] += 1
|
||
await self.logger.debug(
|
||
f'[QQ Official] 流式 chunk 已发送, index={ctx["index"]}, '
|
||
f'sent_len={ctx["sent_length"]}, is_final={is_final}'
|
||
)
|
||
except Exception as e:
|
||
await self.logger.error(f'Failed to send stream message: {e}')
|
||
|
||
if is_final:
|
||
self._stream_ctx.pop(message_id, None)
|
||
|
||
def unregister_listener(
|
||
self,
|
||
event_type: type,
|
||
callback: typing.Callable[
|
||
[platform_events.Event, abstract_platform_adapter.AbstractMessagePlatformAdapter], None
|
||
],
|
||
):
|
||
return super().unregister_listener(event_type, callback)
|