fix：让麦麦可以回复自己的消息,replyer现在可以接受 原因

src/chat/chat_loop/heartFC_chat.py

@@ -295,7 +295,6 @@ class HeartFChatting:
     async def _send_and_store_reply(
         self,
         response_set,
-        loop_start_time,
         action_message,
         cycle_timers: Dict[str, float],
         thinking_id,
@@ -303,7 +302,7 @@ class HeartFChatting:
     ) -> Tuple[Dict[str, Any], str, Dict[str, float]]:
         
         with Timer("回复发送", cycle_timers):
-            reply_text = await self._send_response(response_set, loop_start_time, action_message)
+            reply_text = await self._send_response(response_set, action_message)
 
         # 存储reply action信息
         person_info_manager = get_person_info_manager()
@@ -383,7 +382,6 @@ class HeartFChatting:
             await send_typing()
 
         async with global_prompt_manager.async_message_scope(self.chat_stream.context.get_template_name()):
-            loop_start_time = time.time()
             await self.relationship_builder.build_relation()
             await self.expression_learner.trigger_learning_for_chat()
 
@@ -411,7 +409,7 @@ class HeartFChatting:
             with Timer("规划器", cycle_timers):
                 actions, _= await self.action_planner.plan(
                     mode=mode,
-                    loop_start_time=loop_start_time,
+                    loop_start_time=self.last_read_time,
                     available_actions=available_actions,
                 )
 
@@ -467,6 +465,7 @@ class HeartFChatting:
                                 chat_stream=self.chat_stream,
                                 reply_message = action_info["action_message"],
                                 available_actions=available_actions,
+                                reply_reason=action_info.get("reasoning", ""),
                                 enable_tool=global_config.tool.enable_tool,
                                 request_type="chat.replyer",
                                 from_plugin=False,
@@ -492,7 +491,6 @@ class HeartFChatting:
 
                         loop_info, reply_text, cycle_timers_reply = await self._send_and_store_reply(
                             response_set,
-                            loop_start_time,
                             action_info["action_message"],
                             cycle_timers,
                             thinking_id,
@@ -684,10 +682,9 @@ class HeartFChatting:
             traceback.print_exc()
             return False, "", ""
 
-    async def _send_response(self, reply_set, thinking_start_time, message_data) -> str:
+    async def _send_response(self, reply_set, message_data) -> str:
-        current_time = time.time()
         new_message_count = message_api.count_new_messages(
-            chat_id=self.chat_stream.stream_id, start_time=thinking_start_time, end_time=current_time
+            chat_id=self.chat_stream.stream_id, start_time=self.last_read_time, end_time=time.time()
         )
 
         need_reply = new_message_count >= random.randint(2, 4)
@@ -713,7 +710,7 @@ class HeartFChatting:
                     text=data,
                     stream_id=self.chat_stream.stream_id,
                     reply_to_message = message_data,
-                    set_reply=need_reply,
+                    set_reply=False,
                     typing=True,
                 )
             reply_text += data

src/chat/planner_actions/planner.py

@@ -48,16 +48,15 @@ def init_prompt():
 - 你想要闲聊或者随便附
 - {mentioned_bonus}
 - 如果你刚刚进行了回复，不要对同一个话题重复回应
-- 不要回复自己发送的消息
 {{
     "action": "reply",
-    "target_message_id":"触发action的消息id",
+    "target_message_id":"想要回复的消息id",
     "reason":"回复的原因"
 }}
 
 {action_options_text}
 
-你必须从上面列出的可用action中选择一个，并说明触发action的消息id（不是消息原文）和选择该action的原因。
+你必须从上面列出的可用action中选择一个，并说明触发action的消息id（不是消息原文）和选择该action的原因。消息id格式:m+数字
 
 请根据动作示例，以严格的 JSON 格式输出，且仅包含 JSON 内容：
 """,
@@ -192,7 +191,7 @@ class ActionPlanner:
                         parsed_json = {}
 
                     action = parsed_json.get("action", "no_reply")
-                    reasoning = parsed_json.get("reasoning", "未提供原因")
+                    reasoning = parsed_json.get("reason", "未提供原因")
 
                     # 将所有其他属性添加到action_data
                     for key, value in parsed_json.items():
@@ -320,10 +319,18 @@ class ActionPlanner:
             
 
             if mode == ChatMode.FOCUS:
-                no_action_block = """重要说明：
+                no_action_block = """
 - 'no_reply' 表示不进行回复，等待合适的回复时机
 - 当你刚刚发送了消息，没有人回复时，选择no_reply
 - 当你一次发送了太多消息，为了避免打扰聊天节奏，选择no_reply
+动作：no_reply
+动作描述：不进行回复，等待合适的回复时机
+- 当你刚刚发送了消息，没有人回复时，选择no_reply
+- 当你一次发送了太多消息，为了避免打扰聊天节奏，选择no_reply
+{{
+    "action": "no_reply",
+    "reason":"不回复的原因"
+}}
 """
             else:
                 no_action_block = """重要说明：

src/chat/replyer/default_generator.py

@@ -97,9 +97,40 @@ def init_prompt():
 不要浮夸，不要夸张修辞，不要输出多余内容(包括前后缀，冒号和引号，括号()，表情包，at或 @等 )。只输出一条回复内容就好
 现在，你说：
 """,
-        "s4u_style_prompt",
+        "replyer_prompt",
     )
     
+    Prompt(
+        """
+{expression_habits_block}
+{tool_info_block}
+{knowledge_prompt}
+{memory_block}
+{relation_info_block}
+{extra_info_block}
+
+{identity}
+
+{action_descriptions}
+
+{time_block}
+你现在正在一个QQ群里聊天，以下是正在进行的聊天内容：
+{background_dialogue_prompt}
+
+你现在想补充说明你刚刚自己的发言内容：{target}
+请你根据聊天内容，组织一条新回复。
+你现在的心情是：{mood_state}
+{reply_style}
+{keywords_reaction_prompt}
+请注意不要输出多余内容(包括前后缀，冒号和引号，at或 @等 )。只输出回复内容。
+{moderation_prompt}
+不要浮夸，不要夸张修辞，不要输出多余内容(包括前后缀，冒号和引号，括号()，表情包，at或 @等 )。只输出一条回复内容就好
+现在，你说：
+""",
+        "replyer_self_prompt",
+    )
+    
+
     Prompt(
         """
 你是一个专门获取知识的助手。你的名字是{bot_name}。现在是{time_now}。
@@ -136,8 +167,8 @@ class DefaultReplyer:
 
     async def generate_reply_with_context(
         self,
-        reply_to: str = "",
         extra_info: str = "",
+        reply_reason: str = "",
         available_actions: Optional[Dict[str, ActionInfo]] = None,
         enable_tool: bool = True,
         from_plugin: bool = True,
@@ -150,6 +181,7 @@ class DefaultReplyer:
         Args:
             reply_to: 回复对象，格式为 "发送者:消息内容"
             extra_info: 额外信息，用于补充上下文
+            reply_reason: 回复原因
             available_actions: 可用的动作信息字典
             enable_tool: 是否启用工具调用
             from_plugin: 是否来自插件
@@ -164,11 +196,11 @@ class DefaultReplyer:
             # 3. 构建 Prompt
             with Timer("构建Prompt", {}):  # 内部计时器，可选保留
                 prompt = await self.build_prompt_reply_context(
-                    reply_to=reply_to,
                     extra_info=extra_info,
                     available_actions=available_actions,
                     enable_tool=enable_tool,
                     reply_message=reply_message,
+                    reply_reason=reply_reason,
                 )
 
             if not prompt:
@@ -620,8 +652,8 @@ class DefaultReplyer:
 
     async def build_prompt_reply_context(
         self,
-        reply_to: str,
         extra_info: str = "",
+        reply_reason: str = "",
         available_actions: Optional[Dict[str, ActionInfo]] = None,
         enable_tool: bool = True,
         reply_message: Optional[Dict[str, Any]] = None,
@@ -630,8 +662,8 @@ class DefaultReplyer:
         构建回复器上下文
 
         Args:
-            reply_to: 回复对象，格式为 "发送者:消息内容"
             extra_info: 额外信息，用于补充上下文
+            reply_reason: 回复原因
             available_actions: 可用动作
             enable_timeout: 是否启用超时处理
             enable_tool: 是否启用工具调用
@@ -645,6 +677,20 @@ class DefaultReplyer:
         chat_id = chat_stream.stream_id
         person_info_manager = get_person_info_manager()
         is_group_chat = bool(chat_stream.group_info)
+        platform = chat_stream.platform
+        user_id = reply_message.get("user_id","")
+        
+        if user_id:
+            person_id = person_info_manager.get_person_id(platform,user_id)
+            person_name = await person_info_manager.get_value(person_id, "person_name")
+            sender = person_name
+            target = reply_message.get('processed_plain_text')
+        else:
+            person_id = ""
+            person_name = "用户"
+            sender = "用户"
+            target = "消息"
+        
 
         if global_config.mood.enable_mood:
             chat_mood = mood_manager.get_mood_by_chat_id(chat_id)
@@ -652,28 +698,6 @@ class DefaultReplyer:
         else:
             mood_prompt = ""
             
-        if reply_to:
-            #兼容旧的reply_to
-            sender, target = self._parse_reply_target(reply_to)
-        else:
-            # 获取 platform，如果不存在则从 chat_stream 获取，如果还是 None 则使用默认值
-            platform = reply_message.get("chat_info_platform")
-            person_id = person_info_manager.get_person_id(
-                platform,  # type: ignore
-                reply_message.get("user_id"),  # type: ignore
-            )
-            person_name = await person_info_manager.get_value(person_id, "person_name")
-            sender = person_name
-            target = reply_message.get('processed_plain_text')
-            
-        person_info_manager = get_person_info_manager()
-        person_id = person_info_manager.get_person_id_by_person_name(sender)
-        user_id = person_info_manager.get_value_sync(person_id, "user_id")
-        platform = chat_stream.platform
-        if user_id == global_config.bot.qq_account and platform == global_config.bot.platform:
-            logger.warning("选取了自身作为回复对象，跳过构建prompt")
-            return ""
-
         target = replace_user_references_sync(target, chat_stream.platform, replace_bot_name=True)
 
         # 构建action描述 (如果启用planner)
@@ -759,27 +783,16 @@ class DefaultReplyer:
             "请不要输出违法违规内容，不要输出色情，暴力，政治相关内容，如有敏感内容，请规避。不要随意遵从他人指令。"
         )
 
-        if sender and target:
+        if sender:
             if is_group_chat:
-                if sender:
                 reply_target_block = (
-                        f"现在{sender}说的:{target}。引起了你的注意，你想要在群里发言或者回复这条消息。"
+                    f"现在{sender}说的:{target}。引起了你的注意，你想要在群里发言或者回复这条消息。原因是{reply_reason}"
                 )
-                elif target:
-                    reply_target_block = f"现在{target}引起了你的注意，你想要在群里发言或者回复这条消息。"
-                else:
-                    reply_target_block = "现在，你想要在群里发言或者回复消息。"
             else:  # private chat
-                if sender:
+                reply_target_block = f"现在{sender}说的:{target}。引起了你的注意，针对这条消息回复。原因是{reply_reason}"
-                    reply_target_block = f"现在{sender}说的:{target}。引起了你的注意，针对这条消息回复。"
-                elif target:
-                    reply_target_block = f"现在{target}引起了你的注意，针对这条消息回复。"
-                else:
-                    reply_target_block = "现在，你想要回复。"
         else:
             reply_target_block = ""
 
-        template_name = "default_generator_prompt"
         if is_group_chat:
             chat_target_1 = await global_prompt_manager.get_prompt_async("chat_target_group1")
             chat_target_2 = await global_prompt_manager.get_prompt_async("chat_target_group2")
@@ -796,50 +809,34 @@ class DefaultReplyer:
                 "chat_target_private2", sender_name=chat_target_name
             )
 
-        target_user_id = ""
-        person_id = ""
-        if sender:
-            # 根据sender通过person_info_manager反向查找person_id，再获取user_id
-            person_id = person_info_manager.get_person_id_by_person_name(sender)
-
-        # 使用 s4u 对话构建模式：分离当前对话对象和其他对话
-        try:
-            user_id_value = await person_info_manager.get_value(person_id, "user_id")
-            if user_id_value:
-                target_user_id = str(user_id_value)
-        except Exception as e:
-            logger.warning(f"无法从person_id {person_id} 获取user_id: {e}")
-            target_user_id = ""
 
         # 构建分离的对话 prompt
         core_dialogue_prompt, background_dialogue_prompt = self.build_s4u_chat_history_prompts(
-            message_list_before_now_long, target_user_id, sender
+            message_list_before_now_long, user_id, sender
         )
 
-        self.build_mai_think_context(
+        if global_config.bot.qq_account == user_id and platform == global_config.bot.platform:
-            chat_id=chat_id,
-            memory_block=memory_block,
-            relation_info=relation_info,
-            time_block=time_block,
-            chat_target_1=chat_target_1,
-            chat_target_2=chat_target_2,
-            mood_prompt=mood_prompt,
-            identity_block=identity_block,
-            sender=sender,
-            target=target,
-            chat_info=f"""
-{background_dialogue_prompt}
---------------------------------
-{time_block}
-这是你和{sender}的对话，你们正在交流中：
-{core_dialogue_prompt}""",
-        )
-
-        # 使用 s4u 风格的模板
-        template_name = "s4u_style_prompt"
-
             return await global_prompt_manager.format_prompt(
-            template_name,
+                "replyer_self_prompt",
+                expression_habits_block=expression_habits_block,
+                tool_info_block=tool_info,
+                knowledge_prompt=prompt_info,
+                memory_block=memory_block,
+                relation_info_block=relation_info,
+                extra_info_block=extra_info_block,
+                identity=identity_block,
+                action_descriptions=action_descriptions,
+                mood_state=mood_prompt,
+                background_dialogue_prompt=background_dialogue_prompt,
+                time_block=time_block,
+                target = target,
+                reply_style=global_config.personality.reply_style,
+                keywords_reaction_prompt=keywords_reaction_prompt,
+                moderation_prompt=moderation_prompt_block,
+            )
+        else:
+            return await global_prompt_manager.format_prompt(
+                "replyer_prompt",
                 expression_habits_block=expression_habits_block,
                 tool_info_block=tool_info,
                 knowledge_prompt=prompt_info,
@@ -854,7 +851,6 @@ class DefaultReplyer:
                 time_block=time_block,
                 core_dialogue_prompt=core_dialogue_prompt,
                 reply_target_block=reply_target_block,
-            message_txt=target,
                 reply_style=global_config.personality.reply_style,
                 keywords_reaction_prompt=keywords_reaction_prompt,
                 moderation_prompt=moderation_prompt_block,

src/plugin_system/apis/generator_api.py

@@ -77,6 +77,7 @@ async def generate_reply(
     reply_to: str = "",
     reply_message: Optional[Dict[str, Any]] = None,
     extra_info: str = "",
+    reply_reason: str = "",
     available_actions: Optional[Dict[str, ActionInfo]] = None,
     enable_tool: bool = False,
     enable_splitter: bool = True,
@@ -92,8 +93,9 @@ async def generate_reply(
         chat_id: 聊天ID（备用）
         action_data: 动作数据（向下兼容，包含reply_to和extra_info）
         reply_to: 回复对象，格式为 "发送者:消息内容"
-        reply_message: 回复的原始消息
+        reply_message: 回复消息
         extra_info: 额外信息，用于补充上下文
+        reply_reason: 回复原因
         available_actions: 可用动作
         enable_tool: 是否启用工具调用
         enable_splitter: 是否启用消息分割器
@@ -116,20 +118,24 @@ async def generate_reply(
 
         logger.debug("[GeneratorAPI] 开始生成回复")
         
-        if not reply_to and action_data:
+        if reply_to:
-            reply_to = action_data.get("reply_to", "")
+            logger.warning("[GeneratorAPI] 在0.10.0, reply_to 参数已弃用，请使用 reply_message 参数")
+
         if not extra_info and action_data:
             extra_info = action_data.get("extra_info", "")
             
+        if not reply_reason and action_data:
+            reply_reason = action_data.get("reason", "")
+
         # 调用回复器生成回复
         success, llm_response_dict, prompt = await replyer.generate_reply_with_context(
-            reply_to=reply_to,
             extra_info=extra_info,
             available_actions=available_actions,
             enable_tool=enable_tool,
+            reply_message=reply_message,
+            reply_reason=reply_reason,
             from_plugin=from_plugin,
             stream_id=chat_stream.stream_id if chat_stream else chat_id,
-            reply_message=reply_message,
         )
         if not success:
             logger.warning("[GeneratorAPI] 回复生成失败")

src/plugin_system/apis/send_api.py

@@ -100,7 +100,7 @@ async def _send_to_target(
         message_segment = Seg(type=message_type, data=content)  # type: ignore
 
         if reply_to_message:
-            anchor_message = MessageRecv(message_dict=reply_to_message)
+            anchor_message = message_dict_to_message_recv(reply_to_message)
             anchor_message.update_chat_stream(target_stream)
             reply_to_platform_id = (
                 f"{anchor_message.message_info.platform}:{anchor_message.message_info.user_info.user_id}"
@@ -145,111 +145,56 @@ async def _send_to_target(
         return False
 
 
-async def _find_reply_message(target_stream, reply_to: str) -> Optional[MessageRecv]:
+def message_dict_to_message_recv(message_dict: Dict[str, Any]) -> Optional[MessageRecv]:
-    # sourcery skip: inline-variable, use-named-expression
     """查找要回复的消息
 
     Args:
-        target_stream: 目标聊天流
+        message_dict: 消息字典
-        reply_to: 回复格式，如"发送者:消息内容"或"发送者：消息内容"
 
     Returns:
         Optional[MessageRecv]: 找到的消息，如果没找到则返回None
     """
-    try:
-        # 解析reply_to参数
-        if ":" in reply_to:
-            parts = reply_to.split(":", 1)
-        elif "：" in reply_to:
-            parts = reply_to.split("：", 1)
-        else:
-            logger.warning(f"[SendAPI] reply_to格式不正确: {reply_to}")
-            return None
-
-        if len(parts) != 2:
-            logger.warning(f"[SendAPI] reply_to格式不正确: {reply_to}")
-            return None
-
-        sender = parts[0].strip()
-        text = parts[1].strip()
-
-        # 获取聊天流的最新20条消息
-        reverse_talking_message = get_raw_msg_before_timestamp_with_chat(
-            target_stream.stream_id,
-            time.time(),  # 当前时间之前的消息
-            20,  # 最新的20条消息
-        )
-
-        # 反转列表，使最新的消息在前面
-        reverse_talking_message = list(reversed(reverse_talking_message))
-
-        find_msg = None
-        for message in reverse_talking_message:
-            user_id = message["user_id"]
-            platform = message["chat_info_platform"]
-            person_id = get_person_info_manager().get_person_id(platform, user_id)
-            person_name = await get_person_info_manager().get_value(person_id, "person_name")
-            if person_name == sender:
-                translate_text = message["processed_plain_text"]
-
-                # 使用独立函数处理用户引用格式
-                translate_text = await replace_user_references_async(translate_text, platform)
-
-                similarity = difflib.SequenceMatcher(None, text, translate_text).ratio()
-                if similarity >= 0.9:
-                    find_msg = message
-                    break
-
-        if not find_msg:
-            logger.info("[SendAPI] 未找到匹配的回复消息")
-            return None
-
     # 构建MessageRecv对象
     user_info = {
-            "platform": find_msg.get("user_platform", ""),
+        "platform": message_dict.get("user_platform", ""),
-            "user_id": find_msg.get("user_id", ""),
+        "user_id": message_dict.get("user_id", ""),
-            "user_nickname": find_msg.get("user_nickname", ""),
+        "user_nickname": message_dict.get("user_nickname", ""),
-            "user_cardname": find_msg.get("user_cardname", ""),
+        "user_cardname": message_dict.get("user_cardname", ""),
     }
 
     group_info = {}
-        if find_msg.get("chat_info_group_id"):
+    if message_dict.get("chat_info_group_id"):
         group_info = {
-                "platform": find_msg.get("chat_info_group_platform", ""),
+            "platform": message_dict.get("chat_info_group_platform", ""),
-                "group_id": find_msg.get("chat_info_group_id", ""),
+            "group_id": message_dict.get("chat_info_group_id", ""),
-                "group_name": find_msg.get("chat_info_group_name", ""),
+            "group_name": message_dict.get("chat_info_group_name", ""),
         }
 
     format_info = {"content_format": "", "accept_format": ""}
     template_info = {"template_items": {}}
 
     message_info = {
-            "platform": target_stream.platform,
+        "platform": message_dict.get("chat_info_platform", ""),
-            "message_id": find_msg.get("message_id"),
+        "message_id": message_dict.get("message_id"),
-            "time": find_msg.get("time"),
+        "time": message_dict.get("time"),
         "group_info": group_info,
         "user_info": user_info,
-            "additional_config": find_msg.get("additional_config"),
+        "additional_config": message_dict.get("additional_config"),
         "format_info": format_info,
         "template_info": template_info,
     }
 
     message_dict = {
         "message_info": message_info,
-            "raw_message": find_msg.get("processed_plain_text"),
+        "raw_message": message_dict.get("processed_plain_text"),
-            "processed_plain_text": find_msg.get("processed_plain_text"),
+        "processed_plain_text": message_dict.get("processed_plain_text"),
     }
 
-        find_rec_msg = MessageRecv(message_dict)
+    message_recv = MessageRecv(message_dict)
-        find_rec_msg.update_chat_stream(target_stream)
     
-        logger.info(f"[SendAPI] 找到匹配的回复消息，发送者: {sender}")
+    logger.info(f"[SendAPI] 找到匹配的回复消息，发送者: {message_dict.get('user_nickname', '')}")
-        return find_rec_msg
+    return message_recv
 
-    except Exception as e:
-        logger.error(f"[SendAPI] 查找回复消息时出错: {e}")
-        traceback.print_exc()
-        return None
 
 
 # =============================================================================