AstrBot 3.5.6__py3-none-any.whl → 4.7.0__py3-none-any.whl

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

@@ -37,7 +37,10 @@ else:
 @register_platform_adapter("telegram", "telegram 适配器")
 class TelegramPlatformAdapter(Platform):
     def __init__(
-        self, platform_config: dict, platform_settings: dict, event_queue: asyncio.Queue
+        self,
+        platform_config: dict,
+        platform_settings: dict,
+        event_queue: asyncio.Queue,
     ) -> None:
         super().__init__(event_queue)
         self.config = platform_config
@@ -45,13 +48,15 @@ class TelegramPlatformAdapter(Platform):
         self.client_self_id = uuid.uuid4().hex[:8]
 
         base_url = self.config.get(
-            "telegram_api_base_url", "https://api.telegram.org/bot"
+            "telegram_api_base_url",
+            "https://api.telegram.org/bot",
         )
         if not base_url:
             base_url = "https://api.telegram.org/bot"
 
         file_base_url = self.config.get(
-            "telegram_file_base_url", "https://api.telegram.org/file/bot"
+            "telegram_file_base_url",
+            "https://api.telegram.org/file/bot",
         )
         if not file_base_url:
             file_base_url = "https://api.telegram.org/file/bot"
@@ -59,10 +64,12 @@ class TelegramPlatformAdapter(Platform):
         self.base_url = base_url
 
         self.enable_command_register = self.config.get(
-            "telegram_command_register", True
+            "telegram_command_register",
+            True,
         )
         self.enable_command_refresh = self.config.get(
-            "telegram_command_auto_refresh", True
+            "telegram_command_auto_refresh",
+            True,
         )
         self.last_command_hash = None
 
@@ -85,19 +92,22 @@ class TelegramPlatformAdapter(Platform):
 
     @override
     async def send_by_session(
-        self, session: MessageSesion, message_chain: MessageChain
+        self,
+        session: MessageSesion,
+        message_chain: MessageChain,
     ):
         from_username = session.session_id
         await TelegramPlatformEvent.send_with_client(
-            self.client, message_chain, from_username
+            self.client,
+            message_chain,
+            from_username,
         )
         await super().send_by_session(session, message_chain)
 
     @override
     def meta(self) -> PlatformMetadata:
-        return PlatformMetadata(
-            name="telegram", description="telegram 适配器", id=self.config.get("id")
-        )
+        id_ = self.config.get("id") or "telegram"
+        return PlatformMetadata(name="telegram", description="telegram 适配器", id=id_)
 
     @override
     async def run(self):
@@ -117,6 +127,10 @@ class TelegramPlatformAdapter(Platform):
             )
             self.scheduler.start()
 
+        if not self.application.updater:
+            logger.error("Telegram Updater is not initialized. Cannot start polling.")
+            return
+
         queue = self.application.updater.start_polling()
         logger.info("Telegram Platform Adapter is running.")
         await queue
@@ -128,7 +142,7 @@ class TelegramPlatformAdapter(Platform):
 
             if commands:
                 current_hash = hash(
-                    tuple((cmd.command, cmd.description) for cmd in commands)
+                    tuple((cmd.command, cmd.description) for cmd in commands),
                 )
                 if current_hash == self.last_command_hash:
                     return
@@ -144,13 +158,15 @@ class TelegramPlatformAdapter(Platform):
         command_dict = {}
         skip_commands = {"start"}
 
-        for handler_md in star_handlers_registry._handlers:
-            handler_metadata = handler_md[1]
+        for handler_md in star_handlers_registry:
+            handler_metadata = handler_md
             if not star_map[handler_metadata.handler_module_path].activated:
                 continue
             for event_filter in handler_metadata.event_filters:
                 cmd_info = self._extract_command_info(
-                    event_filter, handler_metadata, skip_commands
+                    event_filter,
+                    handler_metadata,
+                    skip_commands,
                 )
                 if cmd_info:
                     cmd_name, description = cmd_info
@@ -161,7 +177,9 @@ class TelegramPlatformAdapter(Platform):
 
     @staticmethod
     def _extract_command_info(
-        event_filter, handler_metadata, skip_commands: set
+        event_filter,
+        handler_metadata,
+        skip_commands: set,
     ) -> tuple[str, str] | None:
         """从事件过滤器中提取指令信息"""
         cmd_name = None
@@ -183,7 +201,6 @@ class TelegramPlatformAdapter(Platform):
             return None
 
         if not re.match(r"^[a-z0-9_]+$", cmd_name) or len(cmd_name) > 32:
-            logger.debug(f"跳过无法注册的命令: {cmd_name}")
             return None
 
         # Build description.
@@ -195,8 +212,14 @@ class TelegramPlatformAdapter(Platform):
         return cmd_name, description
 
     async def start(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        if not update.effective_chat:
+            logger.warning(
+                "Received a start command without an effective chat, skipping /start reply.",
+            )
+            return
         await context.bot.send_message(
-            chat_id=update.effective_chat.id, text=self.config["start_message"]
+            chat_id=update.effective_chat.id,
+            text=self.config["start_message"],
         )
 
     async def message_handler(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
@@ -206,16 +229,24 @@ class TelegramPlatformAdapter(Platform):
             await self.handle_msg(abm)
 
     async def convert_message(
-        self, update: Update, context: ContextTypes.DEFAULT_TYPE, get_reply=True
-    ) -> AstrBotMessage:
+        self,
+        update: Update,
+        context: ContextTypes.DEFAULT_TYPE,
+        get_reply=True,
+    ) -> AstrBotMessage | None:
         """转换 Telegram 的消息对象为 AstrBotMessage 对象。
 
         @param update: Telegram 的 Update 对象。
         @param context: Telegram 的 Context 对象。
         @param get_reply: 是否获取回复消息。这个参数是为了防止多个回复嵌套。
         """
+        if not update.message:
+            logger.warning("Received an update without a message.")
+            return None
+
         message = AstrBotMessage()
         message.session_id = str(update.message.chat.id)
+
         # 获得是群聊还是私聊
         if update.message.chat.type == ChatType.PRIVATE:
             message.type = MessageType.FRIEND_MESSAGE
@@ -226,10 +257,14 @@ class TelegramPlatformAdapter(Platform):
                 # Topic Group
                 message.group_id += "#" + str(update.message.message_thread_id)
                 message.session_id = message.group_id
-
         message.message_id = str(update.message.message_id)
+        _from_user = update.message.from_user
+        if not _from_user:
+            logger.warning("[Telegram] Received a message without a from_user.")
+            return None
         message.sender = MessageMember(
-            str(update.message.from_user.id), update.message.from_user.username
+            str(_from_user.id),
+            _from_user.username or "Unknown",
         )
         message.self_id = str(context.bot.username)
         message.raw_message = update
@@ -248,22 +283,32 @@ class TelegramPlatformAdapter(Platform):
             )
             reply_abm = await self.convert_message(reply_update, context, False)
 
-            message.message.append(
-                Comp.Reply(
-                    id=reply_abm.message_id,
-                    chain=reply_abm.message,
-                    sender_id=reply_abm.sender.user_id,
-                    sender_nickname=reply_abm.sender.nickname,
-                    time=reply_abm.timestamp,
-                    message_str=reply_abm.message_str,
-                    text=reply_abm.message_str,
-                    qq=reply_abm.sender.user_id,
+            if reply_abm:
+                message.message.append(
+                    Comp.Reply(
+                        id=reply_abm.message_id,
+                        chain=reply_abm.message,
+                        sender_id=reply_abm.sender.user_id,
+                        sender_nickname=reply_abm.sender.nickname,
+                        time=reply_abm.timestamp,
+                        message_str=reply_abm.message_str,
+                        text=reply_abm.message_str,
+                        qq=reply_abm.sender.user_id,
+                    ),
                 )
-            )
 
         if update.message.text:
             # 处理文本消息
             plain_text = update.message.text
+            if (
+                message.type == MessageType.GROUP_MESSAGE
+                and update.message
+                and update.message.reply_to_message
+                and update.message.reply_to_message.from_user
+                and update.message.reply_to_message.from_user.id == context.bot.id
+            ):
+                plain_text2 = f"/@{context.bot.username} " + plain_text
+                plain_text = plain_text2
 
             # 群聊场景命令特殊处理
             if plain_text.startswith("/"):
@@ -282,10 +327,12 @@ class TelegramPlatformAdapter(Platform):
                             entity.offset + 1 : entity.offset + entity.length
                         ]
                         message.message.append(Comp.At(qq=name, name=name))
-                        plain_text = (
-                            plain_text[: entity.offset]
-                            + plain_text[entity.offset + entity.length :]
-                        )
+                        # 如果mention是当前bot则移除；否则保留
+                        if name.lower() == context.bot.username.lower():
+                            plain_text = (
+                                plain_text[: entity.offset]
+                                + plain_text[entity.offset + entity.length :]
+                            )
 
             if plain_text:
                 message.message.append(Comp.Plain(plain_text))
@@ -293,7 +340,7 @@ class TelegramPlatformAdapter(Platform):
 
             if message.message_str.strip() == "/start":
                 await self.start(update, context)
-                return
+                return None
 
         elif update.message.voice:
             file = await update.message.voice.get_file()
@@ -327,15 +374,25 @@ class TelegramPlatformAdapter(Platform):
 
         elif update.message.document:
             file = await update.message.document.get_file()
-            message.message = [
-                Comp.File(file=file.file_path, name=update.message.document.file_name),
-            ]
+            file_name = update.message.document.file_name or uuid.uuid4().hex
+            file_path = file.file_path
+            if file_path is None:
+                logger.warning(
+                    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))
 
         elif update.message.video:
             file = await update.message.video.get_file()
-            message.message = [
-                Comp.Video(file=file.file_path, path=file.file_path),
-            ]
+            file_name = update.message.video.file_name or uuid.uuid4().hex
+            file_path = file.file_path
+            if file_path is None:
+                logger.warning(
+                    f"Telegram video file_path is None, cannot save the file {file_name}.",
+                )
+            else:
+                message.message.append(Comp.Video(file=file_path, path=file.file_path))
 
         return message
 

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

@@ -1,21 +1,37 @@
 import asyncio
+import os
+import re
+
 import telegramify_markdown
+from telegram import ReactionTypeCustomEmoji, ReactionTypeEmoji
+from telegram.ext import ExtBot
+
+from astrbot import logger
 from astrbot.api.event import AstrMessageEvent, MessageChain
-from astrbot.api.platform import AstrBotMessage, PlatformMetadata, MessageType
 from astrbot.api.message_components import (
-    Plain,
-    Image,
-    Reply,
     At,
     File,
+    Image,
+    Plain,
     Record,
+    Reply,
 )
-from telegram.ext import ExtBot
+from astrbot.api.platform import AstrBotMessage, MessageType, PlatformMetadata
+from astrbot.core.utils.astrbot_path import get_astrbot_data_path
 from astrbot.core.utils.io import download_file
-from astrbot import logger
 
 
 class TelegramPlatformEvent(AstrMessageEvent):
+    # Telegram 的最大消息长度限制
+    MAX_MESSAGE_LENGTH = 4096
+
+    SPLIT_PATTERNS = {
+        "paragraph": re.compile(r"\n\n"),
+        "line": re.compile(r"\n"),
+        "sentence": re.compile(r"[.!?。！？]"),
+        "word": re.compile(r"\s"),
+    }
+
     def __init__(
         self,
         message_str: str,
@@ -27,8 +43,38 @@ class TelegramPlatformEvent(AstrMessageEvent):
         super().__init__(message_str, message_obj, platform_meta, session_id)
         self.client = client
 
-    @staticmethod
-    async def send_with_client(client: ExtBot, message: MessageChain, user_name: str):
+    @classmethod
+    def _split_message(cls, text: str) -> list[str]:
+        if len(text) <= cls.MAX_MESSAGE_LENGTH:
+            return [text]
+
+        chunks = []
+        while text:
+            if len(text) <= cls.MAX_MESSAGE_LENGTH:
+                chunks.append(text)
+                break
+
+            split_point = cls.MAX_MESSAGE_LENGTH
+            segment = text[: cls.MAX_MESSAGE_LENGTH]
+
+            for _, pattern in cls.SPLIT_PATTERNS.items():
+                if matches := list(pattern.finditer(segment)):
+                    last_match = matches[-1]
+                    split_point = last_match.end()
+                    break
+
+            chunks.append(text[:split_point])
+            text = text[split_point:].lstrip()
+
+        return chunks
+
+    @classmethod
+    async def send_with_client(
+        cls,
+        client: ExtBot,
+        message: MessageChain,
+        user_name: str,
+    ):
         image_path = None
 
         has_reply = False
@@ -57,25 +103,33 @@ class TelegramPlatformEvent(AstrMessageEvent):
 
             if isinstance(i, Plain):
                 if at_user_id and not at_flag:
-                    i.text = f"@{at_user_id} " + i.text
+                    i.text = f"@{at_user_id} {i.text}"
                     at_flag = True
-                text = i.text
-                try:
-                    text = telegramify_markdown.markdownify(
-                        i.text, max_line_length=None, normalize_whitespace=False
-                    )
-                except Exception as e:
-                    logger.warning(
-                        f"MarkdownV2 conversion failed: {e}. Using plain text instead."
-                    )
-                    return
-                await client.send_message(text=text, parse_mode="MarkdownV2", **payload)
+                chunks = cls._split_message(i.text)
+                for chunk in chunks:
+                    try:
+                        md_text = telegramify_markdown.markdownify(
+                            chunk,
+                            max_line_length=None,
+                            normalize_whitespace=False,
+                        )
+                        await client.send_message(
+                            text=md_text,
+                            parse_mode="MarkdownV2",
+                            **payload,
+                        )
+                    except Exception as e:
+                        logger.warning(
+                            f"MarkdownV2 send failed: {e}. Using plain text instead.",
+                        )
+                        await client.send_message(text=chunk, **payload)
             elif isinstance(i, Image):
                 image_path = await i.convert_to_file_path()
                 await client.send_photo(photo=image_path, **payload)
             elif isinstance(i, File):
                 if i.file.startswith("https://"):
-                    path = "data/temp/" + i.name
+                    temp_dir = os.path.join(get_astrbot_data_path(), "temp")
+                    path = os.path.join(temp_dir, i.name)
                     await download_file(i.file, path)
                     i.file = path
 
@@ -91,6 +145,38 @@ class TelegramPlatformEvent(AstrMessageEvent):
             await self.send_with_client(self.client, message, self.get_sender_id())
         await super().send(message)
 
+    async def react(self, emoji: str | None, big: bool = False):
+        """给原消息添加 Telegram 反应：
+        - 普通 emoji：传入 '👍'、'😂' 等
+        - 自定义表情：传入其 custom_emoji_id（纯数字字符串）
+        - 取消本机器人的反应：传入 None 或空字符串
+        """
+        try:
+            # 解析 chat_id（去掉超级群的 "#<thread_id>" 片段）
+            if self.get_message_type() == MessageType.GROUP_MESSAGE:
+                chat_id = (self.message_obj.group_id or "").split("#")[0]
+            else:
+                chat_id = self.get_sender_id()
+
+            message_id = int(self.message_obj.message_id)
+
+            # 组装 reaction 参数（必须是 ReactionType 的列表）
+            if not emoji:  # 清空本 bot 的反应
+                reaction_param = []  # 空列表表示移除本 bot 的反应
+            elif emoji.isdigit():  # 自定义表情：传 custom_emoji_id
+                reaction_param = [ReactionTypeCustomEmoji(emoji)]
+            else:  # 普通 emoji
+                reaction_param = [ReactionTypeEmoji(emoji)]
+
+            await self.client.set_message_reaction(
+                chat_id=chat_id,
+                message_id=message_id,
+                reaction=reaction_param,  # 注意是列表
+                is_big=big,  # 可选：大动画
+            )
+        except Exception as e:
+            logger.error(f"[Telegram] 添加反应失败: {e}")
+
     async def send_streaming(self, generator, use_fallback: bool = False):
         message_thread_id = None
 
@@ -116,6 +202,12 @@ class TelegramPlatformEvent(AstrMessageEvent):
 
         async for chain in generator:
             if isinstance(chain, MessageChain):
+                if chain.type == "break":
+                    # 分割符
+                    message_id = None  # 重置消息 ID
+                    delta = ""  # 重置 delta
+                    continue
+
                 # 处理消息链中的每个组件
                 for i in chain.chain:
                     if isinstance(i, Plain):
@@ -126,12 +218,15 @@ class TelegramPlatformEvent(AstrMessageEvent):
                         continue
                     elif isinstance(i, File):
                         if i.file.startswith("https://"):
-                            path = "data/temp/" + i.name
+                            temp_dir = os.path.join(get_astrbot_data_path(), "temp")
+                            path = os.path.join(temp_dir, i.name)
                             await download_file(i.file, path)
                             i.file = path
 
                         await self.client.send_document(
-                            document=i.file, filename=i.name, **payload
+                            document=i.file,
+                            filename=i.name,
+                            **payload,
                         )
                         continue
                     elif isinstance(i, Record):
@@ -143,17 +238,7 @@ class TelegramPlatformEvent(AstrMessageEvent):
                         continue
 
                 # Plain
-                if not message_id:
-                    try:
-                        msg = await self.client.send_message(text=delta, **payload)
-                        current_content = delta
-                    except Exception as e:
-                        logger.warning(f"发送消息失败(streaming): {e!s}")
-                    message_id = msg.message_id
-                    last_edit_time = (
-                        asyncio.get_event_loop().time()
-                    )  # 记录初始消息发送时间
-                else:
+                if message_id and len(delta) <= self.MAX_MESSAGE_LENGTH:
                     current_time = asyncio.get_event_loop().time()
                     time_since_last_edit = current_time - last_edit_time
 
@@ -172,12 +257,25 @@ class TelegramPlatformEvent(AstrMessageEvent):
                         last_edit_time = (
                             asyncio.get_event_loop().time()
                         )  # 更新上次编辑的时间
+                else:
+                    # delta 长度一般不会大于 4096，因此这里直接发送
+                    try:
+                        msg = await self.client.send_message(text=delta, **payload)
+                        current_content = delta
+                    except Exception as e:
+                        logger.warning(f"发送消息失败(streaming): {e!s}")
+                    message_id = msg.message_id
+                    last_edit_time = (
+                        asyncio.get_event_loop().time()
+                    )  # 记录初始消息发送时间
 
         try:
             if delta and current_content != delta:
                 try:
                     markdown_text = telegramify_markdown.markdownify(
-                        delta, max_line_length=None, normalize_whitespace=False
+                        delta,
+                        max_line_length=None,
+                        normalize_whitespace=False,
                     )
                     await self.client.edit_message_text(
                         text=markdown_text,
@@ -188,7 +286,9 @@ class TelegramPlatformEvent(AstrMessageEvent):
                 except Exception as e:
                     logger.warning(f"Markdown转换失败，使用普通文本: {e!s}")
                     await self.client.edit_message_text(
-                        text=delta, chat_id=payload["chat_id"], message_id=message_id
+                        text=delta,
+                        chat_id=payload["chat_id"],
+                        message_id=message_id,
                     )
         except Exception as e:
             logger.warning(f"编辑消息失败(streaming): {e!s}")