feat：整合normal和focus聊天

src/chat/replyer/default_generator.py

@@ -136,33 +136,6 @@ class DefaultReplyer:
         selected_config = random.choices(population=configs, weights=weights, k=1)[0]
         return selected_config
 
-    async def _create_thinking_message(self, anchor_message: Optional[MessageRecv], thinking_id: str):
-        """创建思考消息 (尝试锚定到 anchor_message)"""
-        if not anchor_message or not anchor_message.chat_stream:
-            logger.error(f"{self.log_prefix} 无法创建思考消息，缺少有效的锚点消息或聊天流。")
-            return None
-
-        chat = anchor_message.chat_stream
-        messageinfo = anchor_message.message_info
-        thinking_time_point = parse_thinking_id_to_timestamp(thinking_id)
-        bot_user_info = UserInfo(
-            user_id=global_config.bot.qq_account,
-            user_nickname=global_config.bot.nickname,
-            platform=messageinfo.platform,
-        )
-
-        thinking_message = MessageThinking(
-            message_id=thinking_id,
-            chat_stream=chat,
-            bot_user_info=bot_user_info,
-            reply=anchor_message,  # 回复的是锚点消息
-            thinking_start_time=thinking_time_point,
-        )
-        # logger.debug(f"创建思考消息thinking_message：{thinking_message}")
-
-        await self.heart_fc_sender.register_thinking(thinking_message)
-        return None
-
     async def generate_reply_with_context(
         self,
         reply_data: Dict[str, Any] = None,
@@ -812,108 +785,6 @@ class DefaultReplyer:
 
         return prompt
 
-    async def send_response_messages(
-        self,
-        anchor_message: Optional[MessageRecv],
-        response_set: List[Tuple[str, str]],
-        thinking_id: str = "",
-        display_message: str = "",
-    ) -> Optional[MessageSending]:
-        """发送回复消息 (尝试锚定到 anchor_message)，使用 HeartFCSender"""
-        chat = self.chat_stream
-        chat_id = self.chat_stream.stream_id
-        if chat is None:
-            logger.error(f"{self.log_prefix} 无法发送回复，chat_stream 为空。")
-            return None
-        if not anchor_message:
-            logger.error(f"{self.log_prefix} 无法发送回复，anchor_message 为空。")
-            return None
-
-        stream_name = get_chat_manager().get_stream_name(chat_id) or chat_id  # 获取流名称用于日志
-
-        # 检查思考过程是否仍在进行，并获取开始时间
-        if thinking_id:
-            # print(f"thinking_id: {thinking_id}")
-            thinking_start_time = await self.heart_fc_sender.get_thinking_start_time(chat_id, thinking_id)
-        else:
-            print("thinking_id is None")
-            # thinking_id = "ds" + str(round(time.time(), 2))
-            thinking_start_time = time.time()
-
-        if thinking_start_time is None:
-            logger.error(f"[{stream_name}]replyer思考过程未找到或已结束，无法发送回复。")
-            return None
-
-        mark_head = False
-        # first_bot_msg: Optional[MessageSending] = None
-        reply_message_ids = []  # 记录实际发送的消息ID
-
-        sent_msg_list = []
-
-        for i, msg_text in enumerate(response_set):
-            # 为每个消息片段生成唯一ID
-            type = msg_text[0]
-            data = msg_text[1]
-
-            if global_config.debug.debug_show_chat_mode and type == "text":
-                data += "ᶠ"
-
-            part_message_id = f"{thinking_id}_{i}"
-            message_segment = Seg(type=type, data=data)
-
-            if type == "emoji":
-                is_emoji = True
-            else:
-                is_emoji = False
-            reply_to = not mark_head
-
-            bot_message: MessageSending = await self._build_single_sending_message(
-                anchor_message=anchor_message,
-                message_id=part_message_id,
-                message_segment=message_segment,
-                display_message=display_message,
-                reply_to=reply_to,
-                is_emoji=is_emoji,
-                thinking_id=thinking_id,
-                thinking_start_time=thinking_start_time,
-            )
-
-            try:
-                if (
-                    bot_message.is_private_message()
-                    or bot_message.reply.processed_plain_text != "[System Trigger Context]"
-                    or mark_head
-                ):
-                    set_reply = False
-                else:
-                    set_reply = True
-
-                if not mark_head:
-                    mark_head = True
-                    typing = False
-                else:
-                    typing = True
-
-                sent_msg = await self.heart_fc_sender.send_message(bot_message, typing=typing, set_reply=set_reply)
-
-                reply_message_ids.append(part_message_id)  # 记录我们生成的ID
-
-                sent_msg_list.append((type, sent_msg))
-
-            except Exception as e:
-                logger.error(f"{self.log_prefix}发送回复片段 {i} ({part_message_id}) 时失败: {e}")
-                traceback.print_exc()
-                # 这里可以选择是继续发送下一个片段还是中止
-
-        # 在尝试发送完所有片段后，完成原始的 thinking_id 状态
-        try:
-            await self.heart_fc_sender.complete_thinking(chat_id, thinking_id)
-
-        except Exception as e:
-            logger.error(f"{self.log_prefix}完成思考状态 {thinking_id} 时出错: {e}")
-
-        return sent_msg_list
-
     async def _build_single_sending_message(
         self,
         message_id: str,