AstrBot 4.7.4__py3-none-any.whl → 4.8.0__py3-none-any.whl

astrbot/core/platform/sources/qqofficial_webhook/qo_webhook_adapter.py

@@ -1,5 +1,6 @@
 import asyncio
 import logging
+from typing import Any
 
 import botpy
 import botpy.message
@@ -11,6 +12,7 @@ from astrbot import logger
 from astrbot.api.event import MessageChain
 from astrbot.api.platform import AstrBotMessage, MessageType, Platform, PlatformMetadata
 from astrbot.core.platform.astr_message_event import MessageSesion
+from astrbot.core.utils.webhook_utils import log_webhook_info
 
 from ...register import register_platform_adapter
 from ..qqofficial.qqofficial_platform_adapter import QQOfficialPlatformAdapter
@@ -87,13 +89,12 @@ class QQOfficialWebhookPlatformAdapter(Platform):
         platform_settings: dict,
         event_queue: asyncio.Queue,
     ) -> None:
-        super().__init__(event_queue)
-
-        self.config = platform_config
+        super().__init__(platform_config, event_queue)
 
         self.appid = platform_config["appid"]
         self.secret = platform_config["secret"]
         self.unique_session = platform_settings["unique_session"]
+        self.unified_webhook_mode = platform_config.get("unified_webhook_mode", False)
 
         intents = botpy.Intents(
             public_messages=True,
@@ -106,6 +107,7 @@ class QQOfficialWebhookPlatformAdapter(Platform):
             timeout=20,
         )
         self.client.set_platform(self)
+        self.webhook_helper = None
 
     async def send_by_session(
         self,
@@ -128,16 +130,37 @@ class QQOfficialWebhookPlatformAdapter(Platform):
             self.client,
         )
         await self.webhook_helper.initialize()
-        await self.webhook_helper.start_polling()
+
+        # 如果启用统一 webhook 模式，则不启动独立服务器
+        webhook_uuid = self.config.get("webhook_uuid")
+        if self.unified_webhook_mode and webhook_uuid:
+            log_webhook_info(f"{self.meta().id}(QQ 官方机器人 Webhook)", webhook_uuid)
+            # 保持运行状态，等待 shutdown
+            await self.webhook_helper.shutdown_event.wait()
+        else:
+            await self.webhook_helper.start_polling()
 
     def get_client(self) -> botClient:
         return self.client
 
+    async def webhook_callback(self, request: Any) -> Any:
+        """统一 Webhook 回调入口"""
+        if not self.webhook_helper:
+            return {"error": "Webhook helper not initialized"}, 500
+
+        # 复用 webhook_helper 的回调处理逻辑
+        return await self.webhook_helper.handle_callback(request)
+
     async def terminate(self):
-        self.webhook_helper.shutdown_event.set()
+        if self.webhook_helper:
+            self.webhook_helper.shutdown_event.set()
         await self.client.close()
-        try:
-            await self.webhook_helper.server.shutdown()
-        except Exception as _:
-            pass
+        if self.webhook_helper and not self.unified_webhook_mode:
+            try:
+                await self.webhook_helper.server.shutdown()
+            except Exception as exc:
+                logger.warning(
+                    f"Exception occurred during QQOfficialWebhook server shutdown: {exc}",
+                    exc_info=True,
+                )
         logger.info("QQ 机器人官方 API 适配器已经被优雅地关闭")

astrbot/core/platform/sources/qqofficial_webhook/qo_webhook_server.py

@@ -78,7 +78,19 @@ class QQOfficialWebhook:
         return response
 
     async def callback(self):
-        msg: dict = await quart.request.json
+        """内部服务器的回调入口"""
+        return await self.handle_callback(quart.request)
+
+    async def handle_callback(self, request) -> dict:
+        """处理 webhook 回调，可被统一 webhook 入口复用
+
+        Args:
+            request: Quart 请求对象
+
+        Returns:
+            响应数据
+        """
+        msg: dict = await request.json
         logger.debug(f"收到 qq_official_webhook 回调: {msg}")
 
         event = msg.get("t")

astrbot/core/platform/sources/satori/satori_adapter.py

@@ -38,8 +38,7 @@ class SatoriPlatformAdapter(Platform):
         platform_settings: dict,
         event_queue: asyncio.Queue,
     ) -> None:
-        super().__init__(event_queue)
-        self.config = platform_config
+        super().__init__(platform_config, event_queue)
         self.settings = platform_settings
 
         self.api_base_url = self.config.get(

astrbot/core/platform/sources/slack/client.py

@@ -47,51 +47,62 @@ class SlackWebhookClient:
 
         @self.app.route(self.path, methods=["POST"])
         async def slack_events():
-            """处理 Slack 事件"""
-            try:
-                # 获取请求体和头部
-                body = await request.get_data()
-                event_data = json.loads(body.decode("utf-8"))
-
-                # Verify Slack request signature
-                timestamp = request.headers.get("X-Slack-Request-Timestamp")
-                signature = request.headers.get("X-Slack-Signature")
-                if not timestamp or not signature:
-                    return Response("Missing headers", status=400)
-                # Calculate the HMAC signature
-                sig_basestring = f"v0:{timestamp}:{body.decode('utf-8')}"
-                my_signature = (
-                    "v0="
-                    + hmac.new(
-                        self.signing_secret.encode("utf-8"),
-                        sig_basestring.encode("utf-8"),
-                        hashlib.sha256,
-                    ).hexdigest()
-                )
-                # Verify the signature
-                if not hmac.compare_digest(my_signature, signature):
-                    logger.warning("Slack request signature verification failed")
-                    return Response("Invalid signature", status=400)
-                logger.info(f"Received Slack event: {event_data}")
-
-                # 处理 URL 验证事件
-                if event_data.get("type") == "url_verification":
-                    return {"challenge": event_data.get("challenge")}
-                # 处理事件
-                if self.event_handler and event_data.get("type") == "event_callback":
-                    await self.event_handler(event_data)
-
-                return Response("", status=200)
-
-            except Exception as e:
-                logger.error(f"处理 Slack 事件时出错: {e}")
-                return Response("Internal Server Error", status=500)
+            """内部服务器的 POST 回调入口"""
+            return await self.handle_callback(request)
 
         @self.app.route("/health", methods=["GET"])
         async def health_check():
             """健康检查端点"""
             return {"status": "ok", "service": "slack-webhook"}
 
+    async def handle_callback(self, req):
+        """处理 Slack 回调请求，可被统一 webhook 入口复用
+
+        Args:
+            req: Quart 请求对象
+
+        Returns:
+            Response 对象或字典
+        """
+        try:
+            # 获取请求体和头部
+            body = await req.get_data()
+            event_data = json.loads(body.decode("utf-8"))
+
+            # Verify Slack request signature
+            timestamp = req.headers.get("X-Slack-Request-Timestamp")
+            signature = req.headers.get("X-Slack-Signature")
+            if not timestamp or not signature:
+                return Response("Missing headers", status=400)
+            # Calculate the HMAC signature
+            sig_basestring = f"v0:{timestamp}:{body.decode('utf-8')}"
+            my_signature = (
+                "v0="
+                + hmac.new(
+                    self.signing_secret.encode("utf-8"),
+                    sig_basestring.encode("utf-8"),
+                    hashlib.sha256,
+                ).hexdigest()
+            )
+            # Verify the signature
+            if not hmac.compare_digest(my_signature, signature):
+                logger.warning("Slack request signature verification failed")
+                return Response("Invalid signature", status=400)
+            logger.info(f"Received Slack event: {event_data}")
+
+            # 处理 URL 验证事件
+            if event_data.get("type") == "url_verification":
+                return {"challenge": event_data.get("challenge")}
+            # 处理事件
+            if self.event_handler and event_data.get("type") == "event_callback":
+                await self.event_handler(event_data)
+
+            return Response("", status=200)
+
+        except Exception as e:
+            logger.error(f"处理 Slack 事件时出错: {e}")
+            return Response("Internal Server Error", status=500)
+
     async def start(self):
         """启动 Webhook 服务器"""
         logger.info(

astrbot/core/platform/sources/slack/slack_adapter.py

@@ -21,6 +21,7 @@ from astrbot.api.platform import (
     PlatformMetadata,
 )
 from astrbot.core.platform.astr_message_event import MessageSesion
+from astrbot.core.utils.webhook_utils import log_webhook_info
 
 from ...register import register_platform_adapter
 from .client import SlackSocketClient, SlackWebhookClient
@@ -39,9 +40,7 @@ class SlackAdapter(Platform):
         platform_settings: dict,
         event_queue: asyncio.Queue,
     ) -> None:
-        super().__init__(event_queue)
-
-        self.config = platform_config
+        super().__init__(platform_config, event_queue)
         self.settings = platform_settings
         self.unique_session = platform_settings.get("unique_session", False)
 
@@ -49,6 +48,7 @@ class SlackAdapter(Platform):
         self.app_token = platform_config.get("app_token")
         self.signing_secret = platform_config.get("signing_secret")
         self.connection_mode = platform_config.get("slack_connection_mode", "socket")
+        self.unified_webhook_mode = platform_config.get("unified_webhook_mode", False)
         self.webhook_host = platform_config.get("slack_webhook_host", "0.0.0.0")
         self.webhook_port = platform_config.get("slack_webhook_port", 3000)
         self.webhook_path = platform_config.get(
@@ -361,10 +361,17 @@ class SlackAdapter(Platform):
                 self._handle_webhook_event,
             )
 
-            logger.info(
-                f"Slack 适配器 (Webhook Mode) 启动中，监听 {self.webhook_host}:{self.webhook_port}{self.webhook_path}...",
-            )
-            await self.webhook_client.start()
+            # 如果启用统一 webhook 模式，则不启动独立服务器
+            webhook_uuid = self.config.get("webhook_uuid")
+            if self.unified_webhook_mode and webhook_uuid:
+                log_webhook_info(f"{self.meta().id}(Slack)", webhook_uuid)
+                # 保持运行状态，等待 shutdown
+                await self.webhook_client.shutdown_event.wait()
+            else:
+                logger.info(
+                    f"Slack 适配器 (Webhook Mode) 启动中，监听 {self.webhook_host}:{self.webhook_port}{self.webhook_path}...",
+                )
+                await self.webhook_client.start()
 
         else:
             raise ValueError(
@@ -391,6 +398,13 @@ class SlackAdapter(Platform):
             if abm:
                 await self.handle_msg(abm)
 
+    async def webhook_callback(self, request: Any) -> Any:
+        """统一 Webhook 回调入口"""
+        if self.connection_mode != "webhook" or not self.webhook_client:
+            return {"error": "Slack adapter is not in webhook mode"}, 400
+
+        return await self.webhook_client.handle_callback(request)
+
     async def terminate(self):
         if self.socket_client:
             await self.socket_client.stop()

astrbot/core/platform/sources/slack/slack_event.py

@@ -31,7 +31,7 @@ class SlackMessageEvent(AstrMessageEvent):
     async def _from_segment_to_slack_block(
         segment: BaseMessageComponent,
         web_client: AsyncWebClient,
-    ) -> dict:
+    ) -> dict | None:
         """将消息段转换为 Slack 块格式"""
         if isinstance(segment, Plain):
             return {"type": "section", "text": {"type": "mrkdwn", "text": segment.text}}
@@ -85,7 +85,6 @@ class SlackMessageEvent(AstrMessageEvent):
                     "text": f"文件: <{file_url}|{segment.name or '文件'}>",
                 },
             }
-        return {"type": "section", "text": {"type": "mrkdwn", "text": str(segment)}}
 
     @staticmethod
     async def _parse_slack_blocks(
@@ -115,7 +114,8 @@ class SlackMessageEvent(AstrMessageEvent):
                     segment,
                     web_client,
                 )
-                blocks.append(block)
+                if block:
+                    blocks.append(block)
 
         # 如果最后还有文本内容
         if text_content.strip():

astrbot/core/platform/sources/telegram/tg_adapter.py

@@ -42,8 +42,7 @@ class TelegramPlatformAdapter(Platform):
         platform_settings: dict,
         event_queue: asyncio.Queue,
     ) -> None:
-        super().__init__(event_queue)
-        self.config = platform_config
+        super().__init__(platform_config, event_queue)
         self.settings = platform_settings
         self.client_self_id = uuid.uuid4().hex[:8]
 

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

@@ -6,7 +6,9 @@ from collections.abc import Awaitable, Callable
 from typing import Any
 
 from astrbot import logger
-from astrbot.core.message.components import Image, Plain, Record
+from astrbot.core import db_helper
+from astrbot.core.db.po import PlatformMessageHistory
+from astrbot.core.message.components import File, Image, Plain, Record, Reply, Video
 from astrbot.core.message.message_event_result import MessageChain
 from astrbot.core.platform import (
     AstrBotMessage,
@@ -74,9 +76,8 @@ class WebChatAdapter(Platform):
         platform_settings: dict,
         event_queue: asyncio.Queue,
     ) -> None:
-        super().__init__(event_queue)
+        super().__init__(platform_config, event_queue)
 
-        self.config = platform_config
         self.settings = platform_settings
         self.unique_session = platform_settings["unique_session"]
         self.imgs_dir = os.path.join(get_astrbot_data_path(), "webchat", "imgs")
@@ -96,6 +97,92 @@ class WebChatAdapter(Platform):
         await WebChatMessageEvent._send(message_chain, session.session_id)
         await super().send_by_session(session, message_chain)
 
+    async def _get_message_history(
+        self, message_id: int
+    ) -> PlatformMessageHistory | None:
+        return await db_helper.get_platform_message_history_by_id(message_id)
+
+    async def _parse_message_parts(
+        self,
+        message_parts: list,
+        depth: int = 0,
+        max_depth: int = 1,
+    ) -> tuple[list, list[str]]:
+        """解析消息段列表，返回消息组件列表和纯文本列表
+
+        Args:
+            message_parts: 消息段列表
+            depth: 当前递归深度
+            max_depth: 最大递归深度（用于处理 reply）
+
+        Returns:
+            tuple[list, list[str]]: (消息组件列表, 纯文本列表)
+        """
+        components = []
+        text_parts = []
+
+        for part in message_parts:
+            part_type = part.get("type")
+            if part_type == "plain":
+                text = part.get("text", "")
+                components.append(Plain(text))
+                text_parts.append(text)
+            elif part_type == "reply":
+                message_id = part.get("message_id")
+                reply_chain = []
+                reply_message_str = ""
+                sender_id = None
+                sender_name = None
+
+                # recursively get the content of the referenced message
+                if depth < max_depth and message_id:
+                    history = await self._get_message_history(message_id)
+                    if history and history.content:
+                        reply_parts = history.content.get("message", [])
+                        if isinstance(reply_parts, list):
+                            (
+                                reply_chain,
+                                reply_text_parts,
+                            ) = await self._parse_message_parts(
+                                reply_parts,
+                                depth=depth + 1,
+                                max_depth=max_depth,
+                            )
+                            reply_message_str = "".join(reply_text_parts)
+                        sender_id = history.sender_id
+                        sender_name = history.sender_name
+
+                components.append(
+                    Reply(
+                        id=message_id,
+                        chain=reply_chain,
+                        message_str=reply_message_str,
+                        sender_id=sender_id,
+                        sender_nickname=sender_name,
+                    )
+                )
+            elif part_type == "image":
+                path = part.get("path")
+                if path:
+                    components.append(Image.fromFileSystem(path))
+            elif part_type == "record":
+                path = part.get("path")
+                if path:
+                    components.append(Record.fromFileSystem(path))
+            elif part_type == "file":
+                path = part.get("path")
+                if path:
+                    filename = part.get("filename") or (
+                        os.path.basename(path) if path else "file"
+                    )
+                    components.append(File(name=filename, file=path))
+            elif part_type == "video":
+                path = part.get("path")
+                if path:
+                    components.append(Video.fromFileSystem(path))
+
+        return components, text_parts
+
     async def convert_message(self, data: tuple) -> AstrBotMessage:
         username, cid, payload = data
 
@@ -108,36 +195,15 @@ class WebChatAdapter(Platform):
         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"]),
-                    ),
-                )
-        if payload["audio_url"]:
-            if isinstance(payload["audio_url"], list):
-                for audio in payload["audio_url"]:
-                    path = os.path.join(self.imgs_dir, audio)
-                    abm.message.append(Record(file=path, path=path))
-            else:
-                path = os.path.join(self.imgs_dir, payload["audio_url"])
-                abm.message.append(Record(file=path, path=path))
+
+        # 处理消息段列表
+        message_parts = payload.get("message", [])
+        abm.message, message_str_parts = await self._parse_message_parts(message_parts)
 
         logger.debug(f"WebChatAdapter: {abm.message}")
 
-        message_str = payload["message"]
         abm.timestamp = int(time.time())
-        abm.message_str = message_str
+        abm.message_str = "".join(message_str_parts)
         abm.raw_message = data
         return abm
 

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

@@ -1,12 +1,12 @@
 import base64
 import os
+import shutil
 import uuid
 
 from astrbot.api import logger
 from astrbot.api.event import AstrMessageEvent, MessageChain
-from astrbot.api.message_components import Image, Plain, Record
+from astrbot.api.message_components import File, Image, Plain, Record
 from astrbot.core.utils.astrbot_path import get_astrbot_data_path
-from astrbot.core.utils.io import download_image_by_url
 
 from .webchat_queue_mgr import webchat_queue_mgr
 
@@ -19,7 +19,9 @@ class WebChatMessageEvent(AstrMessageEvent):
         os.makedirs(imgs_dir, exist_ok=True)
 
     @staticmethod
-    async def _send(message: MessageChain, session_id: str, streaming: bool = False):
+    async def _send(
+        message: MessageChain | None, session_id: str, streaming: bool = False
+    ) -> str | None:
         cid = session_id.split("!")[-1]
         web_chat_back_queue = webchat_queue_mgr.get_or_create_back_queue(cid)
         if not message:
@@ -30,7 +32,7 @@ class WebChatMessageEvent(AstrMessageEvent):
                     "streaming": False,
                 },  # end means this request is finished
             )
-            return ""
+            return
 
         data = ""
         for comp in message.chain:
@@ -47,24 +49,11 @@ class WebChatMessageEvent(AstrMessageEvent):
                 )
             elif isinstance(comp, Image):
                 # save image to local
-                filename = str(uuid.uuid4()) + ".jpg"
+                filename = f"{str(uuid.uuid4())}.jpg"
                 path = os.path.join(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.startswith("base64://"):
-                    base64_str = comp.file[9:]
-                    image_data = base64.b64decode(base64_str)
-                    with open(path, "wb") as f:
-                        f.write(image_data)
-                elif comp.file and comp.file.startswith("http"):
-                    await download_image_by_url(comp.file, path=path)
-                else:
-                    with open(path, "wb") as f:
-                        with open(comp.file, "rb") as f2:
-                            f.write(f2.read())
+                image_base64 = await comp.convert_to_base64()
+                with open(path, "wb") as f:
+                    f.write(base64.b64decode(image_base64))
                 data = f"[IMAGE]{filename}"
                 await web_chat_back_queue.put(
                     {
@@ -76,19 +65,11 @@ class WebChatMessageEvent(AstrMessageEvent):
                 )
             elif isinstance(comp, Record):
                 # save record to local
-                filename = str(uuid.uuid4()) + ".wav"
+                filename = f"{str(uuid.uuid4())}.wav"
                 path = os.path.join(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)
-                else:
-                    with open(path, "wb") as f:
-                        with open(comp.file, "rb") as f2:
-                            f.write(f2.read())
+                record_base64 = await comp.convert_to_base64()
+                with open(path, "wb") as f:
+                    f.write(base64.b64decode(record_base64))
                 data = f"[RECORD]{filename}"
                 await web_chat_back_queue.put(
                     {
@@ -98,6 +79,23 @@ class WebChatMessageEvent(AstrMessageEvent):
                         "streaming": streaming,
                     },
                 )
+            elif isinstance(comp, File):
+                # save file to local
+                file_path = await comp.get_file()
+                original_name = comp.name or os.path.basename(file_path)
+                ext = os.path.splitext(original_name)[1] or ""
+                filename = f"{uuid.uuid4()!s}{ext}"
+                dest_path = os.path.join(imgs_dir, filename)
+                shutil.copy2(file_path, dest_path)
+                data = f"[FILE]{filename}|{original_name}"
+                await web_chat_back_queue.put(
+                    {
+                        "type": "file",
+                        "cid": cid,
+                        "data": data,
+                        "streaming": streaming,
+                    },
+                )
             else:
                 logger.debug(f"webchat 忽略: {comp.type}")
 
@@ -131,6 +129,8 @@ class WebChatMessageEvent(AstrMessageEvent):
                 session_id=self.session_id,
                 streaming=True,
             )
+            if not r:
+                continue
             if chain.type == "reasoning":
                 reasoning_content += chain.get_plain_text()
             else:

astrbot/core/platform/sources/wechatpadpro/wechatpadpro_adapter.py

@@ -42,10 +42,9 @@ class WeChatPadProAdapter(Platform):
         platform_settings: dict,
         event_queue: asyncio.Queue,
     ) -> None:
-        super().__init__(event_queue)
+        super().__init__(platform_config, event_queue)
         self._shutdown_event = None
         self.wxnewpass = None
-        self.config = platform_config
         self.settings = platform_settings
         self.unique_session = platform_settings.get("unique_session", False)