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

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]
 
@@ -381,7 +380,9 @@ class TelegramPlatformAdapter(Platform):
                     f"Telegram document file_path is None, cannot save the file {file_name}.",
                 )
             else:
-                message.message.append(Comp.File(file=file_path, name=file_name))
+                message.message.append(
+                    Comp.File(file=file_path, name=file_name, url=file_path)
+                )
 
         elif update.message.video:
             file = await update.message.video.get_file()

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)
 

astrbot/core/platform/sources/wecom/wecom_adapter.py

@@ -2,6 +2,7 @@ import asyncio
 import os
 import sys
 import uuid
+from typing import Any
 
 import quart
 from requests import Response
@@ -24,6 +25,7 @@ from astrbot.api.platform import (
 from astrbot.core import logger
 from astrbot.core.platform.astr_message_event import MessageSesion
 from astrbot.core.utils.astrbot_path import get_astrbot_data_path
+from astrbot.core.utils.webhook_utils import log_webhook_info
 
 from .wecom_event import WecomPlatformEvent
 from .wecom_kf import WeChatKF
@@ -62,8 +64,20 @@ class WecomServer:
         self.shutdown_event = asyncio.Event()
 
     async def verify(self):
-        logger.info(f"验证请求有效性: {quart.request.args}")
-        args = quart.request.args
+        """内部服务器的 GET 验证入口"""
+        return await self.handle_verify(quart.request)
+
+    async def handle_verify(self, request) -> str:
+        """处理验证请求，可被统一 webhook 入口复用
+
+        Args:
+            request: Quart 请求对象
+
+        Returns:
+            验证响应
+        """
+        logger.info(f"验证请求有效性: {request.args}")
+        args = request.args
         try:
             echo_str = self.crypto.check_signature(
                 args.get("msg_signature"),
@@ -78,10 +92,22 @@ class WecomServer:
             raise
 
     async def callback_command(self):
-        data = await quart.request.get_data()
-        msg_signature = quart.request.args.get("msg_signature")
-        timestamp = quart.request.args.get("timestamp")
-        nonce = quart.request.args.get("nonce")
+        """内部服务器的 POST 回调入口"""
+        return await self.handle_callback(quart.request)
+
+    async def handle_callback(self, request) -> str:
+        """处理回调请求，可被统一 webhook 入口复用
+
+        Args:
+            request: Quart 请求对象
+
+        Returns:
+            响应内容
+        """
+        data = await request.get_data()
+        msg_signature = request.args.get("msg_signature")
+        timestamp = request.args.get("timestamp")
+        nonce = request.args.get("nonce")
         try:
             xml = self.crypto.decrypt_message(data, msg_signature, timestamp, nonce)
         except InvalidSignatureException:
@@ -118,14 +144,14 @@ class WecomPlatformAdapter(Platform):
         platform_settings: dict,
         event_queue: asyncio.Queue,
     ) -> None:
-        super().__init__(event_queue)
-        self.config = platform_config
+        super().__init__(platform_config, event_queue)
         self.settingss = platform_settings
         self.client_self_id = uuid.uuid4().hex[:8]
         self.api_base_url = platform_config.get(
             "api_base_url",
             "https://qyapi.weixin.qq.com/cgi-bin/",
         )
+        self.unified_webhook_mode = platform_config.get("unified_webhook_mode", False)
 
         if not self.api_base_url:
             self.api_base_url = "https://qyapi.weixin.qq.com/cgi-bin/"
@@ -232,7 +258,23 @@ class WecomPlatformAdapter(Platform):
                     )
             except Exception as e:
                 logger.error(e)
-        await self.server.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}(企业微信)", webhook_uuid)
+            # 保持运行状态，等待 shutdown
+            await self.server.shutdown_event.wait()
+        else:
+            await self.server.start_polling()
+
+    async def webhook_callback(self, request: Any) -> Any:
+        """统一 Webhook 回调入口"""
+        # 根据请求方法分发到不同的处理函数
+        if request.method == "GET":
+            return await self.server.handle_verify(request)
+        else:
+            return await self.server.handle_callback(request)
 
     async def convert_message(self, msg: BaseMessage) -> AstrBotMessage | None:
         abm = AstrBotMessage()

astrbot/core/platform/sources/wecom/wecom_event.py

@@ -16,7 +16,7 @@ try:
     import pydub
 except Exception:
     logger.warning(
-        "检测到 pydub 库未安装，企业微信将无法语音收发。如需使用语音，请前往管理面板 -> 控制台 -> 安装 Pip 库安装 pydub。",
+        "检测到 pydub 库未安装，企业微信将无法语音收发。如需使用语音，请前往管理面板 -> 平台日志 -> 安装 Pip 库安装 pydub。",
     )
 
 

astrbot/core/platform/sources/wecom_ai_bot/wecomai_adapter.py

@@ -22,6 +22,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 .wecomai_api import (
@@ -103,9 +104,7 @@ class WecomAIBotAdapter(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
 
         # 初始化配置参数
@@ -122,6 +121,7 @@ class WecomAIBotAdapter(Platform):
             "wecomaibot_friend_message_welcome_text",
             "",
         )
+        self.unified_webhook_mode = self.config.get("unified_webhook_mode", False)
 
         # 平台元数据
         self.metadata = PlatformMetadata(
@@ -425,17 +425,34 @@ class WecomAIBotAdapter(Platform):
 
     def run(self) -> Awaitable[Any]:
         """运行适配器，同时启动HTTP服务器和队列监听器"""
-        logger.info("启动企业微信智能机器人适配器，监听 %s:%d", self.host, self.port)
 
         async def run_both():
-            # 同时运行HTTP服务器和队列监听器
-            await asyncio.gather(
-                self.server.start_server(),
-                self.queue_listener.run(),
-            )
+            # 如果启用统一 webhook 模式，则不启动独立服务器
+            webhook_uuid = self.config.get("webhook_uuid")
+            if self.unified_webhook_mode and webhook_uuid:
+                log_webhook_info(f"{self.meta().id}(企业微信智能机器人)", webhook_uuid)
+                # 只运行队列监听器
+                await self.queue_listener.run()
+            else:
+                logger.info(
+                    "启动企业微信智能机器人适配器，监听 %s:%d", self.host, self.port
+                )
+                # 同时运行HTTP服务器和队列监听器
+                await asyncio.gather(
+                    self.server.start_server(),
+                    self.queue_listener.run(),
+                )
 
         return run_both()
 
+    async def webhook_callback(self, request: Any) -> Any:
+        """统一 Webhook 回调入口"""
+        # 根据请求方法分发到不同的处理函数
+        if request.method == "GET":
+            return await self.server.handle_verify(request)
+        else:
+            return await self.server.handle_callback(request)
+
     async def terminate(self):
         """终止适配器"""
         logger.info("企业微信智能机器人适配器正在关闭...")

astrbot/core/platform/sources/wecom_ai_bot/wecomai_server.py

@@ -59,8 +59,19 @@ class WecomAIBotServer:
         )
 
     async def verify_url(self):
-        """验证回调 URL"""
-        args = quart.request.args
+        """内部服务器的 GET 验证入口"""
+        return await self.handle_verify(quart.request)
+
+    async def handle_verify(self, request):
+        """处理 URL 验证请求，可被统一 webhook 入口复用
+
+        Args:
+            request: Quart 请求对象
+
+        Returns:
+            验证响应元组 (content, status_code, headers)
+        """
+        args = request.args
         msg_signature = args.get("msg_signature")
         timestamp = args.get("timestamp")
         nonce = args.get("nonce")
@@ -81,8 +92,19 @@ class WecomAIBotServer:
         return result, 200, {"Content-Type": "text/plain"}
 
     async def handle_message(self):
-        """处理消息回调"""
-        args = quart.request.args
+        """内部服务器的 POST 消息回调入口"""
+        return await self.handle_callback(quart.request)
+
+    async def handle_callback(self, request):
+        """处理消息回调，可被统一 webhook 入口复用
+
+        Args:
+            request: Quart 请求对象
+
+        Returns:
+            响应元组 (content, status_code, headers)
+        """
+        args = request.args
         msg_signature = args.get("msg_signature")
         timestamp = args.get("timestamp")
         nonce = args.get("nonce")
@@ -102,7 +124,7 @@ class WecomAIBotServer:
 
         try:
             # 获取请求体
-            post_data = await quart.request.get_data()
+            post_data = await request.get_data()
 
             # 确保 post_data 是 bytes 类型
             if isinstance(post_data, str):