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

astrbot/core/pipeline/respond/stage.py

@@ -1,58 +1,38 @@
-import random
 import asyncio
 import math
-import traceback
+import random
+from collections.abc import AsyncGenerator
+
 import astrbot.core.message.components as Comp
-from typing import Union, AsyncGenerator
-from ..stage import register_stage, Stage
-from ..context import PipelineContext
-from astrbot.core.platform.astr_message_event import AstrMessageEvent
-from astrbot.core.message.message_event_result import MessageChain, ResultContentType
 from astrbot.core import logger
-from astrbot.core.message.message_event_result import BaseMessageComponent
-from astrbot.core.star.star_handler import star_handlers_registry, EventType
-from astrbot.core.star.star import star_map
+from astrbot.core.message.components import BaseMessageComponent, ComponentType
+from astrbot.core.message.message_event_result import MessageChain, ResultContentType
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core.star.star_handler import EventType
 from astrbot.core.utils.path_util import path_Mapping
 
+from ..context import PipelineContext, call_event_hook
+from ..stage import Stage, register_stage
+
 
 @register_stage
 class RespondStage(Stage):
     # 组件类型到其非空判断函数的映射
     _component_validators = {
         Comp.Plain: lambda comp: bool(
-            comp.text and comp.text.strip()
+            comp.text and comp.text.strip(),
         ),  # 纯文本消息需要strip
         Comp.Face: lambda comp: comp.id is not None,  # QQ表情
         Comp.Record: lambda comp: bool(comp.file),  # 语音
         Comp.Video: lambda comp: bool(comp.file),  # 视频
         Comp.At: lambda comp: bool(comp.qq) or bool(comp.name),  # @
-        Comp.AtAll: lambda comp: True,  # @所有人
-        Comp.RPS: lambda comp: True,  # 不知道是啥(未完成)
-        Comp.Dice: lambda comp: True,  # 骰子(未完成)
-        Comp.Shake: lambda comp: True,  # 摇一摇(未完成)
-        Comp.Anonymous: lambda comp: True,  # 匿名(未完成)
-        Comp.Share: lambda comp: bool(comp.url) and bool(comp.title),  # 分享
-        Comp.Contact: lambda comp: True,  # 联系人(未完成)
-        Comp.Location: lambda comp: bool(comp.lat and comp.lon),  # 位置
-        Comp.Music: lambda comp: bool(comp._type)
-        and bool(comp.url)
-        and bool(comp.audio),  # 音乐
         Comp.Image: lambda comp: bool(comp.file),  # 图片
         Comp.Reply: lambda comp: bool(comp.id) and comp.sender_id is not None,  # 回复
-        Comp.RedBag: lambda comp: bool(comp.title),  # 红包
         Comp.Poke: lambda comp: comp.id != 0 and comp.qq != 0,  # 戳一戳
-        Comp.Forward: lambda comp: bool(comp.id and comp.id.strip()),  # 转发
-        Comp.Node: lambda comp: bool(comp.name)
-        and comp.uin != 0
-        and bool(comp.content),  # 一个转发节点
+        Comp.Node: lambda comp: bool(comp.content),  # 转发节点
         Comp.Nodes: lambda comp: bool(comp.nodes),  # 多个转发节点
-        Comp.Xml: lambda comp: bool(comp.data and comp.data.strip()),  # XML
-        Comp.Json: lambda comp: bool(comp.data),  # JSON
-        Comp.CardImage: lambda comp: bool(comp.file),  # 卡片图片
-        Comp.TTS: lambda comp: bool(comp.text and comp.text.strip()),  # 语音合成
-        Comp.Unknown: lambda comp: bool(comp.text and comp.text.strip()),  # 未知消息
-        Comp.File: lambda comp: bool(comp.file),  # 文件
-        Comp.WechatEmoji: lambda comp: bool(comp.md5),  # 微信表情
+        Comp.File: lambda comp: bool(comp.file_ or comp.url),
+        Comp.WechatEmoji: lambda comp: comp.md5 is not None,  # 微信表情
     }
 
     async def initialize(self, ctx: PipelineContext):
@@ -79,7 +59,7 @@ class RespondStage(Stage):
             "segmented_reply"
         ]["interval_method"]
         self.log_base = float(
-            ctx.astrbot_config["platform_settings"]["segmented_reply"]["log_base"]
+            ctx.astrbot_config["platform_settings"]["segmented_reply"]["log_base"],
         )
         interval_str: str = ctx.astrbot_config["platform_settings"]["segmented_reply"][
             "interval"
@@ -107,17 +87,16 @@ class RespondStage(Stage):
                 wc = await self._word_cnt(comp.text)
                 i = math.log(wc + 1, self.log_base)
                 return random.uniform(i, i + 0.5)
-            else:
-                return random.uniform(1, 1.75)
-        else:
-            # random
-            return random.uniform(self.interval[0], self.interval[1])
+            return random.uniform(1, 1.75)
+        # random
+        return random.uniform(self.interval[0], self.interval[1])
 
     async def _is_empty_message_chain(self, chain: list[BaseMessageComponent]):
         """检查消息链是否为空
 
         Args:
             chain (list[BaseMessageComponent]): 包含消息对象的列表
+
         """
         if not chain:
             return True
@@ -129,32 +108,77 @@ class RespondStage(Stage):
             if comp_type in self._component_validators:
                 if self._component_validators[comp_type](comp):
                     return False
-            else:
-                logger.info(f"空内容检查: 无法识别的组件类型: {comp_type.__name__}")
 
         # 如果所有组件都为空
         return True
 
+    def is_seg_reply_required(self, event: AstrMessageEvent) -> bool:
+        """检查是否需要分段回复"""
+        if not self.enable_seg:
+            return False
+
+        if self.only_llm_result and not event.get_result().is_llm_result():
+            return False
+
+        if event.get_platform_name() in [
+            "qq_official",
+            "weixin_official_account",
+            "dingtalk",
+        ]:
+            return False
+
+        return True
+
+    def _extract_comp(
+        self,
+        raw_chain: list[BaseMessageComponent],
+        extract_types: set[ComponentType],
+        modify_raw_chain: bool = True,
+    ):
+        extracted = []
+        if modify_raw_chain:
+            remaining = []
+            for comp in raw_chain:
+                if comp.type in extract_types:
+                    extracted.append(comp)
+                else:
+                    remaining.append(comp)
+            raw_chain[:] = remaining
+        else:
+            extracted = [comp for comp in raw_chain if comp.type in extract_types]
+
+        return extracted
+
     async def process(
-        self, event: AstrMessageEvent
-    ) -> Union[None, AsyncGenerator[None, None]]:
+        self,
+        event: AstrMessageEvent,
+    ) -> None | AsyncGenerator[None, None]:
         result = event.get_result()
         if result is None:
             return
         if result.result_content_type == ResultContentType.STREAMING_FINISH:
             return
 
+        logger.info(
+            f"Prepare to send - {event.get_sender_name()}/{event.get_sender_id()}: {event._outline_chain(result.chain)}",
+        )
+
         if result.result_content_type == ResultContentType.STREAMING_RESULT:
+            if result.async_stream is None:
+                logger.warning("async_stream 为空，跳过发送。")
+                return
             # 流式结果直接交付平台适配器处理
-            use_fallback = self.config.get("provider_settings", {}).get(
-                "streaming_segmented", False
+            realtime_segmenting = (
+                self.config.get("provider_settings", {}).get(
+                    "unsupported_streaming_strategy",
+                    "realtime_segmenting",
+                )
+                == "realtime_segmenting"
             )
-            logger.info(f"应用流式输出({event.get_platform_name()})")
-            await event._pre_send()
-            await event.send_streaming(result.async_stream, use_fallback)
-            await event._post_send()
+            logger.info(f"应用流式输出({event.get_platform_id()})")
+            await event.send_streaming(result.async_stream, realtime_segmenting)
             return
-        elif len(result.chain) > 0:
+        if len(result.chain) > 0:
             # 检查路径映射
             if mappings := self.platform_settings.get("path_mapping", []):
                 for idx, component in enumerate(result.chain):
@@ -163,71 +187,88 @@ class RespondStage(Stage):
                         component.file = path_Mapping(mappings, component.file)
                         event.get_result().chain[idx] = component
 
-            await event._pre_send()
-
             # 检查消息链是否为空
             try:
                 if await self._is_empty_message_chain(result.chain):
                     logger.info("消息为空，跳过发送阶段")
-                    event.clear_result()
-                    event.stop_event()
                     return
             except Exception as e:
                 logger.warning(f"空内容检查异常: {e}")
 
-            if self.enable_seg and (
-                (self.only_llm_result and result.is_llm_result())
-                or not self.only_llm_result
-            ):
-                decorated_comps = []
-                if self.reply_with_mention:
-                    for comp in result.chain:
-                        if isinstance(comp, Comp.At):
-                            decorated_comps.append(comp)
-                            result.chain.remove(comp)
-                            break
-                if self.reply_with_quote:
-                    for comp in result.chain:
-                        if isinstance(comp, Comp.Reply):
-                            decorated_comps.append(comp)
-                            result.chain.remove(comp)
-                            break
-                # 分段回复
+            # 将 Plain 为空的消息段移除
+            result.chain = [
+                comp
+                for comp in result.chain
+                if not (
+                    isinstance(comp, Comp.Plain)
+                    and (not comp.text or not comp.text.strip())
+                )
+            ]
+
+            # 发送消息链
+            # Record 需要强制单独发送
+            need_separately = {ComponentType.Record}
+            if self.is_seg_reply_required(event):
+                header_comps = self._extract_comp(
+                    result.chain,
+                    {ComponentType.Reply, ComponentType.At},
+                    modify_raw_chain=True,
+                )
+                if not result.chain or len(result.chain) == 0:
+                    # may fix #2670
+                    logger.warning(
+                        f"实际消息链为空, 跳过发送阶段。header_chain: {header_comps}, actual_chain: {result.chain}",
+                    )
+                    return
                 for comp in result.chain:
                     i = await self._calc_comp_interval(comp)
                     await asyncio.sleep(i)
                     try:
-                        await event.send(MessageChain([*decorated_comps, comp]))
+                        if comp.type in need_separately:
+                            await event.send(MessageChain([comp]))
+                        else:
+                            await event.send(MessageChain([*header_comps, comp]))
+                            header_comps.clear()
                     except Exception as e:
-                        logger.error(f"发送消息失败: {e} chain: {result.chain}")
-                        break
+                        logger.error(
+                            f"发送消息链失败: chain = {MessageChain([comp])}, error = {e}",
+                            exc_info=True,
+                        )
             else:
-                try:
-                    await event.send(result)
-                except Exception as e:
-                    logger.error(traceback.format_exc())
-                    logger.error(f"发送消息失败: {e} chain: {result.chain}")
-            await event._post_send()
-            logger.info(
-                f"AstrBot -> {event.get_sender_name()}/{event.get_sender_id()}: {event._outline_chain(result.chain)}"
-            )
-
-        handlers = star_handlers_registry.get_handlers_by_event_type(
-            EventType.OnAfterMessageSentEvent, platform_id=event.get_platform_id()
-        )
-        for handler in handlers:
-            try:
-                logger.debug(
-                    f"hook(on_after_message_sent) -> {star_map[handler.handler_module_path].name} - {handler.handler_name}"
+                if all(
+                    comp.type in {ComponentType.Reply, ComponentType.At}
+                    for comp in result.chain
+                ):
+                    # may fix #2670
+                    logger.warning(
+                        f"消息链全为 Reply 和 At 消息段, 跳过发送阶段。chain: {result.chain}",
+                    )
+                    return
+                sep_comps = self._extract_comp(
+                    result.chain,
+                    need_separately,
+                    modify_raw_chain=True,
                 )
-                await handler.handler(event)
-            except BaseException:
-                logger.error(traceback.format_exc())
+                for comp in sep_comps:
+                    chain = MessageChain([comp])
+                    try:
+                        await event.send(chain)
+                    except Exception as e:
+                        logger.error(
+                            f"发送消息链失败: chain = {chain}, error = {e}",
+                            exc_info=True,
+                        )
+                chain = MessageChain(result.chain)
+                if result.chain and len(result.chain) > 0:
+                    try:
+                        await event.send(chain)
+                    except Exception as e:
+                        logger.error(
+                            f"发送消息链失败: chain = {chain}, error = {e}",
+                            exc_info=True,
+                        )
 
-            if event.is_stopped():
-                logger.info(
-                    f"{star_map[handler.handler_module_path].name} - {handler.handler_name} 终止了事件传播。"
-                )
-                return
+        if await call_event_hook(event, EventType.OnAfterMessageSentEvent):
+            return
 
         event.clear_result()

astrbot/core/pipeline/result_decorate/stage.py

@@ -1,17 +1,19 @@
-import time
 import re
+import time
 import traceback
-from typing import Union, AsyncGenerator
-from ..stage import Stage, register_stage, registered_stages
-from ..context import PipelineContext
-from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from collections.abc import AsyncGenerator
+
+from astrbot.core import file_token_service, html_renderer, logger
+from astrbot.core.message.components import At, File, Image, Node, Plain, Record, Reply
 from astrbot.core.message.message_event_result import ResultContentType
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
 from astrbot.core.platform.message_type import MessageType
-from astrbot.core import logger
-from astrbot.core.message.components import Plain, Image, At, Reply, Record, File, Node
-from astrbot.core import html_renderer
-from astrbot.core.star.star_handler import star_handlers_registry, EventType
+from astrbot.core.star.session_llm_manager import SessionServiceManager
 from astrbot.core.star.star import star_map
+from astrbot.core.star.star_handler import EventType, star_handlers_registry
+
+from ..context import PipelineContext
+from ..stage import Stage, register_stage, registered_stages
 
 
 @register_stage
@@ -28,12 +30,12 @@ class ResultDecorateStage(Stage):
         self.t2i_word_threshold = ctx.astrbot_config["t2i_word_threshold"]
         try:
             self.t2i_word_threshold = int(self.t2i_word_threshold)
-            if self.t2i_word_threshold < 50:
-                self.t2i_word_threshold = 50
+            self.t2i_word_threshold = max(self.t2i_word_threshold, 50)
         except BaseException:
             self.t2i_word_threshold = 150
         self.t2i_strategy = ctx.astrbot_config["t2i_strategy"]
         self.t2i_use_network = self.t2i_strategy == "remote"
+        self.t2i_active_template = ctx.astrbot_config["t2i_active_template"]
 
         self.forward_threshold = ctx.astrbot_config["platform_settings"][
             "forward_threshold"
@@ -43,7 +45,7 @@ class ResultDecorateStage(Stage):
         self.words_count_threshold = int(
             ctx.astrbot_config["platform_settings"]["segmented_reply"][
                 "words_count_threshold"
-            ]
+            ],
         )
         self.enable_segmented_reply = ctx.astrbot_config["platform_settings"][
             "segmented_reply"
@@ -62,13 +64,15 @@ class ResultDecorateStage(Stage):
         ]
         self.content_safe_check_stage = None
         if self.content_safe_check_reply:
-            for stage in registered_stages:
-                if stage.__class__.__name__ == "ContentSafetyCheckStage":
-                    self.content_safe_check_stage = stage
+            for stage_cls in registered_stages:
+                if stage_cls.__name__ == "ContentSafetyCheckStage":
+                    self.content_safe_check_stage = stage_cls()
+                    await self.content_safe_check_stage.initialize(ctx)
 
     async def process(
-        self, event: AstrMessageEvent
-    ) -> Union[None, AsyncGenerator[None, None]]:
+        self,
+        event: AstrMessageEvent,
+    ) -> None | AsyncGenerator[None, None]:
         result = event.get_result()
         if result is None or not result.chain:
             return
@@ -90,34 +94,36 @@ class ResultDecorateStage(Stage):
                 if isinstance(comp, Plain):
                     text += comp.text
             async for _ in self.content_safe_check_stage.process(
-                event, check_text=text
+                event,
+                check_text=text,
             ):
                 yield
 
         # 发送消息前事件钩子
         handlers = star_handlers_registry.get_handlers_by_event_type(
-            EventType.OnDecoratingResultEvent, platform_id=event.get_platform_id()
+            EventType.OnDecoratingResultEvent,
+            plugins_name=event.plugins_name,
         )
         for handler in handlers:
             try:
                 logger.debug(
-                    f"hook(on_decorating_result) -> {star_map[handler.handler_module_path].name} - {handler.handler_name}"
+                    f"hook(on_decorating_result) -> {star_map[handler.handler_module_path].name} - {handler.handler_name}",
                 )
                 if is_stream:
                     logger.warning(
-                        "启用流式输出时，依赖发送消息前事件钩子的插件可能无法正常工作"
+                        "启用流式输出时，依赖发送消息前事件钩子的插件可能无法正常工作",
                     )
                 await handler.handler(event)
                 if event.get_result() is None or not event.get_result().chain:
                     logger.debug(
-                        f"hook(on_decorating_result) -> {star_map[handler.handler_module_path].name} - {handler.handler_name} 将消息结果清空。"
+                        f"hook(on_decorating_result) -> {star_map[handler.handler_module_path].name} - {handler.handler_name} 将消息结果清空。",
                     )
             except BaseException:
                 logger.error(traceback.format_exc())
 
             if event.is_stopped():
                 logger.info(
-                    f"{star_map[handler.handler_module_path].name} - {handler.handler_name} 终止了事件传播。"
+                    f"{star_map[handler.handler_module_path].name} - {handler.handler_name} 终止了事件传播。",
                 )
                 return
 
@@ -140,7 +146,11 @@ class ResultDecorateStage(Stage):
                         break
 
             # 分段回复
-            if self.enable_segmented_reply:
+            if self.enable_segmented_reply and event.get_platform_name() not in [
+                "qq_official",
+                "weixin_official_account",
+                "dingtalk",
+            ]:
                 if (
                     self.only_llm_result and result.is_llm_result()
                 ) or not self.only_llm_result:
@@ -151,9 +161,21 @@ class ResultDecorateStage(Stage):
                                 # 不分段回复
                                 new_chain.append(comp)
                                 continue
-                            split_response = re.findall(
-                                self.regex, comp.text, re.DOTALL | re.MULTILINE
-                            )
+                            try:
+                                split_response = re.findall(
+                                    self.regex,
+                                    comp.text,
+                                    re.DOTALL | re.MULTILINE,
+                                )
+                            except re.error:
+                                logger.error(
+                                    f"分段回复正则表达式错误，使用默认分段方式: {traceback.format_exc()}",
+                                )
+                                split_response = re.findall(
+                                    r".*?[。？！~…]+|.+$",
+                                    comp.text,
+                                    re.DOTALL | re.MULTILINE,
+                                )
                             if not split_response:
                                 new_chain.append(comp)
                                 continue
@@ -168,68 +190,110 @@ class ResultDecorateStage(Stage):
                     result.chain = new_chain
 
             # TTS
+            tts_provider = self.ctx.plugin_manager.context.get_using_tts_provider(
+                event.unified_msg_origin,
+            )
+
             if (
                 self.ctx.astrbot_config["provider_tts_settings"]["enable"]
                 and result.is_llm_result()
+                and SessionServiceManager.should_process_tts_request(event)
             ):
-                tts_provider = self.ctx.plugin_manager.context.provider_manager.curr_tts_provider_inst
-                new_chain = []
-                for comp in result.chain:
-                    if isinstance(comp, Plain) and len(comp.text) > 1:
-                        try:
-                            logger.info("TTS 请求: " + comp.text)
-                            audio_path = await tts_provider.get_audio(comp.text)
-                            logger.info("TTS 结果: " + audio_path)
-                            if audio_path:
+                if not tts_provider:
+                    logger.warning(
+                        f"会话 {event.unified_msg_origin} 未配置文本转语音模型。",
+                    )
+                else:
+                    new_chain = []
+                    for comp in result.chain:
+                        if isinstance(comp, Plain) and len(comp.text) > 1:
+                            try:
+                                logger.info(f"TTS 请求: {comp.text}")
+                                audio_path = await tts_provider.get_audio(comp.text)
+                                logger.info(f"TTS 结果: {audio_path}")
+                                if not audio_path:
+                                    logger.error(
+                                        f"由于 TTS 音频文件未找到，消息段转语音失败: {comp.text}",
+                                    )
+                                    new_chain.append(comp)
+                                    continue
+
+                                use_file_service = self.ctx.astrbot_config[
+                                    "provider_tts_settings"
+                                ]["use_file_service"]
+                                callback_api_base = self.ctx.astrbot_config[
+                                    "callback_api_base"
+                                ]
+                                dual_output = self.ctx.astrbot_config[
+                                    "provider_tts_settings"
+                                ]["dual_output"]
+
+                                url = None
+                                if use_file_service and callback_api_base:
+                                    token = await file_token_service.register_file(
+                                        audio_path,
+                                    )
+                                    url = f"{callback_api_base}/api/file/{token}"
+                                    logger.debug(f"已注册：{url}")
+
                                 new_chain.append(
-                                    Record(file=audio_path, url=audio_path)
+                                    Record(
+                                        file=url or audio_path,
+                                        url=url or audio_path,
+                                    ),
                                 )
-                                if(self.ctx.astrbot_config["provider_tts_settings"]["dual_output"]):
+                                if dual_output:
                                     new_chain.append(comp)
-                            else:
-                                logger.error(
-                                    f"由于 TTS 音频文件没找到，消息段转语音失败: {comp.text}"
-                                )
+                            except Exception:
+                                logger.error(traceback.format_exc())
+                                logger.error("TTS 失败，使用文本发送。")
                                 new_chain.append(comp)
-                        except BaseException:
-                            logger.error(traceback.format_exc())
-                            logger.error("TTS 失败，使用文本发送。")
+                        else:
                             new_chain.append(comp)
-                    else:
-                        new_chain.append(comp)
-                result.chain = new_chain
+                    result.chain = new_chain
 
             # 文本转图片
             elif (
                 result.use_t2i_ is None and self.ctx.astrbot_config["t2i"]
             ) or result.use_t2i_:
-                plain_str = ""
+                parts = []
                 for comp in result.chain:
                     if isinstance(comp, Plain):
-                        plain_str += "\n\n" + comp.text
+                        parts.append("\n\n" + comp.text)
                     else:
                         break
+                plain_str = "".join(parts)
                 if plain_str and len(plain_str) > self.t2i_word_threshold:
                     render_start = time.time()
                     try:
                         url = await html_renderer.render_t2i(
-                            plain_str, return_url=True, use_network=self.t2i_use_network
+                            plain_str,
+                            return_url=True,
+                            use_network=self.t2i_use_network,
+                            template_name=self.t2i_active_template,
                         )
                     except BaseException:
                         logger.error("文本转图片失败，使用文本发送。")
                         return
                     if time.time() - render_start > 3:
                         logger.warning(
-                            "文本转图片耗时超过了 3 秒，如果觉得很慢可以使用 /t2i 关闭文本转图片模式。"
+                            "文本转图片耗时超过了 3 秒，如果觉得很慢可以使用 /t2i 关闭文本转图片模式。",
                         )
                     if url:
                         if url.startswith("http"):
                             result.chain = [Image.fromURL(url)]
+                        elif (
+                            self.ctx.astrbot_config["t2i_use_file_service"]
+                            and self.ctx.astrbot_config["callback_api_base"]
+                        ):
+                            token = await file_token_service.register_file(url)
+                            url = f"{self.ctx.astrbot_config['callback_api_base']}/api/file/{token}"
+                            logger.debug(f"已注册：{url}")
+                            result.chain = [Image.fromURL(url)]
                         else:
                             result.chain = [Image.fromFileSystem(url)]
 
             # 触发转发消息
-            has_forwarded = False
             if event.get_platform_name() == "aiocqhttp":
                 word_cnt = 0
                 for comp in result.chain:
@@ -237,19 +301,22 @@ class ResultDecorateStage(Stage):
                         word_cnt += len(comp.text)
                 if word_cnt > self.forward_threshold:
                     node = Node(
-                        uin=event.get_self_id(), name="AstrBot", content=[*result.chain]
+                        uin=event.get_self_id(),
+                        name="AstrBot",
+                        content=[*result.chain],
                     )
                     result.chain = [node]
-                    has_forwarded = True
 
-            if not has_forwarded:
+            has_plain = any(isinstance(item, Plain) for item in result.chain)
+            if has_plain:
                 # at 回复
                 if (
                     self.reply_with_mention
                     and event.get_message_type() != MessageType.FRIEND_MESSAGE
                 ):
                     result.chain.insert(
-                        0, At(qq=event.get_sender_id(), name=event.get_sender_name())
+                        0,
+                        At(qq=event.get_sender_id(), name=event.get_sender_name()),
                     )
                     if len(result.chain) > 1 and isinstance(result.chain[1], Plain):
                         result.chain[1].text = "\n" + result.chain[1].text