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

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

@@ -2,11 +2,13 @@ import asyncio
 import os
 import time
 import uuid
-from collections.abc import Awaitable, Callable
+from collections.abc import Callable, Coroutine
 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,40 +195,19 @@ 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
 
-    def run(self) -> Awaitable[Any]:
+    def run(self) -> Coroutine[Any, Any, None]:
         async def callback(data: tuple):
             abm = await self.convert_message(data)
             await self.handle_msg(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,14 +79,31 @@ 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}")
 
         return data
 
-    async def send(self, message: MessageChain):
+    async def send(self, message: MessageChain | None):
         await WebChatMessageEvent._send(message, session_id=self.session_id)
-        await super().send(message)
+        await super().send(MessageChain([]))
 
     async def send_streaming(self, generator, use_fallback: bool = False):
         final_data = ""
@@ -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

@@ -4,6 +4,7 @@ import json
 import os
 import time
 import traceback
+from typing import cast
 
 import aiohttp
 import anyio
@@ -42,10 +43,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)
 
@@ -70,7 +70,7 @@ class WeChatPadProAdapter(Platform):
         )
         self.base_url = f"http://{self.host}:{self.port}"
         self.auth_key = None  # 用于保存生成的授权码
-        self.wxid = None  # 用于保存登录成功后的 wxid
+        self.wxid: str | None = None  # 用于保存登录成功后的 wxid
         self.credentials_file = os.path.join(
             get_astrbot_data_path(),
             "wechatpadpro_credentials.json",
@@ -399,7 +399,7 @@ class WeChatPadProAdapter(Platform):
                 )
                 await asyncio.sleep(5)
 
-    async def handle_websocket_message(self, message: str):
+    async def handle_websocket_message(self, message: str | bytes):
         """处理从 WebSocket 接收到的消息。"""
         logger.debug(f"收到 WebSocket 消息: {message}")
         try:
@@ -431,10 +431,13 @@ class WeChatPadProAdapter(Platform):
 
     async def convert_message(self, raw_message: dict) -> AstrBotMessage | None:
         """将 WeChatPadPro 原始消息转换为 AstrBotMessage。"""
+        if self.wxid is None:
+            logger.error("WeChatPadPro 适配器未登录或未获取到 wxid，无法处理消息。")
+            return None
         abm = AstrBotMessage()
         abm.raw_message = raw_message
         abm.message_id = str(raw_message.get("msg_id"))
-        abm.timestamp = raw_message.get("create_time")
+        abm.timestamp = cast(int, raw_message.get("create_time"))
         abm.self_id = self.wxid
 
         if int(time.time()) - abm.timestamp > 180:
@@ -447,7 +450,7 @@ class WeChatPadProAdapter(Platform):
         to_user_name = raw_message.get("to_user_name", {}).get("str", "")
         content = raw_message.get("content", {}).get("str", "")
         push_content = raw_message.get("push_content", "")
-        msg_type = raw_message.get("msg_type")
+        msg_type = cast(int, raw_message.get("msg_type"))
 
         abm.message_str = ""
         abm.message = []
@@ -575,7 +578,7 @@ class WeChatPadProAdapter(Platform):
         from_user_name: str,
         to_user_name: str,
         msg_id: int,
-    ):
+    ) -> dict | None:
         """下载原始图片。"""
         url = f"{self.base_url}/message/GetMsgBigImg"
         params = {"key": self.auth_key}
@@ -726,12 +729,15 @@ class WeChatPadProAdapter(Platform):
             # 图片消息
             from_user_name = raw_message.get("from_user_name", {}).get("str", "")
             to_user_name = raw_message.get("to_user_name", {}).get("str", "")
-            msg_id = raw_message.get("msg_id")
+            msg_id = cast(int, raw_message.get("msg_id"))
             image_resp = await self._download_raw_image(
                 from_user_name,
                 to_user_name,
                 msg_id,
             )
+            if image_resp is None:
+                logger.error(f"下载图片失败: msg_id={msg_id}")
+                return
             image_bs64_data = (
                 image_resp.get("Data", {}).get("Data", {}).get("Buffer", None)
             )
@@ -772,6 +778,9 @@ class WeChatPadProAdapter(Platform):
             bufid = 0
             to_user_name = raw_message.get("to_user_name", {}).get("str", "")
             new_msg_id = raw_message.get("new_msg_id")
+            if new_msg_id is None:
+                logger.error("语音消息缺少 new_msg_id")
+                return
             data_parser = GeweDataParser(
                 content=content,
                 is_private_chat=(abm.type != MessageType.GROUP_MESSAGE),
@@ -779,6 +788,9 @@ class WeChatPadProAdapter(Platform):
             )
 
             voicemsg = data_parser._format_to_xml().find("voicemsg")
+            if voicemsg is None:
+                logger.error("无法从 XML 解析 voicemsg 节点")
+                return
             bufid = voicemsg.get("bufid") or "0"
             length = int(voicemsg.get("length") or 0)
             voice_resp = await self.download_voice(
@@ -787,6 +799,9 @@ class WeChatPadProAdapter(Platform):
                 bufid=bufid,
                 length=length,
             )
+            if voice_resp is None:
+                logger.error(f"下载语音失败: new_msg_id={new_msg_id}")
+                return
             voice_bs64_data = voice_resp.get("Data", {}).get("Base64", None)
             if voice_bs64_data:
                 voice_bs64_data = base64.b64decode(voice_bs64_data)
@@ -828,7 +843,8 @@ class WeChatPadProAdapter(Platform):
         try:
             if self.ws_handle_task:
                 self.ws_handle_task.cancel()
-            self._shutdown_event.set()
+            if self._shutdown_event is not None:
+                self._shutdown_event.set()
         except Exception:
             pass
 
@@ -895,8 +911,8 @@ class WeChatPadProAdapter(Platform):
 
     async def get_contact_details_list(
         self,
-        room_wx_id_list: list[str] = None,
-        user_names: list[str] = None,
+        room_wx_id_list: list[str] | None = None,
+        user_names: list[str] | None = None,
     ) -> dict | None:
         """获取联系人详情列表。"""
         if room_wx_id_list is None:

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

@@ -2,6 +2,8 @@ import asyncio
 import os
 import sys
 import uuid
+from collections.abc import Awaitable, Callable
+from typing import Any, cast
 
 import quart
 from requests import Response
@@ -24,6 +26,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
@@ -38,7 +41,7 @@ else:
 class WecomServer:
     def __init__(self, event_queue: asyncio.Queue, config: dict):
         self.server = quart.Quart(__name__)
-        self.port = int(config.get("port"))
+        self.port = int(cast(str, config.get("port")))
         self.callback_server_host = config.get("callback_server_host", "0.0.0.0")
         self.server.add_url_rule(
             "/callback/command",
@@ -58,12 +61,24 @@ class WecomServer:
             config["corpid"].strip(),
         )
 
-        self.callback = None
+        self.callback: Callable[[BaseMessage], Awaitable[None]] | None = None
         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,17 +93,29 @@ 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:
             logger.error("解密失败，签名异常，请检查配置。")
             raise
         else:
-            msg = parse_message(xml)
+            msg = cast(BaseMessage, parse_message(xml))
             logger.info(f"解析成功: {msg}")
 
             if self.callback:
@@ -118,14 +145,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/"
@@ -150,10 +177,10 @@ class WecomPlatformAdapter(Platform):
             # inject
             self.wechat_kf_api = WeChatKF(client=self.client)
             self.wechat_kf_message_api = WeChatKFMessage(self.client)
-            self.client.kf = self.wechat_kf_api
-            self.client.kf_message = self.wechat_kf_message_api
+            self.client.__setattr__("kf", self.wechat_kf_api)
+            self.client.__setattr__("kf_message", self.wechat_kf_message_api)
 
-        self.client.API_BASE_URL = self.api_base_url
+        self.client.__setattr__("API_BASE_URL", self.api_base_url)
 
         async def callback(msg: BaseMessage):
             if msg.type == "unknown" and msg._data["Event"] == "kf_msg_or_event":
@@ -232,41 +259,53 @@ 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()
-        if msg.type == "text":
-            assert isinstance(msg, TextMessage)
+        if isinstance(msg, TextMessage):
             abm.message_str = msg.content
             abm.self_id = str(msg.agent)
             abm.message = [Plain(msg.content)]
             abm.type = MessageType.FRIEND_MESSAGE
             abm.sender = MessageMember(
-                msg.source,
-                msg.source,
+                cast(str, msg.source),
+                cast(str, msg.source),
             )
-            abm.message_id = msg.id
-            abm.timestamp = msg.time
+            abm.message_id = str(msg.id)
+            abm.timestamp = int(cast(int | str, msg.time))
             abm.session_id = abm.sender.user_id
             abm.raw_message = msg
-        elif msg.type == "image":
-            assert isinstance(msg, ImageMessage)
+        elif isinstance(msg, ImageMessage):
             abm.message_str = "[图片]"
             abm.self_id = str(msg.agent)
             abm.message = [Image(file=msg.image, url=msg.image)]
             abm.type = MessageType.FRIEND_MESSAGE
             abm.sender = MessageMember(
-                msg.source,
-                msg.source,
+                cast(str, msg.source),
+                cast(str, msg.source),
             )
-            abm.message_id = msg.id
-            abm.timestamp = msg.time
+            abm.message_id = str(msg.id)
+            abm.timestamp = int(cast(int | str, msg.time))
             abm.session_id = abm.sender.user_id
             abm.raw_message = msg
-        elif msg.type == "voice":
-            assert isinstance(msg, VoiceMessage)
-
+        elif isinstance(msg, VoiceMessage):
             resp: Response = await asyncio.get_event_loop().run_in_executor(
                 None,
                 self.client.media.download,
@@ -293,11 +332,11 @@ class WecomPlatformAdapter(Platform):
             abm.message = [Record(file=path_wav, url=path_wav)]
             abm.type = MessageType.FRIEND_MESSAGE
             abm.sender = MessageMember(
-                msg.source,
-                msg.source,
+                cast(str, msg.source),
+                cast(str, msg.source),
             )
-            abm.message_id = msg.id
-            abm.timestamp = msg.time
+            abm.message_id = str(msg.id)
+            abm.timestamp = int(cast(int | str, msg.time))
             abm.session_id = abm.sender.user_id
             abm.raw_message = msg
         else:
@@ -309,7 +348,7 @@ class WecomPlatformAdapter(Platform):
 
     async def convert_wechat_kf_message(self, msg: dict) -> AstrBotMessage | None:
         msgtype = msg.get("msgtype")
-        external_userid = msg.get("external_userid")
+        external_userid = cast(str, msg.get("external_userid"))
         abm = AstrBotMessage()
         abm.raw_message = msg
         abm.raw_message["_wechat_kf_flag"] = None  # 方便处理
@@ -383,4 +422,4 @@ class WecomPlatformAdapter(Platform):
             await self.server.server.shutdown()
         except Exception as _:
             pass
-        logger.info("企业微信 适配器已被优雅地关闭")
+        logger.info("企业微信 适配器已被关闭")

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。",
     )
 
 
@@ -93,10 +93,10 @@ class WecomPlatformEvent(AstrMessageEvent):
         if is_wechat_kf:
             # 微信客服
             kf_message_api = getattr(self.client, "kf_message", None)
-            if not kf_message_api:
+            if not isinstance(kf_message_api, WeChatKFMessage):
                 logger.warning("未找到微信客服发送消息方法。")
                 return
-            assert isinstance(kf_message_api, WeChatKFMessage)
+
             user_id = self.get_sender_id()
             for comp in message.chain:
                 if isinstance(comp, Plain):