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

2025-08-11 14:07:57 +08:00
parent 3ae95a4014
commit 9c0f56f6c7
5 changed files with 163 additions and 212 deletions
--- a/src/chat/chat_loop/heartFC_chat.py
+++ b/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:
-        current_time = time.time()
+    async def _send_response(self, reply_set, message_data) -> str:
        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
--- a/src/chat/planner_actions/planner.py
+++ b/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 = """重要说明：
--- a/src/chat/replyer/default_generator.py
+++ b/src/chat/replyer/default_generator.py
@@ -97,8 +97,39 @@ 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(
        """
@@ -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,35 +677,27 @@ 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)
            mood_prompt = chat_mood.mood_state
        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}。引起了你的注意，你想要在群里发言或者回复这条消息。"
-                    )
-                elif target:
-                    reply_target_block = f"现在{target}引起了你的注意，你想要在群里发言或者回复这条消息。"
-                else:
-                    reply_target_block = "现在，你想要在群里发言或者回复消息。"
+                reply_target_block = (
+                    f"现在{sender}说的:{target}。引起了你的注意，你想要在群里发言或者回复这条消息。原因是{reply_reason}"
+                )
            else:  # private chat
-                if sender:
-                    reply_target_block = f"现在{sender}说的:{target}。引起了你的注意，针对这条消息回复。"
-                elif target:
-                    reply_target_block = f"现在{target}引起了你的注意，针对这条消息回复。"
-                else:
-                    reply_target_block = "现在，你想要回复。"
+                reply_target_block = f"现在{sender}说的:{target}。引起了你的注意，针对这条消息回复。原因是{reply_reason}"
        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,69 +809,52 @@ 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(
-            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,
-            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,
-            sender_name=sender,
-            mood_state=mood_prompt,
-            background_dialogue_prompt=background_dialogue_prompt,
-            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,
-        )
+        if global_config.bot.qq_account == user_id and platform == global_config.bot.platform:
+            return await global_prompt_manager.format_prompt(
+                "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,
+                memory_block=memory_block,
+                relation_info_block=relation_info,
+                extra_info_block=extra_info_block,
+                identity=identity_block,
+                action_descriptions=action_descriptions,
+                sender_name=sender,
+                mood_state=mood_prompt,
+                background_dialogue_prompt=background_dialogue_prompt,
+                time_block=time_block,
+                core_dialogue_prompt=core_dialogue_prompt,
+                reply_target_block=reply_target_block,
+                reply_style=global_config.personality.reply_style,
+                keywords_reaction_prompt=keywords_reaction_prompt,
+                moderation_prompt=moderation_prompt_block,
+            )

    async def build_prompt_rewrite_context(
        self,