Merge branch 'dev' of https://github.com/MaiM-with-u/MaiBot into groupnickname

.gitignore

@@ -5,6 +5,8 @@ NapCat.Framework.Windows.Once/
 log/
 logs/
 tool_call_benchmark.py
+run_maibot_core.bat
+run_napcat_adapter.bat
 run_ad.bat
 llm_tool_benchmark_results.json
 MaiBot-Napcat-Adapter-main

src/config/config.py

@@ -22,7 +22,7 @@ logger = get_logger("config")
 # 考虑到，实际上配置文件中的mai_version是不会自动更新的,所以采用硬编码
 is_test = False
 mai_version_main = "0.6.3"
-mai_version_fix = "fix-1"
+mai_version_fix = "fix-2"
 
 if mai_version_fix:
     if is_test:
@@ -268,6 +268,7 @@ class BotConfig:
     # experimental
     enable_friend_chat: bool = False  # 是否启用好友聊天
     # enable_think_flow: bool = False  # 是否启用思考流程
+    talk_allowed_private = set()
     enable_pfc_chatting: bool = False  # 是否启用PFC聊天
 
     # Group Nickname
@@ -672,6 +673,7 @@ class BotConfig:
             experimental_config = parent["experimental"]
             config.enable_friend_chat = experimental_config.get("enable_friend_chat", config.enable_friend_chat)
             # config.enable_think_flow = experimental_config.get("enable_think_flow", config.enable_think_flow)
+            config.talk_allowed_private = set(str(user) for user in experimental_config.get("talk_allowed_private", []))
             if config.INNER_VERSION in SpecifierSet(">=1.1.0"):
                 config.enable_pfc_chatting = experimental_config.get("pfc_chatting", config.enable_pfc_chatting)
 

src/do_tool/tool_can_use/compare_numbers_tool.py

@@ -9,7 +9,7 @@ class CompareNumbersTool(BaseTool):
     """比较两个数大小的工具"""
 
     name = "compare_numbers"
-    description = "比较两个数的大小，返回较大的数"
+    description = "使用工具 比较两个数的大小，返回较大的数"
     parameters = {
         "type": "object",
         "properties": {
@@ -39,10 +39,10 @@ class CompareNumbersTool(BaseTool):
             else:
                 result = f"{num1} 等于 {num2}"
 
-            return {"name": self.name, "content": result}
+            return {"type": "comparison_result", "id": f"{num1}_vs_{num2}", "content": result}
         except Exception as e:
             logger.error(f"比较数字失败: {str(e)}")
-            return {"name": self.name, "content": f"比较数字失败: {str(e)}"}
+            return {"type": "info", "id": f"{num1}_vs_{num2}", "content": f"比较数字失败，炸了: {str(e)}"}
 
 
 # 注册工具

src/do_tool/tool_can_use/get_knowledge.py

@@ -11,7 +11,7 @@ class SearchKnowledgeTool(BaseTool):
     """从知识库中搜索相关信息的工具"""
 
     name = "search_knowledge"
-    description = "从知识库中搜索相关信息"
+    description = "使用工具从知识库中搜索相关信息"
     parameters = {
         "type": "object",
         "properties": {
@@ -42,11 +42,11 @@ class SearchKnowledgeTool(BaseTool):
                     content = f"你知道这些知识: {knowledge_info}"
                 else:
                     content = f"你不太了解有关{query}的知识"
-                return {"name": "search_knowledge", "content": content}
-            return {"name": "search_knowledge", "content": f"无法获取关于'{query}'的嵌入向量"}
+                return {"type": "knowledge", "id": query, "content": content}
+            return {"type": "info", "id": query, "content": f"无法获取关于'{query}'的嵌入向量，你知识库炸了"}
         except Exception as e:
             logger.error(f"知识库搜索工具执行失败: {str(e)}")
-            return {"name": "search_knowledge", "content": f"知识库搜索失败: {str(e)}"}
+            return {"type": "info", "id": query, "content": f"知识库搜索失败，炸了: {str(e)}"}
 
     @staticmethod
     def get_info_from_db(

src/do_tool/tool_can_use/get_memory.py

@@ -10,7 +10,7 @@ class GetMemoryTool(BaseTool):
     """从记忆系统中获取相关记忆的工具"""
 
     name = "get_memory"
-    description = "从记忆系统中获取相关记忆"
+    description = "使用工具从记忆系统中获取相关记忆"
     parameters = {
         "type": "object",
         "properties": {
@@ -53,10 +53,11 @@ class GetMemoryTool(BaseTool):
             else:
                 content = f"{topic}的记忆，你记不太清"
 
-            return {"name": "get_memory", "content": content}
+            return {"type": "memory", "id": topic_list, "content": content}
         except Exception as e:
             logger.error(f"记忆获取工具执行失败: {str(e)}")
-            return {"name": "get_memory", "content": f"记忆获取失败: {str(e)}"}
+            # 在失败时也保持格式一致，但id可能不适用或设为None/Error
+            return {"type": "memory_error", "id": topic_list, "content": f"记忆获取失败: {str(e)}"}
 
 
 # 注册工具

src/do_tool/tool_can_use/get_time_date.py

@@ -2,6 +2,7 @@ from src.do_tool.tool_can_use.base_tool import BaseTool
 from src.common.logger_manager import get_logger
 from typing import Dict, Any
 from datetime import datetime
+import time
 
 logger = get_logger("get_time_date")
 
@@ -32,6 +33,7 @@ class GetCurrentDateTimeTool(BaseTool):
         current_weekday = datetime.now().strftime("%A")
 
         return {
-            "name": "get_current_date_time",
+            "type": "time_info",
+            "id": f"time_info_{time.time()}",
             "content": f"当前时间: {current_time}, 日期: {current_date}, 年份: {current_year}, 星期: {current_weekday}",
         }

src/do_tool/tool_can_use/lpmm_get_knowledge.py

@@ -46,11 +46,14 @@ class SearchKnowledgeFromLPMMTool(BaseTool):
                     content = f"你知道这些知识: {knowledge_info}"
                 else:
                     content = f"你不太了解有关{query}的知识"
-                return {"name": "search_knowledge", "content": content}
-            return {"name": "search_knowledge", "content": f"无法获取关于'{query}'的嵌入向量"}
+                return {"type": "lpmm_knowledge", "id": query, "content": content}
+            # 如果获取嵌入失败
+            return {"type": "info", "id": query, "content": f"无法获取关于'{query}'的嵌入向量，你lpmm知识库炸了"}
         except Exception as e:
             logger.error(f"知识库搜索工具执行失败: {str(e)}")
-            return {"name": "search_knowledge", "content": f"知识库搜索失败: {str(e)}"}
+            # 在其他异常情况下，确保 id 仍然是 query (如果它被定义了)
+            query_id = query if "query" in locals() else "unknown_query"
+            return {"type": "info", "id": query_id, "content": f"lpmm知识库搜索失败，炸了: {str(e)}"}
 
     # def get_info_from_db(
     #     self, query_embedding: list, limit: int = 1, threshold: float = 0.5, return_raw: bool = False
@@ -133,6 +136,27 @@ class SearchKnowledgeFromLPMMTool(BaseTool):
     #         # 返回所有找到的内容，用换行分隔
     #         return "\n".join(str(result["content"]) for result in results)
 
+    def _format_results(self, results: list) -> str:
+        """格式化结果"""
+        if not results:
+            return "未找到相关知识。"
+
+        formatted_string = "我找到了一些相关知识：\n"
+        for i, result in enumerate(results):
+            # chunk_id = result.get("chunk_id")
+            text = result.get("text", "")
+            source = result.get("source", "未知来源")
+            source_type = result.get("source_type", "未知类型")
+            similarity = result.get("similarity", 0.0)
+
+            formatted_string += (
+                f"{i + 1}. (相似度: {similarity:.2f}) 类型: {source_type}, 来源: {source} \n内容片段: {text}\n\n"
+            )
+            # 暂时去掉chunk_id
+            # formatted_string += f"{i + 1}. (相似度: {similarity:.2f}) 类型: {source_type}, 来源: {source}, Chunk ID: {chunk_id} \n内容片段: {text}\n\n"
+
+        return formatted_string
+
 
 # 注册工具
 # register_tool(SearchKnowledgeTool)

src/do_tool/tool_can_use/rename_person_tool.py

@@ -0,0 +1,105 @@
+from src.do_tool.tool_can_use.base_tool import BaseTool, register_tool
+from src.plugins.person_info.person_info import person_info_manager
+from src.common.logger_manager import get_logger
+import time
+
+logger = get_logger("rename_person_tool")
+
+
+class RenamePersonTool(BaseTool):
+    name = "rename_person"
+    description = "这个工具可以改变用户的昵称。你可以选择改变对他人的称呼。"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "person_name": {"type": "string", "description": "需要重新取名的用户的当前昵称"},
+            "message_content": {
+                "type": "string",
+                "description": "可选的。当前的聊天内容或特定要求，用于提供取名建议的上下文。",
+            },
+        },
+        "required": ["person_name"],
+    }
+
+    async def execute(self, function_args: dict, message_txt=""):
+        """
+        执行取名工具逻辑
+
+        Args:
+            function_args (dict): 包含 'person_name' 和可选 'message_content' 的字典
+            message_txt (str): 原始消息文本 (这里未使用，因为 message_content 更明确)
+
+        Returns:
+            dict: 包含执行结果的字典
+        """
+        person_name_to_find = function_args.get("person_name")
+        request_context = function_args.get("message_content", "")  # 如果没有提供，则为空字符串
+
+        if not person_name_to_find:
+            return {"name": self.name, "content": "错误：必须提供需要重命名的用户昵称 (person_name)。"}
+
+        try:
+            # 1. 根据昵称查找用户信息
+            logger.debug(f"尝试根据昵称 '{person_name_to_find}' 查找用户...")
+            person_info = await person_info_manager.get_person_info_by_name(person_name_to_find)
+
+            if not person_info:
+                logger.info(f"未找到昵称为 '{person_name_to_find}' 的用户。")
+                return {
+                    "name": self.name,
+                    "content": f"找不到昵称为 '{person_name_to_find}' 的用户。请确保输入的是我之前为该用户取的昵称。",
+                }
+
+            person_id = person_info.get("person_id")
+            user_nickname = person_info.get("nickname")  # 这是用户原始昵称
+            user_cardname = person_info.get("user_cardname")
+            user_avatar = person_info.get("user_avatar")
+
+            if not person_id:
+                logger.error(f"找到了用户 '{person_name_to_find}' 但无法获取 person_id")
+                return {"name": self.name, "content": f"找到了用户 '{person_name_to_find}' 但获取内部ID时出错。"}
+
+            # 2. 调用 qv_person_name 进行取名
+            logger.debug(
+                f"为用户 {person_id} (原昵称: {person_name_to_find}) 调用 qv_person_name，请求上下文: '{request_context}'"
+            )
+            result = await person_info_manager.qv_person_name(
+                person_id=person_id,
+                user_nickname=user_nickname,
+                user_cardname=user_cardname,
+                user_avatar=user_avatar,
+                request=request_context,
+            )
+
+            # 3. 处理结果
+            if result and result.get("nickname"):
+                new_name = result["nickname"]
+                # reason = result.get("reason", "未提供理由")
+                logger.info(f"成功为用户 {person_id} 取了新昵称: {new_name}")
+
+                content = f"已成功将用户 {person_name_to_find} 的备注名更新为 {new_name}"
+                logger.info(content)
+                return {"type": "info", "id": f"rename_success_{time.time()}", "content": content}
+            else:
+                logger.warning(f"为用户 {person_id} 调用 qv_person_name 后未能成功获取新昵称。")
+                # 尝试从内存中获取可能已经更新的名字
+                current_name = await person_info_manager.get_value(person_id, "person_name")
+                if current_name and current_name != person_name_to_find:
+                    return {
+                        "name": self.name,
+                        "content": f"尝试取新昵称时遇到一点小问题，但我已经将 '{person_name_to_find}' 的昵称更新为 '{current_name}' 了。",
+                    }
+                else:
+                    return {
+                        "name": self.name,
+                        "content": f"尝试为 '{person_name_to_find}' 取新昵称时遇到了问题，未能成功生成。可能需要稍后再试。",
+                    }
+
+        except Exception as e:
+            error_msg = f"重命名失败: {str(e)}"
+            logger.error(error_msg, exc_info=True)
+            return {"type": "info_error", "id": f"rename_error_{time.time()}", "content": error_msg}
+
+
+# 注册工具
+register_tool(RenamePersonTool)

src/heart_flow/background_tasks.py

@@ -18,7 +18,9 @@ INTEREST_EVAL_INTERVAL_SECONDS = 5
 # 新增聊天超时检查间隔
 NORMAL_CHAT_TIMEOUT_CHECK_INTERVAL_SECONDS = 60
 # 新增状态评估间隔
-HF_JUDGE_STATE_UPDATE_INTERVAL_SECONDS = 60
+HF_JUDGE_STATE_UPDATE_INTERVAL_SECONDS = 20
+# 新增私聊激活检查间隔
+PRIVATE_CHAT_ACTIVATION_CHECK_INTERVAL_SECONDS = 5  # 与兴趣评估类似，设为5秒
 
 CLEANUP_INTERVAL_SECONDS = 1200
 STATE_UPDATE_INTERVAL_SECONDS = 60
@@ -71,9 +73,10 @@ class BackgroundTaskManager:
         self._state_update_task: Optional[asyncio.Task] = None
         self._cleanup_task: Optional[asyncio.Task] = None
         self._logging_task: Optional[asyncio.Task] = None
-        self._normal_chat_timeout_check_task: Optional[asyncio.Task] = None  # Nyaa~ 添加聊天超时检查任务的引用
-        self._hf_judge_state_update_task: Optional[asyncio.Task] = None  # Nyaa~ 添加状态评估任务的引用
-        self._into_focus_task: Optional[asyncio.Task] = None  # Nyaa~ 添加兴趣评估任务的引用
+        self._normal_chat_timeout_check_task: Optional[asyncio.Task] = None
+        self._hf_judge_state_update_task: Optional[asyncio.Task] = None
+        self._into_focus_task: Optional[asyncio.Task] = None
+        self._private_chat_activation_task: Optional[asyncio.Task] = None  # 新增私聊激活任务引用
         self._tasks: List[Optional[asyncio.Task]] = []  # Keep track of all tasks
 
     async def start_tasks(self):
@@ -124,6 +127,14 @@ class BackgroundTaskManager:
                 f"专注评估任务已启动 间隔:{INTEREST_EVAL_INTERVAL_SECONDS}s",
                 "_into_focus_task",
             ),
+            # 新增私聊激活任务配置
+            (
+                # Use lambda to pass the interval to the runner function
+                lambda: self._run_private_chat_activation_cycle(PRIVATE_CHAT_ACTIVATION_CHECK_INTERVAL_SECONDS),
+                "debug",
+                f"私聊激活检查任务已启动 间隔:{PRIVATE_CHAT_ACTIVATION_CHECK_INTERVAL_SECONDS}s",
+                "_private_chat_activation_task",
+            ),
         ]
 
         # 统一启动所有任务
@@ -277,3 +288,11 @@ class BackgroundTaskManager:
             interval=INTEREST_EVAL_INTERVAL_SECONDS,
             task_func=self._perform_into_focus_work,
         )
+
+    # 新增私聊激活任务运行器
+    async def _run_private_chat_activation_cycle(self, interval: int):
+        await _run_periodic_loop(
+            task_name="Private Chat Activation Check",
+            interval=interval,
+            task_func=self.subheartflow_manager.sbhf_absent_private_into_focus,
+        )

src/heart_flow/observation.py

@@ -12,9 +12,32 @@ from src.plugins.utils.chat_message_builder import (
     num_new_messages_since,
     get_person_id_list,
 )
+from src.plugins.utils.prompt_builder import Prompt, global_prompt_manager
+from typing import Optional
+import difflib
+from src.plugins.chat.message import MessageRecv  # 添加 MessageRecv 导入
+
+# Import the new utility function
+from .utils_chat import get_chat_type_and_target_info
 
 logger = get_logger("observation")
 
+# --- Define Prompt Templates for Chat Summary ---
+Prompt(
+    """这是qq群聊的聊天记录，请总结以下聊天记录的主题：
+{chat_logs}
+请用一句话概括，包括人物、事件和主要信息，不要分点。""",
+    "chat_summary_group_prompt",  # Template for group chat
+)
+
+Prompt(
+    """这是你和{chat_target}的私聊记录，请总结以下聊天记录的主题：
+{chat_logs}
+请用一句话概括，包括事件，时间，和主要信息，不要分点。""",
+    "chat_summary_private_prompt",  # Template for private chat
+)
+# --- End Prompt Template Definition ---
+
 
 # 所有观察的基类
 class Observation:
@@ -34,28 +57,37 @@ class ChattingObservation(Observation):
         super().__init__("chat", chat_id)
         self.chat_id = chat_id
 
+        # --- Initialize attributes (defaults) ---
+        self.is_group_chat: bool = False
+        self.chat_target_info: Optional[dict] = None
+        # --- End Initialization ---
+
+        # --- Other attributes initialized in __init__ ---
         self.talking_message = []
         self.talking_message_str = ""
         self.talking_message_str_truncate = ""
-
         self.name = global_config.BOT_NICKNAME
         self.nick_name = global_config.BOT_ALIAS_NAMES
-
         self.max_now_obs_len = global_config.observation_context_size
         self.overlap_len = global_config.compressed_length
         self.mid_memorys = []
         self.max_mid_memory_len = global_config.compress_length_limit
         self.mid_memory_info = ""
-
         self.person_list = []
-
         self.llm_summary = LLMRequest(
             model=global_config.llm_observation, temperature=0.7, max_tokens=300, request_type="chat_observation"
         )
 
     async def initialize(self):
+        # --- Use utility function to determine chat type and fetch info ---
+        self.is_group_chat, self.chat_target_info = await get_chat_type_and_target_info(self.chat_id)
+        # logger.debug(f"is_group_chat: {self.is_group_chat}")
+        # logger.debug(f"chat_target_info: {self.chat_target_info}")
+        # --- End using utility function ---
+
+        # Fetch initial messages (existing logic)
         initial_messages = get_raw_msg_before_timestamp_with_chat(self.chat_id, self.last_observe_time, 10)
-        self.talking_message = initial_messages  # 将这些消息设为初始上下文
+        self.talking_message = initial_messages
         self.talking_message_str = await build_readable_messages(self.talking_message)
 
     # 进行一次观察 返回观察结果observe_info
@@ -109,18 +141,51 @@ class ChattingObservation(Observation):
                 messages=oldest_messages, timestamp_mode="normal", read_mark=0
             )
 
-            # 调用 LLM 总结主题
-            prompt = (
-                f"请总结以下聊天记录的主题：\n{oldest_messages_str}\n用一句话概括包括人物事件和主要信息，不要分点："
-            )
-            summary = "没有主题的闲聊"  # 默认值
+            # --- Build prompt using template ---
+            prompt = None  # Initialize prompt as None
             try:
-                summary_result, _ = await self.llm_summary.generate_response_async(prompt)
-                if summary_result:  # 确保结果不为空
-                    summary = summary_result
+                # 构建 Prompt - 根据 is_group_chat 选择模板
+                if self.is_group_chat:
+                    prompt_template_name = "chat_summary_group_prompt"
+                    prompt = await global_prompt_manager.format_prompt(
+                        prompt_template_name, chat_logs=oldest_messages_str
+                    )
+                else:
+                    # For private chat, add chat_target to the prompt variables
+                    prompt_template_name = "chat_summary_private_prompt"
+                    # Determine the target name for the prompt
+                    chat_target_name = "对方"  # Default fallback
+                    if self.chat_target_info:
+                        # Prioritize person_name, then nickname
+                        chat_target_name = (
+                            self.chat_target_info.get("person_name")
+                            or self.chat_target_info.get("user_nickname")
+                            or chat_target_name
+                        )
+
+                    # Format the private chat prompt
+                    prompt = await global_prompt_manager.format_prompt(
+                        prompt_template_name,
+                        # Assuming the private prompt template uses {chat_target}
+                        chat_target=chat_target_name,
+                        chat_logs=oldest_messages_str,
+                    )
             except Exception as e:
-                logger.error(f"总结主题失败 for chat {self.chat_id}: {e}")
-                # 保留默认总结 "没有主题的闲聊"
+                logger.error(f"构建总结 Prompt 失败 for chat {self.chat_id}: {e}")
+                # prompt remains None
+
+            summary = "没有主题的闲聊"  # 默认值
+
+            if prompt:  # Check if prompt was built successfully
+                try:
+                    summary_result, _, _ = await self.llm_summary.generate_response(prompt)
+                    if summary_result:  # 确保结果不为空
+                        summary = summary_result
+                except Exception as e:
+                    logger.error(f"总结主题失败 for chat {self.chat_id}: {e}")
+                    # 保留默认总结 "没有主题的闲聊"
+            else:
+                logger.warning(f"因 Prompt 构建失败，跳过 LLM 总结 for chat {self.chat_id}")
 
             mid_memory = {
                 "id": str(int(datetime.now().timestamp())),
@@ -164,6 +229,70 @@ class ChattingObservation(Observation):
             f"Chat {self.chat_id} - 压缩早期记忆：{self.mid_memory_info}\n现在聊天内容：{self.talking_message_str}"
         )
 
+    async def find_best_matching_message(self, search_str: str, min_similarity: float = 0.6) -> Optional[MessageRecv]:
+        """
+        在 talking_message 中查找与 search_str 最匹配的消息。
+
+        Args:
+            search_str: 要搜索的字符串。
+            min_similarity: 要求的最低相似度（0到1之间）。
+
+        Returns:
+            匹配的 MessageRecv 实例，如果找不到则返回 None。
+        """
+        best_match_score = -1.0
+        best_match_dict = None
+
+        if not self.talking_message:
+            logger.debug(f"Chat {self.chat_id}: talking_message is empty, cannot find match for '{search_str}'")
+            return None
+
+        for message_dict in self.talking_message:
+            try:
+                # 临时创建 MessageRecv 以处理文本
+                temp_msg = MessageRecv(message_dict)
+                await temp_msg.process()  # 处理消息以获取 processed_plain_text
+                current_text = temp_msg.processed_plain_text
+
+                if not current_text:  # 跳过没有文本内容的消息
+                    continue
+
+                # 计算相似度
+                matcher = difflib.SequenceMatcher(None, search_str, current_text)
+                score = matcher.ratio()
+
+                # logger.debug(f"Comparing '{search_str}' with '{current_text}', score: {score}") # 可选：用于调试
+
+                if score > best_match_score:
+                    best_match_score = score
+                    best_match_dict = message_dict
+
+            except Exception as e:
+                logger.error(f"Error processing message for matching in chat {self.chat_id}: {e}", exc_info=True)
+                continue  # 继续处理下一条消息
+
+        if best_match_dict is not None and best_match_score >= min_similarity:
+            logger.debug(f"Found best match for '{search_str}' with score {best_match_score:.2f}")
+            try:
+                final_msg = MessageRecv(best_match_dict)
+                await final_msg.process()
+                # 确保 MessageRecv 实例有关联的 chat_stream
+                if hasattr(self, "chat_stream"):
+                    final_msg.update_chat_stream(self.chat_stream)
+                else:
+                    logger.warning(
+                        f"ChattingObservation instance for chat {self.chat_id} does not have a chat_stream attribute set."
+                    )
+                return final_msg
+            except Exception as e:
+                logger.error(f"Error creating final MessageRecv for chat {self.chat_id}: {e}", exc_info=True)
+                return None
+        else:
+            logger.debug(
+                f"No suitable match found for '{search_str}' in chat {self.chat_id} (best score: {best_match_score:.2f}, threshold: {min_similarity})"
+            )
+            return None
+
     async def has_new_messages_since(self, timestamp: float) -> bool:
         """检查指定时间戳之后是否有新消息"""
         count = num_new_messages_since(chat_id=self.chat_id, timestamp_start=timestamp)

src/heart_flow/sub_heartflow.py

@@ -13,6 +13,7 @@ from src.plugins.heartFC_chat.normal_chat import NormalChat
 from src.heart_flow.mai_state_manager import MaiStateInfo
 from src.heart_flow.chat_state_info import ChatState, ChatStateInfo
 from src.heart_flow.sub_mind import SubMind
+from .utils_chat import get_chat_type_and_target_info
 
 
 # 定义常量 (从 interest.py 移动过来)
@@ -238,6 +239,11 @@ class SubHeartflow:
         self.chat_state_last_time: float = 0
         self.history_chat_state: List[Tuple[ChatState, float]] = []
 
+        # --- Initialize attributes ---
+        self.is_group_chat: bool = False
+        self.chat_target_info: Optional[dict] = None
+        # --- End Initialization ---
+
         # 兴趣检测器
         self.interest_chatting: InterestChatting = InterestChatting()
 
@@ -260,11 +266,24 @@ class SubHeartflow:
             subheartflow_id=self.subheartflow_id, chat_state=self.chat_state, observations=self.observations
         )
 
-        # 日志前缀
-        self.log_prefix = chat_manager.get_stream_name(self.subheartflow_id) or self.subheartflow_id
+        # 日志前缀 - Moved determination to initialize
+        self.log_prefix = str(subheartflow_id)  # Initial default prefix
 
     async def initialize(self):
-        """异步初始化方法，创建兴趣流"""
+        """异步初始化方法，创建兴趣流并确定聊天类型"""
+
+        # --- Use utility function to determine chat type and fetch info ---
+        self.is_group_chat, self.chat_target_info = await get_chat_type_and_target_info(self.chat_id)
+        # Update log prefix after getting info (potential stream name)
+        self.log_prefix = (
+            chat_manager.get_stream_name(self.subheartflow_id) or self.subheartflow_id
+        )  # Keep this line or adjust if utils provides name
+        logger.debug(
+            f"SubHeartflow {self.chat_id} initialized: is_group={self.is_group_chat}, target_info={self.chat_target_info}"
+        )
+        # --- End using utility function ---
+
+        # Initialize interest system (existing logic)
         await self.interest_chatting.initialize()
         logger.debug(f"{self.log_prefix} InterestChatting 实例已初始化。")
 
@@ -286,26 +305,33 @@ class SubHeartflow:
 
     async def _start_normal_chat(self) -> bool:
         """
-        启动 NormalChat 实例，
-        进入 CHAT 状态时使用
-
-        确保 HeartFChatting 已停止
+        启动 NormalChat 实例，并进行异步初始化。
+        进入 CHAT 状态时使用。
+        确保 HeartFChatting 已停止。
         """
         await self._stop_heart_fc_chat()  # 确保 专注聊天已停止
 
         log_prefix = self.log_prefix
         try:
-            # 获取聊天流并创建 NormalChat 实例
+            # 获取聊天流并创建 NormalChat 实例 (同步部分)
             chat_stream = chat_manager.get_stream(self.chat_id)
+            if not chat_stream:
+                logger.error(f"{log_prefix} 无法获取 chat_stream，无法启动 NormalChat。")
+                return False
+
             self.normal_chat_instance = NormalChat(chat_stream=chat_stream, interest_dict=self.get_interest_dict())
 
+            # 进行异步初始化
+            await self.normal_chat_instance.initialize()
+
+            # 启动聊天任务
             logger.info(f"{log_prefix} 开始普通聊天，随便水群...")
-            await self.normal_chat_instance.start_chat()  # <--- 修正：调用 start_chat
+            await self.normal_chat_instance.start_chat()  # start_chat now ensures init is called again if needed
             return True
         except Exception as e:
-            logger.error(f"{log_prefix} 启动 NormalChat 时出错: {e}")
+            logger.error(f"{log_prefix} 启动 NormalChat 或其初始化时出错: {e}")
             logger.error(traceback.format_exc())
-            self.normal_chat_instance = None  # 启动失败，清理实例
+            self.normal_chat_instance = None  # 启动/初始化失败，清理实例
             return False
 
     async def _stop_heart_fc_chat(self):

src/heart_flow/sub_mind.py

@@ -1,4 +1,4 @@
-from .observation import Observation
+from .observation import ChattingObservation
 from src.plugins.models.utils_model import LLMRequest
 from src.config.config import global_config
 import time
@@ -20,34 +20,63 @@ logger = get_logger("sub_heartflow")
 
 
 def init_prompt():
-    prompt = ""
-    prompt += "{extra_info}\n"
-    prompt += "{relation_prompt}\n"
-    prompt += "你的名字是{bot_name},{prompt_personality}\n"
-    prompt += "{last_loop_prompt}\n"
-    prompt += "{cycle_info_block}\n"
-    prompt += "现在是{time_now}，你正在上网，和qq群里的网友们聊天，以下是正在进行的聊天内容：\n{chat_observe_info}\n"
-    prompt += "\n你现在{mood_info}\n"
-    prompt += "请仔细阅读当前群聊内容，分析讨论话题和群成员关系，分析你刚刚发言和别人对你的发言的反应，思考你要不要回复。然后思考你是否需要使用函数工具。"
-    prompt += "思考并输出你的内心想法\n"
-    prompt += "输出要求：\n"
-    prompt += "1. 根据聊天内容生成你的想法，{hf_do_next}\n"
-    prompt += "2. 不要分点、不要使用表情符号\n"
-    prompt += "3. 避免多余符号(冒号、引号、括号等)\n"
-    prompt += "4. 语言简洁自然，不要浮夸\n"
-    prompt += "5. 如果你刚发言，并且没有人回复你，不要回复\n"
-    prompt += "工具使用说明：\n"
-    prompt += "1. 输出想法后考虑是否需要使用工具\n"
-    prompt += "2. 工具可获取信息或执行操作\n"
-    prompt += "3. 如需处理消息或回复，请使用工具\n"
+    # --- Group Chat Prompt ---
+    group_prompt = """
+{extra_info}
+{relation_prompt}
+你的名字是{bot_name},{prompt_personality}
+{last_loop_prompt}
+{cycle_info_block}
+现在是{time_now}，你正在上网，和qq群里的网友们聊天，以下是正在进行的聊天内容：
+{chat_observe_info}
 
-    Prompt(prompt, "sub_heartflow_prompt_before")
+你现在{mood_info}
+请仔细阅读当前群聊内容，分析讨论话题和群成员关系，分析你刚刚发言和别人对你的发言的反应，思考你要不要回复。然后思考你是否需要使用函数工具。
+思考并输出你的内心想法
+输出要求：
+1. 根据聊天内容生成你的想法，{hf_do_next}
+2. 不要分点、不要使用表情符号
+3. 避免多余符号(冒号、引号、括号等)
+4. 语言简洁自然，不要浮夸
+5. 如果你刚发言，并且没有人回复你，不要回复
+工具使用说明：
+1. 输出想法后考虑是否需要使用工具
+2. 工具可获取信息或执行操作
+3. 如需处理消息或回复，请使用工具。"""
+    Prompt(group_prompt, "sub_heartflow_prompt_before")
 
-    prompt = ""
-    prompt += "刚刚你的内心想法是：{current_thinking_info}\n"
-    prompt += "{if_replan_prompt}\n"
+    # --- Private Chat Prompt ---
+    private_prompt = """
+{extra_info}
+{relation_prompt}
+你的名字是{bot_name},{prompt_personality}
+{last_loop_prompt}
+{cycle_info_block}
+现在是{time_now}，你正在上网，和 {chat_target_name} 私聊，以下是你们的聊天内容：
+{chat_observe_info}
 
-    Prompt(prompt, "last_loop")
+你现在{mood_info}
+请仔细阅读聊天内容，想想你和 {chat_target_name} 的关系，回顾你们刚刚的交流,你刚刚发言和对方的反应，思考聊天的主题。
+请思考你要不要回复以及如何回复对方。然后思考你是否需要使用函数工具。
+思考并输出你的内心想法
+输出要求：
+1. 根据聊天内容生成你的想法，{hf_do_next}
+2. 不要分点、不要使用表情符号
+3. 避免多余符号(冒号、引号、括号等)
+4. 语言简洁自然，不要浮夸
+5. 如果你刚发言，对方没有回复你，请谨慎回复
+工具使用说明：
+1. 输出想法后考虑是否需要使用工具
+2. 工具可获取信息或执行操作
+3. 如需处理消息或回复，请使用工具。"""
+    Prompt(private_prompt, "sub_heartflow_prompt_private_before")  # New template name
+
+    # --- Last Loop Prompt (remains the same) ---
+    last_loop_t = """
+刚刚你的内心想法是：{current_thinking_info}
+{if_replan_prompt}
+"""
+    Prompt(last_loop_t, "last_loop")
 
 
 def calculate_similarity(text_a: str, text_b: str) -> float:
@@ -85,7 +114,7 @@ def calculate_replacement_probability(similarity: float) -> float:
 
 
 class SubMind:
-    def __init__(self, subheartflow_id: str, chat_state: ChatStateInfo, observations: Observation):
+    def __init__(self, subheartflow_id: str, chat_state: ChatStateInfo, observations: ChattingObservation):
         self.last_active_time = None
         self.subheartflow_id = subheartflow_id
 
@@ -101,10 +130,40 @@ class SubMind:
 
         self.current_mind = ""
         self.past_mind = []
-        self.structured_info = {}
+        self.structured_info = []
+        self.structured_info_str = ""
 
         name = chat_manager.get_stream_name(self.subheartflow_id)
         self.log_prefix = f"[{name}] "
+        self._update_structured_info_str()
+
+    def _update_structured_info_str(self):
+        """根据 structured_info 更新 structured_info_str"""
+        if not self.structured_info:
+            self.structured_info_str = ""
+            return
+
+        lines = ["【信息】"]
+        for item in self.structured_info:
+            # 简化展示，突出内容和类型，包含TTL供调试
+            type_str = item.get("type", "未知类型")
+            content_str = item.get("content", "")
+
+            if type_str == "info":
+                lines.append(f"刚刚: {content_str}")
+            elif type_str == "memory":
+                lines.append(f"{content_str}")
+            elif type_str == "comparison_result":
+                lines.append(f"数字大小比较结果: {content_str}")
+            elif type_str == "time_info":
+                lines.append(f"{content_str}")
+            elif type_str == "lpmm_knowledge":
+                lines.append(f"你知道：{content_str}")
+            else:
+                lines.append(f"{type_str}的信息: {content_str}")
+
+        self.structured_info_str = "\n".join(lines)
+        logger.debug(f"{self.log_prefix} 更新 structured_info_str: \n{self.structured_info_str}")
 
     async def do_thinking_before_reply(self, history_cycle: list[CycleInfo] = None):
         """
@@ -116,18 +175,50 @@ class SubMind:
         # 更新活跃时间
         self.last_active_time = time.time()
 
+        # ---------- 0. 更新和清理 structured_info ----------
+        if self.structured_info:
+            logger.debug(
+                f"{self.log_prefix} 更新前的 structured_info: {safe_json_dumps(self.structured_info, ensure_ascii=False)}"
+            )
+            updated_info = []
+            for item in self.structured_info:
+                item["ttl"] -= 1
+                if item["ttl"] > 0:
+                    updated_info.append(item)
+                else:
+                    logger.debug(f"{self.log_prefix} 移除过期的 structured_info 项: {item['id']}")
+            self.structured_info = updated_info
+            logger.debug(
+                f"{self.log_prefix} 更新后的 structured_info: {safe_json_dumps(self.structured_info, ensure_ascii=False)}"
+            )
+            self._update_structured_info_str()
+        logger.debug(
+            f"{self.log_prefix} 当前完整的 structured_info: {safe_json_dumps(self.structured_info, ensure_ascii=False)}"
+        )
+
         # ---------- 1. 准备基础数据 ----------
         # 获取现有想法和情绪状态
         previous_mind = self.current_mind if self.current_mind else ""
         mood_info = self.chat_state.mood
 
         # 获取观察对象
-        observation = self.observations[0]
-        if not observation:
-            logger.error(f"{self.log_prefix} 无法获取观察对象")
-            self.update_current_mind("(我没看到任何聊天内容...)")
+        observation: ChattingObservation = self.observations[0] if self.observations else None
+        if not observation or not hasattr(observation, "is_group_chat"):  # Ensure it's ChattingObservation or similar
+            logger.error(f"{self.log_prefix} 无法获取有效的观察对象或缺少聊天类型信息")
+            self.update_current_mind("(观察出错了...)")
             return self.current_mind, self.past_mind
 
+        is_group_chat = observation.is_group_chat
+        # logger.debug(f"is_group_chat: {is_group_chat}")
+
+        chat_target_info = observation.chat_target_info
+        chat_target_name = "对方"  # Default for private
+        if not is_group_chat and chat_target_info:
+            chat_target_name = (
+                chat_target_info.get("person_name") or chat_target_info.get("user_nickname") or chat_target_name
+            )
+        # --- End getting observation info ---
+
         # 获取观察内容
         chat_observe_info = observation.get_observe_info()
         person_list = observation.person_list
@@ -238,19 +329,39 @@ class SubMind:
         )[0]
 
         # ---------- 4. 构建最终提示词 ----------
-        # 获取提示词模板并填充数据
-        prompt = (await global_prompt_manager.get_prompt_async("sub_heartflow_prompt_before")).format(
-            extra_info="",  # 可以在这里添加额外信息
-            prompt_personality=prompt_personality,
-            relation_prompt=relation_prompt,
-            bot_name=individuality.name,
-            time_now=time_now,
-            chat_observe_info=chat_observe_info,
-            mood_info=mood_info,
-            hf_do_next=hf_do_next,
-            last_loop_prompt=last_loop_prompt,
-            cycle_info_block=cycle_info_block,
-        )
+        # --- Choose template based on chat type ---
+        logger.debug(f"is_group_chat: {is_group_chat}")
+        if is_group_chat:
+            template_name = "sub_heartflow_prompt_before"
+            prompt = (await global_prompt_manager.get_prompt_async(template_name)).format(
+                extra_info=self.structured_info_str,
+                prompt_personality=prompt_personality,
+                relation_prompt=relation_prompt,
+                bot_name=individuality.name,
+                time_now=time_now,
+                chat_observe_info=chat_observe_info,
+                mood_info=mood_info,
+                hf_do_next=hf_do_next,
+                last_loop_prompt=last_loop_prompt,
+                cycle_info_block=cycle_info_block,
+                # chat_target_name is not used in group prompt
+            )
+        else:  # Private chat
+            template_name = "sub_heartflow_prompt_private_before"
+            prompt = (await global_prompt_manager.get_prompt_async(template_name)).format(
+                extra_info=self.structured_info_str,
+                prompt_personality=prompt_personality,
+                relation_prompt=relation_prompt,  # Might need adjustment for private context
+                bot_name=individuality.name,
+                time_now=time_now,
+                chat_target_name=chat_target_name,  # Pass target name
+                chat_observe_info=chat_observe_info,
+                mood_info=mood_info,
+                hf_do_next=hf_do_next,
+                last_loop_prompt=last_loop_prompt,
+                cycle_info_block=cycle_info_block,
+            )
+        # --- End choosing template ---
 
         # ---------- 5. 执行LLM请求并处理响应 ----------
         content = ""  # 初始化内容变量
@@ -390,7 +501,7 @@ class SubMind:
             tool_instance: 工具使用器实例
         """
         tool_results = []
-        structured_info = {}  # 动态生成键
+        new_structured_items = []  # 收集新产生的结构化信息
 
         # 执行所有工具调用
         for tool_call in tool_calls:
@@ -398,23 +509,34 @@ class SubMind:
                 result = await tool_instance._execute_tool_call(tool_call)
                 if result:
                     tool_results.append(result)
+                    # 创建新的结构化信息项
+                    new_item = {
+                        "type": result.get("type", "unknown_type"),  # 使用 'type' 键
+                        "id": result.get("id", f"fallback_id_{time.time()}"),  # 使用 'id' 键
+                        "content": result.get("content", ""),  # 'content' 键保持不变
+                        "ttl": 3,
+                    }
+                    new_structured_items.append(new_item)
 
-                    # 使用工具名称作为键
-                    tool_name = result["name"]
-                    if tool_name not in structured_info:
-                        structured_info[tool_name] = []
-
-                    structured_info[tool_name].append({"name": result["name"], "content": result["content"]})
             except Exception as tool_e:
                 logger.error(f"[{self.subheartflow_id}] 工具执行失败: {tool_e}")
+                logger.error(traceback.format_exc())  # 添加 traceback 记录
 
-        # 如果有工具结果，记录并更新结构化信息
-        if structured_info:
-            logger.debug(f"工具调用收集到结构化信息: {safe_json_dumps(structured_info, ensure_ascii=False)}")
-            self.structured_info = structured_info
+        # 如果有新的工具结果，记录并更新结构化信息
+        if new_structured_items:
+            self.structured_info.extend(new_structured_items)  # 添加到现有列表
+            logger.debug(f"工具调用收集到新的结构化信息: {safe_json_dumps(new_structured_items, ensure_ascii=False)}")
+            # logger.debug(f"当前完整的 structured_info: {safe_json_dumps(self.structured_info, ensure_ascii=False)}") # 可以取消注释以查看完整列表
+            self._update_structured_info_str()  # 添加新信息后，更新字符串表示
 
     def update_current_mind(self, response):
-        self.past_mind.append(self.current_mind)
+        if self.current_mind:  # 只有当 current_mind 非空时才添加到 past_mind
+            self.past_mind.append(self.current_mind)
+            # 可以考虑限制 past_mind 的大小，例如:
+            # max_past_mind_size = 10
+            # if len(self.past_mind) > max_past_mind_size:
+            #     self.past_mind.pop(0) # 移除最旧的
+
         self.current_mind = response
 
 

src/heart_flow/subheartflow_manager.py

@@ -127,6 +127,8 @@ class SubHeartflowManager:
 
                 # 添加聊天观察者
                 observation = ChattingObservation(chat_id=subheartflow_id)
+                await observation.initialize()
+
                 new_subflow.add_observation(observation)
 
                 # 注册子心流
@@ -335,28 +337,37 @@ class SubHeartflowManager:
 
     async def sbhf_absent_into_chat(self):
         """
-        随机选一个 ABSENT 状态的子心流，评估是否应转换为 CHAT 状态。
+        随机选一个 ABSENT 状态的 *群聊* 子心流，评估是否应转换为 CHAT 状态。
         每次调用最多转换一个。
+        私聊会被忽略。
         """
         current_mai_state = self.mai_state_info.get_current_state()
         chat_limit = current_mai_state.get_normal_chat_max_num()
 
         async with self._lock:
-            # 1. 筛选出所有 ABSENT 状态的子心流
-            absent_subflows = [
-                hf for hf in self.subheartflows.values() if hf.chat_state.chat_status == ChatState.ABSENT
+            # 1. 筛选出所有 ABSENT 状态的 *群聊* 子心流
+            absent_group_subflows = [
+                hf
+                for hf in self.subheartflows.values()
+                if hf.chat_state.chat_status == ChatState.ABSENT and hf.is_group_chat
             ]
 
-            if not absent_subflows:
-                logger.debug("没有摸鱼的子心流可以评估。")  # 日志太频繁，注释掉
+            if not absent_group_subflows:
+                # logger.debug("没有摸鱼的群聊子心流可以评估。") # 日志太频繁
                 return  # 没有目标，直接返回
 
             # 2. 随机选一个幸运儿
-            sub_hf_to_evaluate = random.choice(absent_subflows)
+            sub_hf_to_evaluate = random.choice(absent_group_subflows)
             flow_id = sub_hf_to_evaluate.subheartflow_id
             stream_name = chat_manager.get_stream_name(flow_id) or flow_id
             log_prefix = f"[{stream_name}]"
 
+            # --- Private chat check (redundant due to filter above, but safe) ---
+            # if not sub_hf_to_evaluate.is_group_chat:
+            #     logger.debug(f"{log_prefix} 是私聊，跳过 CHAT 状态评估。")
+            #     return
+            # --- End check ---
+
             # 3. 检查 CHAT 上限
             current_chat_count = self.count_subflows_by_state_nolock(ChatState.CHAT)
             if current_chat_count >= chat_limit:
@@ -658,8 +669,10 @@ class SubHeartflowManager:
     # --- 新增：处理来自 HeartFChatting 的状态转换请求 --- #
     async def sbhf_focus_into_absent(self, subflow_id: Any):
         """
-        接收来自 HeartFChatting 的请求，将特定子心流的状态转换为 ABSENT。
+        接收来自 HeartFChatting 的请求，将特定子心流的状态转换为 ABSENT 或 CHAT。
         通常在连续多次 "no_reply" 后被调用。
+        对于私聊，总是转换为 ABSENT。
+        对于群聊，随机决定转换为 ABSENT 或 CHAT (如果 CHAT 未达上限)。
 
         Args:
             subflow_id: 需要转换状态的子心流 ID。
@@ -667,50 +680,46 @@ class SubHeartflowManager:
         async with self._lock:
             subflow = self.subheartflows.get(subflow_id)
             if not subflow:
-                logger.warning(f"[状态转换请求] 尝试转换不存在的子心流 {subflow_id} 到 ABSENT")
+                logger.warning(f"[状态转换请求] 尝试转换不存在的子心流 {subflow_id} 到 ABSENT/CHAT")
                 return
 
             stream_name = chat_manager.get_stream_name(subflow_id) or subflow_id
             current_state = subflow.chat_state.chat_status
 
-            # 仅当子心流处于 FOCUSED 状态时才进行转换
-            # 因为 HeartFChatting 只在 FOCUSED 状态下运行
             if current_state == ChatState.FOCUSED:
-                target_state = ChatState.ABSENT  # 默认目标状态
-                log_reason = "默认转换"
+                target_state = ChatState.ABSENT  # Default target
+                log_reason = "默认转换 (私聊或群聊)"
 
-                # 决定是去 ABSENT 还是 CHAT
-                if random.random() < 0.5:
-                    target_state = ChatState.ABSENT
-                    log_reason = "随机选择 ABSENT"
-                    logger.debug(f"[状态转换请求] {stream_name} ({current_state.value}) 随机决定进入 ABSENT")
-                else:
-                    # 尝试进入 CHAT，先检查限制
-                    current_mai_state = self.mai_state_info.get_current_state()
-                    chat_limit = current_mai_state.get_normal_chat_max_num()
-                    # 使用不上锁的版本，因为我们已经在锁内
-                    current_chat_count = self.count_subflows_by_state_nolock(ChatState.CHAT)
+                # --- Modify logic based on chat type --- #
+                if subflow.is_group_chat:
+                    # Group chat: Decide between ABSENT or CHAT
+                    if random.random() < 0.5:  # 50% chance to try CHAT
+                        current_mai_state = self.mai_state_info.get_current_state()
+                        chat_limit = current_mai_state.get_normal_chat_max_num()
+                        current_chat_count = self.count_subflows_by_state_nolock(ChatState.CHAT)
 
-                    if current_chat_count < chat_limit:
-                        target_state = ChatState.CHAT
-                        log_reason = f"随机选择 CHAT (当前 {current_chat_count}/{chat_limit})"
-                        logger.debug(
-                            f"[状态转换请求] {stream_name} ({current_state.value}) 随机决定进入 CHAT，未达上限 ({current_chat_count}/{chat_limit})"
-                        )
-                    else:
+                        if current_chat_count < chat_limit:
+                            target_state = ChatState.CHAT
+                            log_reason = f"群聊随机选择 CHAT (当前 {current_chat_count}/{chat_limit})"
+                        else:
+                            target_state = ChatState.ABSENT  # Fallback to ABSENT if CHAT limit reached
+                            log_reason = (
+                                f"群聊随机选择 CHAT 但已达上限 ({current_chat_count}/{chat_limit})，转为 ABSENT"
+                            )
+                    else:  # 50% chance to go directly to ABSENT
                         target_state = ChatState.ABSENT
-                        log_reason = f"随机选择 CHAT 但已达上限 ({current_chat_count}/{chat_limit})，转为 ABSENT"
-                        logger.debug(
-                            f"[状态转换请求] {stream_name} ({current_state.value}) 随机决定进入 CHAT，但已达上限 ({current_chat_count}/{chat_limit})，改为进入 ABSENT"
-                        )
+                        log_reason = "群聊随机选择 ABSENT"
+                else:
+                    # Private chat: Always go to ABSENT
+                    target_state = ChatState.ABSENT
+                    log_reason = "私聊退出 FOCUSED，转为 ABSENT"
+                # --- End modification --- #
 
-                # 开始转换
                 logger.info(
                     f"[状态转换请求] 接收到请求，将 {stream_name} (当前: {current_state.value}) 尝试转换为 {target_state.value} ({log_reason})"
                 )
                 try:
                     await subflow.change_chat_state(target_state)
-                    # 检查最终状态
                     final_state = subflow.chat_state.chat_status
                     if final_state == target_state:
                         logger.debug(f"[状态转换请求] {stream_name} 状态已成功转换为 {final_state.value}")
@@ -730,3 +739,106 @@ class SubHeartflowManager:
                 )
 
     # --- 结束新增 --- #
+
+    # --- 新增：处理私聊从 ABSENT 直接到 FOCUSED 的逻辑 --- #
+    async def sbhf_absent_private_into_focus(self):
+        """检查 ABSENT 状态的私聊子心流是否有新活动，若有且未达 FOCUSED 上限，则直接转换为 FOCUSED。"""
+        log_prefix_task = "[私聊激活检查]"
+        transitioned_count = 0
+        checked_count = 0
+
+        # --- 获取当前状态和 FOCUSED 上限 --- #
+        current_mai_state = self.mai_state_info.get_current_state()
+        focused_limit = current_mai_state.get_focused_chat_max_num()
+
+        # --- 检查是否允许 FOCUS 模式 --- #
+        if not global_config.allow_focus_mode:
+            # Log less frequently to avoid spam
+            # if int(time.time()) % 60 == 0:
+            #     logger.debug(f"{log_prefix_task} 配置不允许进入 FOCUSED 状态")
+            return
+
+        if focused_limit <= 0:
+            # logger.debug(f"{log_prefix_task} 当前状态 ({current_mai_state.value}) 不允许 FOCUSED 子心流")
+            return
+
+        async with self._lock:
+            # --- 获取当前 FOCUSED 计数 (不上锁版本) --- #
+            current_focused_count = self.count_subflows_by_state_nolock(ChatState.FOCUSED)
+
+            # --- 筛选出所有 ABSENT 状态的私聊子心流 --- #
+            eligible_subflows = [
+                hf
+                for hf in self.subheartflows.values()
+                if hf.chat_state.chat_status == ChatState.ABSENT and not hf.is_group_chat
+            ]
+            checked_count = len(eligible_subflows)
+
+            if not eligible_subflows:
+                # logger.debug(f"{log_prefix_task} 没有 ABSENT 状态的私聊子心流可以评估。")
+                return
+
+            # --- 遍历评估每个符合条件的私聊 --- #
+            for sub_hf in eligible_subflows:
+                # --- 再次检查 FOCUSED 上限，因为可能有多个同时激活 --- #
+                if current_focused_count >= focused_limit:
+                    logger.debug(
+                        f"{log_prefix_task} 已达专注上限 ({current_focused_count}/{focused_limit})，停止检查后续私聊。"
+                    )
+                    break  # 已满，无需再检查其他私聊
+
+                flow_id = sub_hf.subheartflow_id
+                stream_name = chat_manager.get_stream_name(flow_id) or flow_id
+                log_prefix = f"[{stream_name}]({log_prefix_task})"
+
+                try:
+                    # --- 检查是否有新活动 --- #
+                    observation = sub_hf._get_primary_observation()  # 获取主要观察者
+                    is_active = False
+                    if observation:
+                        # 检查自上次状态变为 ABSENT 后是否有新消息
+                        # 使用 chat_state_changed_time 可能更精确
+                        # 加一点点缓冲时间（例如 1 秒）以防时间戳完全相等
+                        timestamp_to_check = sub_hf.chat_state_changed_time - 1
+                        has_new = await observation.has_new_messages_since(timestamp_to_check)
+                        if has_new:
+                            is_active = True
+                            logger.debug(f"{log_prefix} 检测到新消息，标记为活跃。")
+                    # 可选：检查兴趣度是否大于0 (如果需要)
+                    # interest_level = await sub_hf.interest_chatting.get_interest()
+                    # if interest_level > 0:
+                    #    is_active = True
+                    #    logger.debug(f"{log_prefix} 检测到兴趣度 > 0 ({interest_level:.2f})，标记为活跃。")
+                    else:
+                        logger.warning(f"{log_prefix} 无法获取主要观察者来检查活动状态。")
+
+                    # --- 如果活跃且未达上限，则尝试转换 --- #
+                    if is_active:
+                        logger.info(
+                            f"{log_prefix} 检测到活跃且未达专注上限 ({current_focused_count}/{focused_limit})，尝试转换为 FOCUSED。"
+                        )
+                        await sub_hf.change_chat_state(ChatState.FOCUSED)
+                        # 确认转换成功
+                        if sub_hf.chat_state.chat_status == ChatState.FOCUSED:
+                            transitioned_count += 1
+                            current_focused_count += 1  # 更新计数器以供本轮后续检查
+                            logger.info(f"{log_prefix} 成功进入 FOCUSED 状态。")
+                        else:
+                            logger.warning(
+                                f"{log_prefix} 尝试进入 FOCUSED 状态失败。当前状态: {sub_hf.chat_state.chat_status.value}"
+                            )
+                    # else: # 不活跃，无需操作
+                    #    logger.debug(f"{log_prefix} 未检测到新活动，保持 ABSENT。")
+
+                except Exception as e:
+                    logger.error(f"{log_prefix} 检查私聊活动或转换状态时出错: {e}", exc_info=True)
+
+        # --- 循环结束后记录总结日志 --- #
+        if transitioned_count > 0:
+            logger.debug(
+                f"{log_prefix_task} 完成，共检查 {checked_count} 个私聊，{transitioned_count} 个转换为 FOCUSED。"
+            )
+
+    # --- 结束新增 --- #
+
+    # --- 结束新增：处理来自 HeartFChatting 的状态转换请求 --- #

src/heart_flow/utils_chat.py

@@ -0,0 +1,74 @@
+import asyncio
+from typing import Optional, Tuple, Dict
+from src.common.logger_manager import get_logger
+from src.plugins.chat.chat_stream import chat_manager
+from src.plugins.person_info.person_info import person_info_manager
+
+logger = get_logger("heartflow_utils")
+
+
+async def get_chat_type_and_target_info(chat_id: str) -> Tuple[bool, Optional[Dict]]:
+    """
+    获取聊天类型（是否群聊）和私聊对象信息。
+
+    Args:
+        chat_id: 聊天流ID
+
+    Returns:
+        Tuple[bool, Optional[Dict]]:
+            - bool: 是否为群聊 (True 是群聊, False 是私聊或未知)
+            - Optional[Dict]: 如果是私聊，包含对方信息的字典；否则为 None。
+            字典包含: platform, user_id, user_nickname, person_id, person_name
+    """
+    is_group_chat = False  # Default to private/unknown
+    chat_target_info = None
+
+    try:
+        chat_stream = await asyncio.to_thread(chat_manager.get_stream, chat_id)  # Use to_thread if get_stream is sync
+        # If get_stream is already async, just use: chat_stream = await chat_manager.get_stream(chat_id)
+
+        if chat_stream:
+            if chat_stream.group_info:
+                is_group_chat = True
+                chat_target_info = None  # Explicitly None for group chat
+            elif chat_stream.user_info:  # It's a private chat
+                is_group_chat = False
+                user_info = chat_stream.user_info
+                platform = chat_stream.platform
+                user_id = user_info.user_id
+
+                # Initialize target_info with basic info
+                target_info = {
+                    "platform": platform,
+                    "user_id": user_id,
+                    "user_nickname": user_info.user_nickname,
+                    "person_id": None,
+                    "person_name": None,
+                }
+
+                # Try to fetch person info
+                try:
+                    # Assume get_person_id is sync (as per original code), keep using to_thread
+                    person_id = await asyncio.to_thread(person_info_manager.get_person_id, platform, user_id)
+                    person_name = None
+                    if person_id:
+                        # get_value is async, so await it directly
+                        person_name = await person_info_manager.get_value(person_id, "person_name")
+
+                    target_info["person_id"] = person_id
+                    target_info["person_name"] = person_name
+                except Exception as person_e:
+                    logger.warning(
+                        f"获取 person_id 或 person_name 时出错 for {platform}:{user_id} in utils: {person_e}"
+                    )
+
+                chat_target_info = target_info
+        else:
+            logger.warning(f"无法获取 chat_stream for {chat_id} in utils")
+            # Keep defaults: is_group_chat=False, chat_target_info=None
+
+    except Exception as e:
+        logger.error(f"获取聊天类型和目标信息时出错 for {chat_id}: {e}", exc_info=True)
+        # Keep defaults on error
+
+    return is_group_chat, chat_target_info

src/plugins/chat/bot.py

@@ -83,6 +83,13 @@ class ChatBot:
                 logger.debug(f"用户{userinfo.user_id}被禁止回复")
                 return
 
+            if groupinfo is None:
+                logger.trace("检测到私聊消息，检查")
+                # 好友黑名单拦截
+                if userinfo.user_id not in global_config.talk_allowed_private:
+                    logger.debug(f"用户{userinfo.user_id}没有私聊权限")
+                    return
+
             # 群聊黑名单拦截
             if groupinfo is not None and groupinfo.group_id not in global_config.talk_allowed_groups:
                 logger.trace(f"群{groupinfo.group_id}被禁止回复")

src/plugins/chat/message.py

@@ -31,19 +31,21 @@ class Message(MessageBase):
     def __init__(
         self,
         message_id: str,
-        timestamp: float,
         chat_stream: ChatStream,
         user_info: UserInfo,
         message_segment: Optional[Seg] = None,
+        timestamp: Optional[float] = None,
         reply: Optional["MessageRecv"] = None,
         detailed_plain_text: str = "",
         processed_plain_text: str = "",
     ):
+        # 使用传入的时间戳或当前时间
+        current_timestamp = timestamp if timestamp is not None else round(time.time(), 3)
         # 构造基础消息信息
         message_info = BaseMessageInfo(
             platform=chat_stream.platform,
             message_id=message_id,
-            time=timestamp,
+            time=current_timestamp,
             group_info=chat_stream.group_info,
             user_info=user_info,
         )
@@ -164,11 +166,12 @@ class MessageProcessBase(Message):
         message_segment: Optional[Seg] = None,
         reply: Optional["MessageRecv"] = None,
         thinking_start_time: float = 0,
+        timestamp: Optional[float] = None,
     ):
-        # 调用父类初始化
+        # 调用父类初始化，传递时间戳
         super().__init__(
             message_id=message_id,
-            timestamp=round(time.time(), 3),  # 保留3位小数
+            timestamp=timestamp,
             chat_stream=chat_stream,
             user_info=bot_user_info,
             message_segment=message_segment,
@@ -238,8 +241,9 @@ class MessageThinking(MessageProcessBase):
         bot_user_info: UserInfo,
         reply: Optional["MessageRecv"] = None,
         thinking_start_time: float = 0,
+        timestamp: Optional[float] = None,
     ):
-        # 调用父类初始化
+        # 调用父类初始化，传递时间戳
         super().__init__(
             message_id=message_id,
             chat_stream=chat_stream,
@@ -247,6 +251,7 @@ class MessageThinking(MessageProcessBase):
             message_segment=None,  # 思考状态不需要消息段
             reply=reply,
             thinking_start_time=thinking_start_time,
+            timestamp=timestamp,
         )
 
         # 思考状态特有属性
@@ -289,7 +294,9 @@ class MessageSending(MessageProcessBase):
 
     def set_reply(self, reply: Optional["MessageRecv"] = None):
         """设置回复消息"""
-        if self.message_info.format_info is not None and "reply" in self.message_info.format_info.accept_format:
+        # print(f"set_reply: {reply}")
+        # if self.message_info.format_info is not None and "reply" in self.message_info.format_info.accept_format:
+        if True:
             if reply:
                 self.reply = reply
             if self.reply:

src/plugins/chat/message_sender.py

@@ -209,25 +209,32 @@ class MessageManager:
             _ = message.update_thinking_time()  # 更新思考时间
             thinking_start_time = message.thinking_start_time
             now_time = time.time()
+            logger.debug(f"thinking_start_time:{thinking_start_time},now_time:{now_time}")
             thinking_messages_count, thinking_messages_length = count_messages_between(
                 start_time=thinking_start_time, end_time=now_time, stream_id=message.chat_stream.stream_id
             )
+            # print(f"message.reply:{message.reply}")
 
             # --- 条件应用 set_reply 逻辑 ---
+            logger.debug(
+                f"[message.apply_set_reply_logic:{message.apply_set_reply_logic},message.is_head:{message.is_head},thinking_messages_count:{thinking_messages_count},thinking_messages_length:{thinking_messages_length},message.is_private_message():{message.is_private_message()}]"
+            )
             if (
                 message.apply_set_reply_logic  # 检查标记
                 and message.is_head
-                and (thinking_messages_count > 4 or thinking_messages_length > 250)
+                and (thinking_messages_count > 3 or thinking_messages_length > 200)
                 and not message.is_private_message()
             ):
                 logger.debug(
                     f"[{message.chat_stream.stream_id}] 应用 set_reply 逻辑: {message.processed_plain_text[:20]}..."
                 )
-                message.set_reply()
+                message.set_reply(message.reply)
             # --- 结束条件 set_reply ---
 
             await message.process()  # 预处理消息内容
 
+            logger.debug(f"{message}")
+
             # 使用全局 message_sender 实例
             await send_message(message)
             await self.storage.store_message(message, message.chat_stream)

src/plugins/chat/utils.py

@@ -6,13 +6,13 @@ from collections import Counter
 import jieba
 import numpy as np
 from src.common.logger import get_module_logger
+from pymongo.errors import PyMongoError
 
 from ..models.utils_model import LLMRequest
 from ..utils.typo_generator import ChineseTypoGenerator
 from ...config.config import global_config
-from .message import MessageRecv, Message
+from .message import MessageRecv
 from maim_message import UserInfo
-from .chat_stream import ChatStream
 from ..moods.moods import MoodManager
 from ...common.database import db
 
@@ -107,55 +107,6 @@ async def get_embedding(text, request_type="embedding"):
     return embedding
 
 
-async def get_recent_group_messages(chat_id: str, limit: int = 12) -> list:
-    """从数据库获取群组最近的消息记录
-
-    Args:
-        chat_id: 群组ID
-        limit: 获取消息数量，默认12条
-
-    Returns:
-        list: Message对象列表，按时间正序排列
-    """
-
-    # 从数据库获取最近消息
-    recent_messages = list(
-        db.messages.find(
-            {"chat_id": chat_id},
-        )
-        .sort("time", -1)
-        .limit(limit)
-    )
-
-    if not recent_messages:
-        return []
-
-    # 转换为 Message对象列表
-    message_objects = []
-    for msg_data in recent_messages:
-        try:
-            chat_info = msg_data.get("chat_info", {})
-            chat_stream = ChatStream.from_dict(chat_info)
-            user_info = msg_data.get("user_info", {})
-            user_info = UserInfo.from_dict(user_info)
-            msg = Message(
-                message_id=msg_data["message_id"],
-                chat_stream=chat_stream,
-                timestamp=msg_data["time"],
-                user_info=user_info,
-                processed_plain_text=msg_data.get("processed_text", ""),
-                detailed_plain_text=msg_data.get("detailed_plain_text", ""),
-            )
-            message_objects.append(msg)
-        except KeyError:
-            logger.warning("数据库中存在无效的消息")
-            continue
-
-    # 按时间正序排列
-    message_objects.reverse()
-    return message_objects
-
-
 def get_recent_group_detailed_plain_text(chat_stream_id: str, limit: int = 12, combine=False):
     recent_messages = list(
         db.messages.find(
@@ -613,93 +564,45 @@ def count_messages_between(start_time: float, end_time: float, stream_id: str) -
     """计算两个时间点之间的消息数量和文本总长度
 
     Args:
-        start_time (float): 起始时间戳
-        end_time (float): 结束时间戳
+        start_time (float): 起始时间戳 (不包含)
+        end_time (float): 结束时间戳 (包含)
         stream_id (str): 聊天流ID
 
     Returns:
         tuple[int, int]: (消息数量, 文本总长度)
-        - 消息数量：包含起始时间的消息，不包含结束时间的消息
-        - 文本总长度：所有消息的processed_plain_text长度之和
     """
+    count = 0
+    total_length = 0
+
+    # 参数校验 (可选但推荐)
+    if start_time >= end_time:
+        # logger.debug(f"开始时间 {start_time} 大于或等于结束时间 {end_time}，返回 0, 0")
+        return 0, 0
+    if not stream_id:
+        logger.error("stream_id 不能为空")
+        return 0, 0
+
+    # 直接查询时间范围内的消息
+    # time > start_time AND time <= end_time
+    query = {"chat_id": stream_id, "time": {"$gt": start_time, "$lte": end_time}}
+
     try:
-        # 获取开始时间之前最新的一条消息
-        start_message = db.messages.find_one(
-            {"chat_id": stream_id, "time": {"$lte": start_time}},
-            sort=[("time", -1), ("_id", -1)],  # 按时间倒序，_id倒序（最后插入的在前）
-        )
+        # 执行查询
+        messages_cursor = db.messages.find(query)
 
-        # 获取结束时间最近的一条消息
-        # 先找到结束时间点的所有消息
-        end_time_messages = list(
-            db.messages.find(
-                {"chat_id": stream_id, "time": {"$lte": end_time}},
-                sort=[("time", -1)],  # 先按时间倒序
-            ).limit(10)
-        )  # 限制查询数量，避免性能问题
-
-        if not end_time_messages:
-            logger.warning(f"未找到结束时间 {end_time} 之前的消息")
-            return 0, 0
-
-        # 找到最大时间
-        max_time = end_time_messages[0]["time"]
-        # 在最大时间的消息中找最后插入的（_id最大的）
-        end_message = max([msg for msg in end_time_messages if msg["time"] == max_time], key=lambda x: x["_id"])
-
-        if not start_message:
-            logger.warning(f"未找到开始时间 {start_time} 之前的消息")
-            return 0, 0
-
-        # 调试输出
-        # print("\n=== 消息范围信息 ===")
-        # print("Start message:", {
-        #     "message_id": start_message.get("message_id"),
-        #     "time": start_message.get("time"),
-        #     "text": start_message.get("processed_plain_text", ""),
-        #     "_id": str(start_message.get("_id"))
-        # })
-        # print("End message:", {
-        #     "message_id": end_message.get("message_id"),
-        #     "time": end_message.get("time"),
-        #     "text": end_message.get("processed_plain_text", ""),
-        #     "_id": str(end_message.get("_id"))
-        # })
-        # print("Stream ID:", stream_id)
-
-        # 如果结束消息的时间等于开始时间，返回0
-        if end_message["time"] == start_message["time"]:
-            return 0, 0
-
-        # 获取并打印这个时间范围内的所有消息
-        # print("\n=== 时间范围内的所有消息 ===")
-        all_messages = list(
-            db.messages.find(
-                {"chat_id": stream_id, "time": {"$gte": start_message["time"], "$lte": end_message["time"]}},
-                sort=[("time", 1), ("_id", 1)],  # 按时间正序，_id正序
-            )
-        )
-
-        count = 0
-        total_length = 0
-        for msg in all_messages:
+        # 遍历结果计算数量和长度
+        for msg in messages_cursor:
             count += 1
-            text_length = len(msg.get("processed_plain_text", ""))
-            total_length += text_length
-            # print(f"\n消息 {count}:")
-            # print({
-            #     "message_id": msg.get("message_id"),
-            #     "time": msg.get("time"),
-            #     "text": msg.get("processed_plain_text", ""),
-            #     "text_length": text_length,
-            #     "_id": str(msg.get("_id"))
-            # })
+            total_length += len(msg.get("processed_plain_text", ""))
 
-        # 如果时间不同，需要把end_message本身也计入
-        return count - 1, total_length
+        # logger.debug(f"查询范围 ({start_time}, {end_time}] 内找到 {count} 条消息，总长度 {total_length}")
+        return count, total_length
 
-    except Exception as e:
-        logger.error(f"计算消息数量时出错: {str(e)}")
+    except PyMongoError as e:
+        logger.error(f"查询 stream_id={stream_id} 在 ({start_time}, {end_time}] 范围内的消息时出错: {e}")
+        return 0, 0
+    except Exception as e:  # 保留一个通用异常捕获以防万一
+        logger.error(f"计算消息数量时发生意外错误: {e}")
         return 0, 0
 
 

src/plugins/heartFC_chat/heartFC_chat.py

@@ -26,7 +26,7 @@ from .heartFC_sender import HeartFCSender
 from src.plugins.chat.utils import process_llm_response
 from src.plugins.respon_info_catcher.info_catcher import info_catcher_manager
 from src.plugins.moods.moods import MoodManager
-from src.individuality.individuality import Individuality
+from src.heart_flow.utils_chat import get_chat_type_and_target_info
 from src.plugins.group_nickname.nickname_utils import trigger_nickname_analysis_if_needed
 
 
@@ -195,7 +195,12 @@ class HeartFChatting:
         self.on_consecutive_no_reply_callback = on_consecutive_no_reply_callback
 
         # 日志前缀
-        self.log_prefix: str = f"[{chat_manager.get_stream_name(chat_id) or chat_id}]"
+        self.log_prefix: str = str(chat_id)  # Initial default, will be updated
+
+        # --- Initialize attributes (defaults) ---
+        self.is_group_chat: bool = False
+        self.chat_target_info: Optional[dict] = None
+        # --- End Initialization ---
 
         # 动作管理器
         self.action_manager = ActionManager()
@@ -235,22 +240,35 @@ class HeartFChatting:
 
     async def _initialize(self) -> bool:
         """
-        懒初始化以使用提供的标识符解析chat_stream。
-        确保实例已准备好处理触发器。
+        懒初始化，解析chat_stream, 获取聊天类型和目标信息。
         """
         if self._initialized:
             return True
 
-        self.chat_stream = chat_manager.get_stream(self.stream_id)
-        if not self.chat_stream:
-            logger.error(f"{self.log_prefix} 获取ChatStream失败。")
+        # --- Use utility function to determine chat type and fetch info ---
+        # Note: get_chat_type_and_target_info handles getting the chat_stream internally
+        self.is_group_chat, self.chat_target_info = await get_chat_type_and_target_info(self.stream_id)
+
+        # Update log prefix based on potential stream name (if needed, or get it from chat_stream if util doesn't return it)
+        # Assuming get_chat_type_and_target_info focuses only on type/target
+        # We still need the chat_stream object itself for other operations
+        try:
+            self.chat_stream = await asyncio.to_thread(chat_manager.get_stream, self.stream_id)
+            if not self.chat_stream:
+                logger.error(
+                    f"[HFC:{self.stream_id}] 获取ChatStream失败 during _initialize, though util func might have succeeded earlier."
+                )
+                return False  # Cannot proceed without chat_stream object
+            # Update log prefix using the fetched stream object
+            self.log_prefix = f"[{chat_manager.get_stream_name(self.stream_id) or self.stream_id}]"
+        except Exception as e:
+            logger.error(f"[HFC:{self.stream_id}] 获取ChatStream时出错 in _initialize: {e}")
             return False
 
-        # 更新日志前缀（以防流名称发生变化）
-        self.log_prefix = f"[{chat_manager.get_stream_name(self.stream_id) or self.stream_id}]"
+        # --- End using utility function ---
 
         self._initialized = True
-        logger.debug(f"{self.log_prefix}麦麦感觉到了，可以开始认真水群 ")
+        logger.debug(f"{self.log_prefix} 麦麦感觉到了，可以开始认真水群 ")
         return True
 
     async def start(self):
@@ -844,18 +862,15 @@ class HeartFChatting:
                     f"{self.log_prefix}[Planner] 临时移除的动作: {actions_to_remove_temporarily}, 当前可用: {list(current_available_actions.keys())}"
                 )
 
-            # --- 构建提示词 (调用修改后的 _build_planner_prompt) ---
-            # replan_prompt_str = "" # 暂时简化
-            # if is_re_planned:
-            #     replan_prompt_str = await self._build_replan_prompt(
-            #         self._current_cycle.action_type, self._current_cycle.reasoning
-            #     )
-            prompt = await self._build_planner_prompt(
-                observed_messages_str,
-                current_mind,
-                self.sub_mind.structured_info,
-                "",  # replan_prompt_str,
-                current_available_actions,  # <--- 传入当前可用动作
+            # --- 构建提示词 (调用修改后的 PromptBuilder 方法) ---
+            prompt = await prompt_builder.build_planner_prompt(
+                is_group_chat=self.is_group_chat,  # <-- Pass HFC state
+                chat_target_info=self.chat_target_info,  # <-- Pass HFC state
+                cycle_history=self._cycle_history,  # <-- Pass HFC state
+                observed_messages_str=observed_messages_str,  # <-- Pass local variable
+                current_mind=current_mind,  # <-- Pass argument
+                structured_info=self.sub_mind.structured_info_str,  # <-- Pass SubMind info
+                current_available_actions=current_available_actions,  # <-- Pass determined actions
             )
 
             # --- 调用 LLM (普通文本生成) ---
@@ -1119,217 +1134,6 @@ class HeartFChatting:
 
         return prompt
 
-    async def _build_planner_prompt(
-        self,
-        observed_messages_str: str,
-        current_mind: Optional[str],
-        structured_info: Dict[str, Any],
-        replan_prompt: str,
-        current_available_actions: Dict[str, str],
-    ) -> str:
-        """构建 Planner LLM 的提示词 (获取模板并填充数据)"""
-        try:
-            # 准备结构化信息块
-            structured_info_block = ""
-            if structured_info:
-                structured_info_block = f"以下是一些额外的信息：\n{structured_info}\n"
-
-            # 准备聊天内容块
-            chat_content_block = ""
-            if observed_messages_str:
-                chat_content_block = "观察到的最新聊天内容如下：\n---\n"
-                chat_content_block += observed_messages_str
-                chat_content_block += "\n---"
-            else:
-                chat_content_block = "当前没有观察到新的聊天内容。\n"
-
-            # 准备当前思维块 (修改以匹配模板)
-            current_mind_block = ""
-            if current_mind:
-                # 模板中占位符是 {current_mind_block}，它期望包含"你的内心想法："的前缀
-                current_mind_block = f"你的内心想法：\n{current_mind}"
-            else:
-                current_mind_block = "你的内心想法：\n[没有特别的想法]"
-
-            # 准备循环信息块 (分析最近的活动循环)
-            recent_active_cycles = []
-            for cycle in reversed(self._cycle_history):
-                # 只关心实际执行了动作的循环
-                if cycle.action_taken:
-                    recent_active_cycles.append(cycle)
-                    # 最多找最近的3个活动循环
-                    if len(recent_active_cycles) == 3:
-                        break
-
-            cycle_info_block = ""
-            consecutive_text_replies = 0
-            responses_for_prompt = []
-
-            # 检查这最近的活动循环中有多少是连续的文本回复 (从最近的开始看)
-            for cycle in recent_active_cycles:
-                if cycle.action_type == "text_reply":
-                    consecutive_text_replies += 1
-                    # 获取回复内容，如果不存在则返回'[空回复]'
-                    response_text = cycle.response_info.get("response_text", [])
-                    # 使用简单的 join 来格式化回复内容列表
-                    formatted_response = "[空回复]" if not response_text else " ".join(response_text)
-                    responses_for_prompt.append(formatted_response)
-                else:
-                    # 一旦遇到非文本回复，连续性中断
-                    break
-
-            # 根据连续文本回复的数量构建提示信息
-            # 注意: responses_for_prompt 列表是从最近到最远排序的
-            if consecutive_text_replies >= 3:  # 如果最近的三个活动都是文本回复
-                cycle_info_block = f'你已经连续回复了三条消息（最近: "{responses_for_prompt[0]}"，第二近: "{responses_for_prompt[1]}"，第三近: "{responses_for_prompt[2]}"）。你回复的有点多了，请注意'
-            elif consecutive_text_replies == 2:  # 如果最近的两个活动是文本回复
-                cycle_info_block = f'你已经连续回复了两条消息（最近: "{responses_for_prompt[0]}"，第二近: "{responses_for_prompt[1]}"），请注意'
-            elif consecutive_text_replies == 1:  # 如果最近的一个活动是文本回复
-                cycle_info_block = f'你刚刚已经回复一条消息（内容: "{responses_for_prompt[0]}"）'
-
-            # 包装提示块，增加可读性，即使没有连续回复也给个标记
-            if cycle_info_block:
-                # 模板中占位符是 {cycle_info_block}，它期望包含"【近期回复历史】"的前缀
-                cycle_info_block = f"\n【近期回复历史】\n{cycle_info_block}\n"
-            else:
-                # 如果最近的活动循环不是文本回复，或者没有活动循环
-                cycle_info_block = "\n【近期回复历史】\n(最近没有连续文本回复)\n"
-
-            individuality = Individuality.get_instance()
-            # 模板中占位符是 {prompt_personality}
-            prompt_personality = individuality.get_prompt(x_person=2, level=2)
-
-            # --- 构建可用动作描述 (用于填充模板中的 {action_options_text}) ---
-            action_options_text = "当前你可以选择的行动有：\n"
-            action_keys = list(current_available_actions.keys())
-            for name in action_keys:
-                desc = current_available_actions[name]
-                action_options_text += f"- '{name}': {desc}\n"
-
-            # --- 选择一个示例动作键 (用于填充模板中的 {example_action}) ---
-            example_action_key = action_keys[0] if action_keys else "no_reply"
-
-            # --- 获取提示词模板 ---
-            planner_prompt_template = await global_prompt_manager.get_prompt_async("planner_prompt")
-
-            # --- 填充模板 ---
-            prompt = planner_prompt_template.format(
-                bot_name=global_config.BOT_NICKNAME,
-                prompt_personality=prompt_personality,
-                structured_info_block=structured_info_block,
-                chat_content_block=chat_content_block,
-                current_mind_block=current_mind_block,
-                replan="",  # 暂时留空 replan 信息
-                cycle_info_block=cycle_info_block,
-                action_options_text=action_options_text,  # 传入可用动作描述
-                example_action=example_action_key,  # 传入示例动作键
-            )
-
-            return prompt
-
-        except Exception as e:
-            logger.error(f"{self.log_prefix}[Planner] 构建提示词时出错: {e}")
-            logger.error(traceback.format_exc())
-            return "[构建 Planner Prompt 时出错]"  # 返回错误提示，避免空字符串
-
-    # --- 回复器 (Replier) 的定义 --- #
-    async def _replier_work(
-        self,
-        reason: str,
-        anchor_message: MessageRecv,
-        thinking_id: str,
-    ) -> Optional[List[str]]:
-        """
-        回复器 (Replier): 核心逻辑，负责生成回复文本。
-        (已整合原 HeartFCGenerator 的功能)
-        """
-        try:
-            # 1. 获取情绪影响因子并调整模型温度
-            arousal_multiplier = MoodManager.get_instance().get_arousal_multiplier()
-            current_temp = global_config.llm_normal["temp"] * arousal_multiplier
-            self.model_normal.temperature = current_temp  # 动态调整温度
-
-            # 2. 获取信息捕捉器
-            info_catcher = info_catcher_manager.get_info_catcher(thinking_id)
-
-            # 3. 构建 Prompt
-            with Timer("构建Prompt", {}):  # 内部计时器，可选保留
-                prompt = await prompt_builder.build_prompt(
-                    build_mode="focus",
-                    reason=reason,
-                    current_mind_info=self.sub_mind.current_mind,
-                    structured_info=self.sub_mind.structured_info,
-                    message_txt="",  # 似乎是固定的空字符串
-                    sender_name="",  # 似乎是固定的空字符串
-                    chat_stream=anchor_message.chat_stream,
-                )
-
-            # 4. 调用 LLM 生成回复
-            content = None
-            reasoning_content = None
-            model_name = "unknown_model"
-            try:
-                with Timer("LLM生成", {}):  # 内部计时器，可选保留
-                    content, reasoning_content, model_name = await self.model_normal.generate_response(prompt)
-                # logger.info(f"{self.log_prefix}[Replier-{thinking_id}]\\nPrompt:\\n{prompt}\\n生成回复: {content}\\n")
-                # 捕捉 LLM 输出信息
-                info_catcher.catch_after_llm_generated(
-                    prompt=prompt, response=content, reasoning_content=reasoning_content, model_name=model_name
-                )
-
-            except Exception as llm_e:
-                # 精简报错信息
-                logger.error(f"{self.log_prefix}[Replier-{thinking_id}] LLM 生成失败: {llm_e}")
-                return None  # LLM 调用失败则无法生成回复
-
-            # 5. 处理 LLM 响应
-            if not content:
-                logger.warning(f"{self.log_prefix}[Replier-{thinking_id}] LLM 生成了空内容。")
-                return None
-
-            with Timer("处理响应", {}):  # 内部计时器，可选保留
-                processed_response = process_llm_response(content)
-
-            if not processed_response:
-                logger.warning(f"{self.log_prefix}[Replier-{thinking_id}] 处理后的回复为空。")
-                return None
-
-            return processed_response
-
-        except Exception as e:
-            # 更通用的错误处理，精简信息
-            logger.error(f"{self.log_prefix}[Replier-{thinking_id}] 回复生成意外失败: {e}")
-            # logger.error(traceback.format_exc()) # 可以取消注释这行以在调试时查看完整堆栈
-            return None
-
-    # --- Methods moved from HeartFCController start ---
-    async def _create_thinking_message(self, anchor_message: Optional[MessageRecv]) -> Optional[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
-        bot_user_info = UserInfo(
-            user_id=global_config.BOT_QQ,
-            user_nickname=global_config.BOT_NICKNAME,
-            platform=messageinfo.platform,
-        )
-
-        thinking_time_point = round(time.time(), 2)
-        thinking_id = "mt" + str(thinking_time_point)
-        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,
-        )
-        # Access MessageManager directly
-        await self.heart_fc_sender.register_thinking(thinking_message)
-        return thinking_id
-
     async def _send_response_messages(
         self, anchor_message: Optional[MessageRecv], response_set: List[str], thinking_id: str
     ) -> Optional[MessageSending]:
@@ -1465,3 +1269,118 @@ class HeartFChatting:
         if self._cycle_history:
             return self._cycle_history[-1].to_dict()
         return None
+
+    # --- 回复器 (Replier) 的定义 --- #
+    async def _replier_work(
+        self,
+        reason: str,
+        anchor_message: MessageRecv,
+        thinking_id: str,
+    ) -> Optional[List[str]]:
+        """
+        回复器 (Replier): 核心逻辑，负责生成回复文本。
+        (已整合原 HeartFCGenerator 的功能)
+        """
+        try:
+            # 1. 获取情绪影响因子并调整模型温度
+            arousal_multiplier = MoodManager.get_instance().get_arousal_multiplier()
+            current_temp = global_config.llm_normal["temp"] * arousal_multiplier
+            self.model_normal.temperature = current_temp  # 动态调整温度
+
+            # 2. 获取信息捕捉器
+            info_catcher = info_catcher_manager.get_info_catcher(thinking_id)
+
+            # --- Determine sender_name for private chat ---
+            sender_name_for_prompt = "某人"  # Default for group or if info unavailable
+            if not self.is_group_chat and self.chat_target_info:
+                # Prioritize person_name, then nickname
+                sender_name_for_prompt = (
+                    self.chat_target_info.get("person_name")
+                    or self.chat_target_info.get("user_nickname")
+                    or sender_name_for_prompt
+                )
+            # --- End determining sender_name ---
+
+            # 3. 构建 Prompt
+            with Timer("构建Prompt", {}):  # 内部计时器，可选保留
+                prompt = await prompt_builder.build_prompt(
+                    build_mode="focus",
+                    chat_stream=self.chat_stream,  # Pass the stream object
+                    # Focus specific args:
+                    reason=reason,
+                    current_mind_info=self.sub_mind.current_mind,
+                    structured_info=self.sub_mind.structured_info_str,
+                    sender_name=sender_name_for_prompt,  # Pass determined name
+                    # Normal specific args (not used in focus mode):
+                    # message_txt="",
+                )
+
+            # 4. 调用 LLM 生成回复
+            content = None
+            reasoning_content = None
+            model_name = "unknown_model"
+            if not prompt:
+                logger.error(f"{self.log_prefix}[Replier-{thinking_id}] Prompt 构建失败，无法生成回复。")
+                return None
+
+            try:
+                with Timer("LLM生成", {}):  # 内部计时器，可选保留
+                    content, reasoning_content, model_name = await self.model_normal.generate_response(prompt)
+                # logger.info(f"{self.log_prefix}[Replier-{thinking_id}]\nPrompt:\n{prompt}\n生成回复: {content}\n")
+                # 捕捉 LLM 输出信息
+                info_catcher.catch_after_llm_generated(
+                    prompt=prompt, response=content, reasoning_content=reasoning_content, model_name=model_name
+                )
+
+            except Exception as llm_e:
+                # 精简报错信息
+                logger.error(f"{self.log_prefix}[Replier-{thinking_id}] LLM 生成失败: {llm_e}")
+                return None  # LLM 调用失败则无法生成回复
+
+            # 5. 处理 LLM 响应
+            if not content:
+                logger.warning(f"{self.log_prefix}[Replier-{thinking_id}] LLM 生成了空内容。")
+                return None
+
+            with Timer("处理响应", {}):  # 内部计时器，可选保留
+                processed_response = process_llm_response(content)
+
+            if not processed_response:
+                logger.warning(f"{self.log_prefix}[Replier-{thinking_id}] 处理后的回复为空。")
+                return None
+
+            return processed_response
+
+        except Exception as e:
+            # 更通用的错误处理，精简信息
+            logger.error(f"{self.log_prefix}[Replier-{thinking_id}] 回复生成意外失败: {e}")
+            # logger.error(traceback.format_exc()) # 可以取消注释这行以在调试时查看完整堆栈
+            return None
+
+    # --- Methods moved from HeartFCController start ---
+    async def _create_thinking_message(self, anchor_message: Optional[MessageRecv]) -> Optional[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
+        bot_user_info = UserInfo(
+            user_id=global_config.BOT_QQ,
+            user_nickname=global_config.BOT_NICKNAME,
+            platform=messageinfo.platform,
+        )
+
+        thinking_time_point = round(time.time(), 2)
+        thinking_id = "mt" + str(thinking_time_point)
+        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,
+        )
+        # Access MessageManager directly (using heart_fc_sender)
+        await self.heart_fc_sender.register_thinking(thinking_message)
+        return thinking_id

src/plugins/heartFC_chat/heartflow_prompt_builder.py

@@ -1,6 +1,6 @@
 import random
 import time
-from typing import Union, Optional
+from typing import Union, Optional, Deque, Dict, Any
 from ...config.config import global_config
 from src.common.logger_manager import get_logger
 from ...individuality.individuality import Individuality
@@ -15,6 +15,8 @@ from ..memory_system.Hippocampus import HippocampusManager
 from ..schedule.schedule_generator import bot_schedule
 from ..knowledge.knowledge_lib import qa_manager
 from src.plugins.group_nickname.nickname_utils import get_nickname_injection_for_prompt
+import traceback
+from .heartFC_Cycleinfo import CycleInfo
 
 logger = get_logger("prompt")
 
@@ -51,7 +53,7 @@ def init_prompt():
 
     # Planner提示词 - 修改为要求 JSON 输出
     Prompt(
-        """你的名字是{bot_name},{prompt_personality}，你现在正在一个群聊中。需要基于以下信息决定如何参与对话：
+        """你的名字是{bot_name},{prompt_personality}，{chat_context_description}。需要基于以下信息决定如何参与对话：
 {structured_info_block}
 {chat_content_block}
 {current_mind_block}
@@ -61,27 +63,27 @@ def init_prompt():
 
 【回复原则】
 1. 不回复(no_reply)适用：
-- 话题无关/无聊/不感兴趣
-- 最后一条消息是你自己发的且无人回应你
-- 讨论你不懂的专业话题
-- 你发送了太多消息，且无人回复
+   - 话题无关/无聊/不感兴趣
+   - 最后一条消息是你自己发的且无人回应你
+   - 讨论你不懂的专业话题
+   - 你发送了太多消息，且无人回复
 
 2. 文字回复(text_reply)适用：
-- 有实质性内容需要表达
-- 有人提到你，但你还没有回应他
-- 可以追加emoji_query表达情绪(emoji_query填写表情包的适用场合，也就是当前场合)
-- 不要追加太多表情
+   - 有实质性内容需要表达
+   - 有人提到你，但你还没有回应他
+   - 可以追加emoji_query表达情绪(emoji_query填写表情包的适用场合，也就是当前场合)
+   - 不要追加太多表情
 
 3. 纯表情回复(emoji_reply)适用：
-- 适合用表情回应的场景
-- 需提供明确的emoji_query
+   - 适合用表情回应的场景
+   - 需提供明确的emoji_query
 
 4. 自我对话处理：
-- 如果是自己发的消息想继续，需自然衔接
-- 避免重复或评价自己的发言
-- 不要和自己聊天
+   - 如果是自己发的消息想继续，需自然衔接
+   - 避免重复或评价自己的发言
+   - 不要和自己聊天
 
-【决策任务】
+决策任务
 {action_options_text}
 
 你必须从上面列出的可用行动中选择一个，并说明原因。
@@ -92,23 +94,9 @@ JSON 结构如下，包含三个字段 "action", "reasoning", "emoji_query":
   "reasoning": "string", // 做出此决定的详细理由和思考过程，说明你如何应用了回复原则
   "emoji_query": "string" // 可选。如果行动是 'emoji_reply'，必须提供表情主题(填写表情包的适用场合)；如果行动是 'text_reply' 且你想附带表情，也在此提供表情主题，否则留空字符串 ""。遵循回复原则，不要滥用。
 }}
-
-例如:
-{{
-  "action": "text_reply",
-  "reasoning": "用户提到了我，且问题比较具体，适合用文本回复。考虑到内容，可以带上一个微笑表情。",
-  "emoji_query": "微笑"
-}}
-或
-{{
-  "action": "no_reply",
-  "reasoning": "我已经连续回复了两次，而且这个话题我不太感兴趣，根据回复原则，选择不回复，等待其他人发言。",
-  "emoji_query": ""
-}}
-
 请输出你的决策 JSON：
-""",  # 使用三引号避免内部引号问题
-        "planner_prompt",  # 保持名称不变，替换内容
+""",
+        "planner_prompt",
     )
 
     Prompt(
@@ -153,24 +141,67 @@ JSON 结构如下，包含三个字段 "action", "reasoning", "emoji_query":
     Prompt("你现在正在做的事情是：{schedule_info}", "schedule_prompt")
     Prompt("\n你有以下这些**知识**：\n{prompt_info}\n请你**记住上面的知识**，之后可能会用到。\n", "knowledge_prompt")
 
+    # --- Template for HeartFChatting (FOCUSED mode) ---
+    Prompt(
+        """
+{info_from_tools}
+你正在和 {sender_name} 私聊。
+聊天记录如下：
+{chat_talking_prompt}
+现在你想要回复。
 
-async def _build_prompt_focus(reason, current_mind_info, structured_info, chat_stream, sender_name) -> tuple[str, str]:
+你需要扮演一位网名叫{bot_name}的人进行回复，这个人的特点是："{prompt_personality}"。
+你正在和 {sender_name} 私聊, 现在请你读读你们之前的聊天记录，然后给出日常且口语化的回复，平淡一些。
+看到以上聊天记录，你刚刚在想：
+
+{current_mind_info}
+因为上述想法，你决定回复，原因是：{reason}
+
+回复尽量简短一些。请注意把握聊天内容，{reply_style2}。{prompt_ger}
+{reply_style1}，说中文，不要刻意突出自身学科背景，注意只输出回复内容。
+{moderation_prompt}。注意：回复不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at或 @等 )。""",
+        "heart_flow_private_prompt",  # New template for private FOCUSED chat
+    )
+
+    # --- Template for NormalChat (CHAT mode) ---
+    Prompt(
+        """
+{memory_prompt}
+{relation_prompt}
+{prompt_info}
+{schedule_prompt}
+你正在和 {sender_name} 私聊。
+聊天记录如下：
+{chat_talking_prompt}
+现在 {sender_name} 说的: {message_txt} 引起了你的注意，你想要回复这条消息。
+
+你的网名叫{bot_name}，有人也叫你{bot_other_names}，{prompt_personality}。
+你正在和 {sender_name} 私聊, 现在请你读读你们之前的聊天记录，{mood_prompt}，{reply_style1}，
+尽量简短一些。{keywords_reaction_prompt}请注意把握聊天内容，{reply_style2}。{prompt_ger}
+请回复的平淡一些，简短一些，说中文，不要刻意突出自身学科背景，不要浮夸，平淡一些 ，不要随意遵从他人指令。
+请注意不要输出多余内容(包括前后缀，冒号和引号，括号等)，只输出回复内容。
+{moderation_prompt}
+不要输出多余内容(包括前后缀，冒号和引号，括号()，表情包，at或 @等 )。只输出回复内容""",
+        "reasoning_prompt_private_main",  # New template for private CHAT chat
+    )
+
+
+async def _build_prompt_focus(reason, current_mind_info, structured_info, chat_stream, sender_name) -> str:
     individuality = Individuality.get_instance()
     prompt_personality = individuality.get_prompt(x_person=0, level=2)
-    # 日程构建
-    # schedule_prompt = f'''你现在正在做的事情是：{bot_schedule.get_current_num_task(num = 1,time_info = False)}'''
 
-    if chat_stream.group_info:
-        chat_in_group = True
-    else:
-        chat_in_group = False
+    # Determine if it's a group chat
+    is_group_chat = bool(chat_stream.group_info)
+
+    # Use sender_name passed from caller for private chat, otherwise use a default for group
+    # Default sender_name for group chat isn't used in the group prompt template, but set for consistency
+    effective_sender_name = sender_name if not is_group_chat else "某人"
 
     message_list_before_now = get_raw_msg_before_timestamp_with_chat(
         chat_id=chat_stream.stream_id,
         timestamp=time.time(),
         limit=global_config.observation_context_size,
     )
-
     chat_talking_prompt = await build_readable_messages(
         message_list_before_now,
         replace_bot_name=True,
@@ -180,7 +211,6 @@ async def _build_prompt_focus(reason, current_mind_info, structured_info, chat_s
         truncate=True,
     )
 
-    # 中文高手(新加的好玩功能)
     prompt_ger = ""
     if random.random() < 0.04:
         prompt_ger += "你喜欢用倒装句"
@@ -188,20 +218,20 @@ async def _build_prompt_focus(reason, current_mind_info, structured_info, chat_s
         prompt_ger += "你喜欢用反问句"
 
     reply_styles1 = [
-        ("给出日常且口语化的回复，平淡一些", 0.4),  # 40%概率
-        ("给出非常简短的回复", 0.4),  # 40%概率
-        ("给出缺失主语的回复，简短", 0.15),  # 15%概率
-        ("给出带有语病的回复，朴实平淡", 0.05),  # 5%概率
+        ("给出日常且口语化的回复，平淡一些", 0.4),
+        ("给出非常简短的回复", 0.4),
+        ("给出缺失主语的回复，简短", 0.15),
+        ("给出带有语病的回复，朴实平淡", 0.05),
     ]
     reply_style1_chosen = random.choices(
         [style[0] for style in reply_styles1], weights=[style[1] for style in reply_styles1], k=1
     )[0]
 
     reply_styles2 = [
-        ("不要回复的太有条理，可以有个性", 0.6),  # 60%概率
-        ("不要回复的太有条理，可以复读", 0.15),  # 15%概率
-        ("回复的认真一些", 0.2),  # 20%概率
-        ("可以回复单个表情符号", 0.05),  # 5%概率
+        ("不要回复的太有条理，可以有个性", 0.6),
+        ("不要回复的太有条理，可以复读", 0.15),
+        ("回复的认真一些", 0.2),
+        ("可以回复单个表情符号", 0.05),
     ]
     reply_style2_chosen = random.choices(
         [style[0] for style in reply_styles2], weights=[style[1] for style in reply_styles2], k=1
@@ -214,35 +244,55 @@ async def _build_prompt_focus(reason, current_mind_info, structured_info, chat_s
     else:
         structured_info_prompt = ""
 
-    logger.debug("开始构建prompt")
+    logger.debug("开始构建 focus prompt")
 
-    # 调用新的工具函数获取绰号信息
-    nickname_injection_str = await get_nickname_injection_for_prompt(chat_stream, message_list_before_now)
+    # --- Choose template based on chat type ---
+    if is_group_chat:
+        template_name = "heart_flow_prompt"
+        # Group specific formatting variables (already fetched or default)
+        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")
 
-    prompt = await global_prompt_manager.format_prompt(
-        "heart_flow_prompt",
-        info_from_tools=structured_info_prompt,
+        # 调用新的工具函数获取绰号信息
+        nickname_injection_str = await get_nickname_injection_for_prompt(chat_stream, message_list_before_now)
+
+        prompt = await global_prompt_manager.format_prompt(
+            template_name,
+            info_from_tools=structured_info_prompt,
+            chat_target=chat_target_1,  # Used in group template
+            chat_talking_prompt=chat_talking_prompt,
+            bot_name=global_config.BOT_NICKNAME,
+            prompt_personality=prompt_personality,
+            chat_target_2=chat_target_2,  # Used in group template
+            current_mind_info=current_mind_info,
+            reply_style2=reply_style2_chosen,
+            reply_style1=reply_style1_chosen,
+            reason=reason,
+            prompt_ger=prompt_ger,
+            moderation_prompt=await global_prompt_manager.get_prompt_async("moderation_prompt"),
+            # sender_name is not used in the group template
+        )
+    else:  # Private chat
+        template_name = "heart_flow_private_prompt"
+        prompt = await global_prompt_manager.format_prompt(
+            template_name,
+            info_from_tools=structured_info_prompt,
         nickname_info=nickname_injection_str,
-        chat_target=await global_prompt_manager.get_prompt_async("chat_target_group1")
-        if chat_in_group
-        else await global_prompt_manager.get_prompt_async("chat_target_private1"),
-        chat_talking_prompt=chat_talking_prompt,
-        bot_name=global_config.BOT_NICKNAME,
-        prompt_personality=prompt_personality,
-        chat_target_2=await global_prompt_manager.get_prompt_async("chat_target_group2")
-        if chat_in_group
-        else await global_prompt_manager.get_prompt_async("chat_target_private2"),
-        current_mind_info=current_mind_info,
-        reply_style2=reply_style2_chosen,
-        reply_style1=reply_style1_chosen,
-        reason=reason,
-        prompt_ger=prompt_ger,
-        moderation_prompt=await global_prompt_manager.get_prompt_async("moderation_prompt"),
-        sender_name=sender_name,
-    )
-
-    logger.debug(f"focus_chat_prompt: \n{prompt}")
+            sender_name=effective_sender_name,  # Used in private template
+            chat_talking_prompt=chat_talking_prompt,
+            bot_name=global_config.BOT_NICKNAME,
+            prompt_personality=prompt_personality,
+            # chat_target and chat_target_2 are not used in private template
+            current_mind_info=current_mind_info,
+            reply_style2=reply_style2_chosen,
+            reply_style1=reply_style1_chosen,
+            reason=reason,
+            prompt_ger=prompt_ger,
+            moderation_prompt=await global_prompt_manager.get_prompt_async("moderation_prompt"),
+        )
+    # --- End choosing template ---
 
+    logger.debug(f"focus_chat_prompt (is_group={is_group_chat}): \n{prompt}")
     return prompt
 
 
@@ -254,13 +304,13 @@ class PromptBuilder:
     async def build_prompt(
         self,
         build_mode,
-        reason,
-        current_mind_info,
-        structured_info,
-        message_txt: str,
-        sender_name: str = "某人",
-        chat_stream=None,
-    ) -> Optional[tuple[str, str]]:
+        chat_stream,
+        reason=None,
+        current_mind_info=None,
+        structured_info=None,
+        message_txt=None,
+        sender_name="某人",
+    ) -> Optional[str]:
         if build_mode == "normal":
             return await self._build_prompt_normal(chat_stream, message_txt, sender_name)
 
@@ -274,54 +324,50 @@ class PromptBuilder:
             )
         return None
 
-    async def _build_prompt_normal(self, chat_stream, message_txt: str, sender_name: str = "某人") -> tuple[str, str]:
+    async def _build_prompt_normal(self, chat_stream, message_txt: str, sender_name: str = "某人") -> str:
         individuality = Individuality.get_instance()
         prompt_personality = individuality.get_prompt(x_person=2, level=2)
+        is_group_chat = bool(chat_stream.group_info)
 
-        # 关系
-        who_chat_in_group = [
-            (chat_stream.user_info.platform, chat_stream.user_info.user_id, chat_stream.user_info.user_nickname)
-        ]
-        who_chat_in_group += get_recent_group_speaker(
-            chat_stream.stream_id,
-            (chat_stream.user_info.platform, chat_stream.user_info.user_id),
-            limit=global_config.observation_context_size,
-        )
+        who_chat_in_group = []
+        if is_group_chat:
+            who_chat_in_group = get_recent_group_speaker(
+                chat_stream.stream_id,
+                (chat_stream.user_info.platform, chat_stream.user_info.user_id) if chat_stream.user_info else None,
+                limit=global_config.observation_context_size,
+            )
+        elif chat_stream.user_info:
+            who_chat_in_group.append(
+                (chat_stream.user_info.platform, chat_stream.user_info.user_id, chat_stream.user_info.user_nickname)
+            )
 
         relation_prompt = ""
         for person in who_chat_in_group:
-            relation_prompt += await relationship_manager.build_relationship_info(person)
-            # print(f"relation_prompt: {relation_prompt}")
+            if len(person) >= 3 and person[0] and person[1]:
+                relation_prompt += await relationship_manager.build_relationship_info(person)
+            else:
+                logger.warning(f"Invalid person tuple encountered for relationship prompt: {person}")
 
-        # print(f"relat11111111ion_prompt: {relation_prompt}")
-
-        # 心情
         mood_manager = MoodManager.get_instance()
         mood_prompt = mood_manager.get_prompt()
-
-        # logger.info(f"心情prompt: {mood_prompt}")
-
         reply_styles1 = [
-            ("然后给出日常且口语化的回复，平淡一些", 0.4),  # 40%概率
-            ("给出非常简短的回复", 0.4),  # 40%概率
-            ("给出缺失主语的回复", 0.15),  # 15%概率
-            ("给出带有语病的回复", 0.05),  # 5%概率
+            ("然后给出日常且口语化的回复，平淡一些", 0.4),
+            ("给出非常简短的回复", 0.4),
+            ("给出缺失主语的回复", 0.15),
+            ("给出带有语病的回复", 0.05),
         ]
         reply_style1_chosen = random.choices(
             [style[0] for style in reply_styles1], weights=[style[1] for style in reply_styles1], k=1
         )[0]
-
         reply_styles2 = [
-            ("不要回复的太有条理，可以有个性", 0.6),  # 60%概率
-            ("不要回复的太有条理，可以复读", 0.15),  # 15%概率
-            ("回复的认真一些", 0.2),  # 20%概率
-            ("可以回复单个表情符号", 0.05),  # 5%概率
+            ("不要回复的太有条理，可以有个性", 0.6),
+            ("不要回复的太有条理，可以复读", 0.15),
+            ("回复的认真一些", 0.2),
+            ("可以回复单个表情符号", 0.05),
         ]
         reply_style2_chosen = random.choices(
             [style[0] for style in reply_styles2], weights=[style[1] for style in reply_styles2], k=1
         )[0]
-
-        # 调取记忆
         memory_prompt = ""
         related_memory = await HippocampusManager.get_instance().get_memory_from_text(
             text=message_txt, max_memory_num=2, max_memory_length=2, max_depth=3, fast_retrieval=False
@@ -330,23 +376,15 @@ class PromptBuilder:
         if related_memory:
             for memory in related_memory:
                 related_memory_info += memory[1]
-            # memory_prompt = f"你想起你之前见过的事情：{related_memory_info}。\n以上是你的回忆，不一定是目前聊天里的人说的，也不一定是现在发生的事情，请记住。\n"
             memory_prompt = await global_prompt_manager.format_prompt(
                 "memory_prompt", related_memory_info=related_memory_info
             )
 
-        # 获取聊天上下文
-        if chat_stream.group_info:
-            chat_in_group = True
-        else:
-            chat_in_group = False
-
         message_list_before_now = get_raw_msg_before_timestamp_with_chat(
             chat_id=chat_stream.stream_id,
             timestamp=time.time(),
             limit=global_config.observation_context_size,
         )
-
         chat_talking_prompt = await build_readable_messages(
             message_list_before_now,
             replace_bot_name=True,
@@ -390,14 +428,11 @@ class PromptBuilder:
         start_time = time.time()
         prompt_info = await self.get_prompt_info(message_txt, threshold=0.38)
         if prompt_info:
-            # prompt_info = f"""\n你有以下这些**知识**：\n{prompt_info}\n请你**记住上面的知识**，之后可能会用到。\n"""
             prompt_info = await global_prompt_manager.format_prompt("knowledge_prompt", prompt_info=prompt_info)
 
         end_time = time.time()
         logger.debug(f"知识检索耗时: {(end_time - start_time):.3f}秒")
 
-        logger.debug("开始构建prompt")
-
         if global_config.ENABLE_SCHEDULE_GEN:
             schedule_prompt = await global_prompt_manager.format_prompt(
                 "schedule_prompt", schedule_info=bot_schedule.get_current_num_task(num=1, time_info=False)
@@ -405,37 +440,64 @@ class PromptBuilder:
         else:
             schedule_prompt = ""
 
-        # 调用新的工具函数获取绰号信息
+        logger.debug("开始构建 normal prompt")
+
+        # --- Choose template and format based on chat type ---
+        if is_group_chat:
+            template_name = "reasoning_prompt_main"
+            effective_sender_name = sender_name
+            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")
+
+            prompt = await global_prompt_manager.format_prompt(
+                template_name,
+                relation_prompt=relation_prompt,
+                sender_name=effective_sender_name,
+                memory_prompt=memory_prompt,
+                prompt_info=prompt_info,
+                schedule_prompt=schedule_prompt,
+                chat_target=chat_target_1,
+                chat_target_2=chat_target_2,
+                chat_talking_prompt=chat_talking_prompt,
+                message_txt=message_txt,
+                bot_name=global_config.BOT_NICKNAME,
+                bot_other_names="/".join(global_config.BOT_ALIAS_NAMES),
+                prompt_personality=prompt_personality,
+                mood_prompt=mood_prompt,
+                reply_style1=reply_style1_chosen,
+                reply_style2=reply_style2_chosen,
+                keywords_reaction_prompt=keywords_reaction_prompt,
+                prompt_ger=prompt_ger,
+                moderation_prompt=await global_prompt_manager.get_prompt_async("moderation_prompt"),
+            )
+        else:
+            template_name = "reasoning_prompt_private_main"
+            effective_sender_name = sender_name
+
+            # 调用新的工具函数获取绰号信息
         nickname_injection_str = await get_nickname_injection_for_prompt(chat_stream, message_list_before_now)
 
         prompt = await global_prompt_manager.format_prompt(
-            "reasoning_prompt_main",
-            relation_prompt=relation_prompt,
-            sender_name=sender_name,
-            memory_prompt=memory_prompt,
-            prompt_info=prompt_info,
-            schedule_prompt=schedule_prompt,
+                template_name,
+                relation_prompt=relation_prompt,
+                sender_name=effective_sender_name,
+                memory_prompt=memory_prompt,
+                prompt_info=prompt_info,
+                schedule_prompt=schedule_prompt,
             nickname_info=nickname_injection_str,  # <--- 注入绰号信息
-            chat_target=await global_prompt_manager.get_prompt_async("chat_target_group1")
-            if chat_in_group
-            else await global_prompt_manager.get_prompt_async("chat_target_private1"),
-            chat_target_2=await global_prompt_manager.get_prompt_async("chat_target_group2")
-            if chat_in_group
-            else await global_prompt_manager.get_prompt_async("chat_target_private2"),
-            chat_talking_prompt=chat_talking_prompt,
-            message_txt=message_txt,
-            bot_name=global_config.BOT_NICKNAME,
-            bot_other_names="/".join(
-                global_config.BOT_ALIAS_NAMES,
-            ),
-            prompt_personality=prompt_personality,
-            mood_prompt=mood_prompt,
-            reply_style1=reply_style1_chosen,
-            reply_style2=reply_style2_chosen,
-            keywords_reaction_prompt=keywords_reaction_prompt,
-            prompt_ger=prompt_ger,
-            moderation_prompt=await global_prompt_manager.get_prompt_async("moderation_prompt"),
-        )
+                chat_talking_prompt=chat_talking_prompt,
+                message_txt=message_txt,
+                bot_name=global_config.BOT_NICKNAME,
+                bot_other_names="/".join(global_config.BOT_ALIAS_NAMES),
+                prompt_personality=prompt_personality,
+                mood_prompt=mood_prompt,
+                reply_style1=reply_style1_chosen,
+                reply_style2=reply_style2_chosen,
+                keywords_reaction_prompt=keywords_reaction_prompt,
+                prompt_ger=prompt_ger,
+                moderation_prompt=await global_prompt_manager.get_prompt_async("moderation_prompt"),
+            )
+        # --- End choosing template ---
 
         return prompt
 
@@ -695,6 +757,112 @@ class PromptBuilder:
             # 返回所有找到的内容，用换行分隔
             return "\n".join(str(result["content"]) for result in results)
 
+    async def build_planner_prompt(
+        self,
+        is_group_chat: bool,  # Now passed as argument
+        chat_target_info: Optional[dict],  # Now passed as argument
+        cycle_history: Deque["CycleInfo"],  # Now passed as argument (Type hint needs import or string)
+        observed_messages_str: str,
+        current_mind: Optional[str],
+        structured_info: Dict[str, Any],
+        current_available_actions: Dict[str, str],
+        # replan_prompt: str, # Replan logic still simplified
+    ) -> str:
+        """构建 Planner LLM 的提示词 (获取模板并填充数据)"""
+        try:
+            # --- Determine chat context ---
+            chat_context_description = "你现在正在一个群聊中"
+            chat_target_name = None  # Only relevant for private
+            if not is_group_chat and chat_target_info:
+                chat_target_name = (
+                    chat_target_info.get("person_name") or chat_target_info.get("user_nickname") or "对方"
+                )
+                chat_context_description = f"你正在和 {chat_target_name} 私聊"
+            # --- End determining chat context ---
+
+            # ... (Copy logic from HeartFChatting._build_planner_prompt here) ...
+            # Structured info block
+            structured_info_block = ""
+            if structured_info:
+                structured_info_block = f"以下是一些额外的信息：\n{structured_info}\n"
+
+            # Chat content block
+            chat_content_block = ""
+            if observed_messages_str:
+                # Use triple quotes for multi-line string literal
+                chat_content_block = f"""观察到的最新聊天内容如下：
+---
+{observed_messages_str}
+---"""
+            else:
+                chat_content_block = "当前没有观察到新的聊天内容。\\n"
+
+            # Current mind block
+            current_mind_block = ""
+            if current_mind:
+                current_mind_block = f"你的内心想法：\n{current_mind}"
+            else:
+                current_mind_block = "你的内心想法：\n[没有特别的想法]"
+
+            # Cycle info block (using passed cycle_history)
+            cycle_info_block = ""
+            recent_active_cycles = []
+            for cycle in reversed(cycle_history):
+                if cycle.action_taken:
+                    recent_active_cycles.append(cycle)
+                    if len(recent_active_cycles) == 3:
+                        break
+            consecutive_text_replies = 0
+            responses_for_prompt = []
+            for cycle in recent_active_cycles:
+                if cycle.action_type == "text_reply":
+                    consecutive_text_replies += 1
+                    response_text = cycle.response_info.get("response_text", [])
+                    formatted_response = "[空回复]" if not response_text else " ".join(response_text)
+                    responses_for_prompt.append(formatted_response)
+                else:
+                    break
+            if consecutive_text_replies >= 3:
+                cycle_info_block = f'你已经连续回复了三条消息（最近: "{responses_for_prompt[0]}"，第二近: "{responses_for_prompt[1]}"，第三近: "{responses_for_prompt[2]}"）。你回复的有点多了，请注意'
+            elif consecutive_text_replies == 2:
+                cycle_info_block = f'你已经连续回复了两条消息（最近: "{responses_for_prompt[0]}"，第二近: "{responses_for_prompt[1]}"），请注意'
+            elif consecutive_text_replies == 1:
+                cycle_info_block = f'你刚刚已经回复一条消息（内容: "{responses_for_prompt[0]}"）'
+            if cycle_info_block:
+                cycle_info_block = f"\n【近期回复历史】\n{cycle_info_block}\n"
+            else:
+                cycle_info_block = "\n【近期回复历史】\n(最近没有连续文本回复)\n"
+
+            individuality = Individuality.get_instance()
+            prompt_personality = individuality.get_prompt(x_person=2, level=2)
+
+            action_options_text = "当前你可以选择的行动有：\n"
+            action_keys = list(current_available_actions.keys())
+            for name in action_keys:
+                desc = current_available_actions[name]
+                action_options_text += f"- '{name}': {desc}\n"
+            example_action_key = action_keys[0] if action_keys else "no_reply"
+
+            planner_prompt_template = await global_prompt_manager.get_prompt_async("planner_prompt")
+
+            prompt = planner_prompt_template.format(
+                bot_name=global_config.BOT_NICKNAME,
+                prompt_personality=prompt_personality,
+                chat_context_description=chat_context_description,
+                structured_info_block=structured_info_block,
+                chat_content_block=chat_content_block,
+                current_mind_block=current_mind_block,
+                cycle_info_block=cycle_info_block,
+                action_options_text=action_options_text,
+                example_action=example_action_key,
+            )
+            return prompt
+
+        except Exception as e:
+            logger.error(f"[PromptBuilder] 构建 Planner 提示词时出错: {e}")
+            logger.error(traceback.format_exc())
+            return "[构建 Planner Prompt 时出错]"
+
 
 init_prompt()
 prompt_builder = PromptBuilder()

src/plugins/heartFC_chat/normal_chat.py

@@ -19,6 +19,7 @@ from src.plugins.chat.chat_stream import ChatStream, chat_manager
 from src.plugins.person_info.relationship_manager import relationship_manager
 from src.plugins.respon_info_catcher.info_catcher import info_catcher_manager
 from src.plugins.utils.timer_calculator import Timer
+from src.heart_flow.utils_chat import get_chat_type_and_target_info
 from src.plugins.group_nickname.nickname_utils import trigger_nickname_analysis_if_needed
 
 
@@ -27,31 +28,48 @@ logger = get_logger("chat")
 
 class NormalChat:
     def __init__(self, chat_stream: ChatStream, interest_dict: dict):
-        """
-        初始化 NormalChat 实例，针对特定的 ChatStream。
-
-        Args:
-            chat_stream (ChatStream): 此 NormalChat 实例关联的聊天流对象。
-        """
+        """初始化 NormalChat 实例。只进行同步操作。"""
 
+        # Basic info from chat_stream (sync)
         self.chat_stream = chat_stream
         self.stream_id = chat_stream.stream_id
+        # Get initial stream name, might be updated in initialize
         self.stream_name = chat_manager.get_stream_name(self.stream_id) or self.stream_id
 
+        # Interest dict
         self.interest_dict = interest_dict
 
+        # --- Initialize attributes (defaults) ---
+        self.is_group_chat: bool = False
+        self.chat_target_info: Optional[dict] = None
+        # --- End Initialization ---
+
+        # Other sync initializations
         self.gpt = NormalChatGenerator()
-        self.mood_manager = MoodManager.get_instance()  # MoodManager 保持单例
-        # 存储此实例的兴趣监控任务
+        self.mood_manager = MoodManager.get_instance()
         self.start_time = time.time()
-
         self.last_speak_time = 0
-
         self._chat_task: Optional[asyncio.Task] = None
-        logger.info(f"[{self.stream_name}] NormalChat 实例初始化完成。")
+        self._initialized = False  # Track initialization status
+
+        # logger.info(f"[{self.stream_name}] NormalChat 实例 __init__ 完成 (同步部分)。")
+        # Avoid logging here as stream_name might not be final
+
+    async def initialize(self):
+        """异步初始化，获取聊天类型和目标信息。"""
+        if self._initialized:
+            return
+
+        # --- Use utility function to determine chat type and fetch info ---
+        self.is_group_chat, self.chat_target_info = await get_chat_type_and_target_info(self.stream_id)
+        # Update stream_name again after potential async call in util func
+        self.stream_name = chat_manager.get_stream_name(self.stream_id) or self.stream_id
+        # --- End using utility function ---
+        self._initialized = True
+        logger.info(f"[{self.stream_name}] NormalChat 实例 initialize 完成 (异步部分)。")
 
     # 改为实例方法
-    async def _create_thinking_message(self, message: MessageRecv) -> str:
+    async def _create_thinking_message(self, message: MessageRecv, timestamp: Optional[float] = None) -> str:
         """创建思考消息"""
         messageinfo = message.message_info
 
@@ -65,10 +83,11 @@ class NormalChat:
         thinking_id = "mt" + str(thinking_time_point)
         thinking_message = MessageThinking(
             message_id=thinking_id,
-            chat_stream=self.chat_stream,  # 使用 self.chat_stream
+            chat_stream=self.chat_stream,
             bot_user_info=bot_user_info,
             reply=message,
             thinking_start_time=thinking_time_point,
+            timestamp=timestamp if timestamp is not None else None,
         )
 
         await message_manager.add_message(thinking_message)
@@ -189,7 +208,10 @@ class NormalChat:
                 try:
                     # 处理消息
                     await self.normal_response(
-                        message=message, is_mentioned=is_mentioned, interested_rate=interest_value
+                        message=message,
+                        is_mentioned=is_mentioned,
+                        interested_rate=interest_value,
+                        rewind_response=False,
                     )
                 except Exception as e:
                     logger.error(f"[{self.stream_name}] 处理兴趣消息{msg_id}时出错: {e}\n{traceback.format_exc()}")
@@ -197,7 +219,9 @@ class NormalChat:
                     self.interest_dict.pop(msg_id, None)
 
     # 改为实例方法, 移除 chat 参数
-    async def normal_response(self, message: MessageRecv, is_mentioned: bool, interested_rate: float) -> None:
+    async def normal_response(
+        self, message: MessageRecv, is_mentioned: bool, interested_rate: float, rewind_response: bool = False
+    ) -> None:
         # 检查收到的消息是否属于当前实例处理的 chat stream
         if message.chat_stream.stream_id != self.stream_id:
             logger.error(
@@ -244,7 +268,10 @@ class NormalChat:
             await willing_manager.before_generate_reply_handle(message.message_info.message_id)
 
             with Timer("创建思考消息", timing_results):
-                thinking_id = await self._create_thinking_message(message)
+                if rewind_response:
+                    thinking_id = await self._create_thinking_message(message, message.message_info.time)
+                else:
+                    thinking_id = await self._create_thinking_message(message)
 
             logger.debug(f"[{self.stream_name}] 创建捕捉器，thinking_id:{thinking_id}")
 
@@ -374,11 +401,20 @@ class NormalChat:
 
             try:
                 logger.info(f"[{self.stream_name}] 处理初始高兴趣消息 {msg_id} (兴趣值: {interest_value:.2f})")
-                await self.normal_response(message=message, is_mentioned=is_mentioned, interested_rate=interest_value)
+                await self.normal_response(
+                    message=message, is_mentioned=is_mentioned, interested_rate=interest_value, rewind_response=True
+                )
                 processed_count += 1
             except Exception as e:
                 logger.error(f"[{self.stream_name}] 处理初始兴趣消息 {msg_id} 时出错: {e}\\n{traceback.format_exc()}")
 
+        # --- 新增：处理完后清空整个字典 ---
+        logger.info(
+            f"[{self.stream_name}] 处理了 {processed_count} 条初始高兴趣消息。现在清空所有剩余的初始兴趣消息..."
+        )
+        self.interest_dict.clear()
+        # --- 新增结束 ---
+
         logger.info(
             f"[{self.stream_name}] 初始高兴趣消息处理完毕，共处理 {processed_count} 条。剩余 {len(self.interest_dict)} 条待轮询。"
         )
@@ -418,22 +454,18 @@ class NormalChat:
     # 改为实例方法, 移除 chat 参数
 
     async def start_chat(self):
-        """为此 NormalChat 实例关联的 ChatStream 启动聊天任务（如果尚未运行），
-        并在后台处理一次初始的高兴趣消息。"""  # 文言文注释示例：启聊之始，若有遗珠，当于暗处拂拭，勿碍正途。
-        if self._chat_task is None or self._chat_task.done():
-            # --- 修改：使用 create_task 启动初始消息处理 ---
-            logger.info(f"[{self.stream_name}] 开始后台处理初始兴趣消息...")
-            # 创建一个任务来处理初始消息，不阻塞当前流程
-            _initial_process_task = asyncio.create_task(self._process_initial_interest_messages())
-            # 可以考虑给这个任务也添加完成回调来记录日志或处理错误
-            # initial_process_task.add_done_callback(...)
-            # --- 修改结束 ---
+        """先进行异步初始化，然后启动聊天任务。"""
+        if not self._initialized:
+            await self.initialize()  # Ensure initialized before starting tasks
 
-            # 启动后台轮询任务 (这部分不变)
-            logger.info(f"[{self.stream_name}] 启动后台兴趣消息轮询任务...")
-            polling_task = asyncio.create_task(self._reply_interested_message())  # 注意变量名区分
+        if self._chat_task is None or self._chat_task.done():
+            logger.info(f"[{self.stream_name}] 开始后台处理初始兴趣消息和轮询任务...")
+            # Process initial messages first
+            await self._process_initial_interest_messages()
+            # Then start polling task
+            polling_task = asyncio.create_task(self._reply_interested_message())
             polling_task.add_done_callback(lambda t: self._handle_task_completion(t))
-            self._chat_task = polling_task  # self._chat_task 仍然指向主要的轮询任务
+            self._chat_task = polling_task
         else:
             logger.info(f"[{self.stream_name}] 聊天轮询任务已在运行中。")
 

src/plugins/person_info/person_info.py

@@ -51,6 +51,8 @@ person_info_default = {
     "konw_time": 0,
     "msg_interval": 2000,
     "msg_interval_list": [],
+    "user_cardname": None,  # 添加群名片
+    "user_avatar": None,  # 添加头像信息（例如URL或标识符）
     "group_nicknames": [],
 }  # 个人信息的各项与默认值在此定义，以下处理会自动创建/补全每一项
 
@@ -187,7 +189,9 @@ class PersonInfoManager:
         logger.warning(f"无法从文本中提取有效的JSON字典: {text}")
         return {"nickname": "", "reason": ""}
 
-    async def qv_person_name(self, person_id: str, user_nickname: str, user_cardname: str, user_avatar: str):
+    async def qv_person_name(
+        self, person_id: str, user_nickname: str, user_cardname: str, user_avatar: str, request: str = ""
+    ):
         """给某个用户取名"""
         if not person_id:
             logger.debug("取名失败：person_id不能为空")
@@ -212,6 +216,8 @@ class PersonInfoManager:
             if old_name:
                 qv_name_prompt += f"你之前叫他{old_name}，是因为{old_reason}，"
 
+            qv_name_prompt += f"\n其他取名的要求是：{request}"
+
             qv_name_prompt += "\n请根据以上用户信息，想想你叫他什么比较好，请最好使用用户的qq昵称，可以稍作修改"
             if existing_names:
                 qv_name_prompt += f"\n请注意，以下名称已被使用，不要使用以下昵称：{existing_names}。\n"
@@ -512,5 +518,41 @@ class PersonInfoManager:
 
         return person_id
 
+    async def get_person_info_by_name(self, person_name: str) -> dict | None:
+        """根据 person_name 查找用户并返回基本信息 (如果找到)"""
+        if not person_name:
+            logger.debug("get_person_info_by_name 获取失败：person_name 不能为空")
+            return None
+
+        # 优先从内存缓存查找 person_id
+        found_person_id = None
+        for pid, name in self.person_name_list.items():
+            if name == person_name:
+                found_person_id = pid
+                break  # 找到第一个匹配就停止
+
+        if not found_person_id:
+            # 如果内存没有，尝试数据库查询（可能内存未及时更新或启动时未加载）
+            document = db.person_info.find_one({"person_name": person_name})
+            if document:
+                found_person_id = document.get("person_id")
+            else:
+                logger.debug(f"数据库中也未找到名为 '{person_name}' 的用户")
+                return None  # 数据库也找不到
+
+        # 根据找到的 person_id 获取所需信息
+        if found_person_id:
+            required_fields = ["person_id", "platform", "user_id", "nickname", "user_cardname", "user_avatar"]
+            person_data = await self.get_values(found_person_id, required_fields)
+            if person_data:  # 确保 get_values 成功返回
+                return person_data
+            else:
+                logger.warning(f"找到了 person_id '{found_person_id}' 但获取详细信息失败")
+                return None
+        else:
+            # 这理论上不应该发生，因为上面已经处理了找不到的情况
+            logger.error(f"逻辑错误：未能为 '{person_name}' 确定 person_id")
+            return None
+
 
 person_info_manager = PersonInfoManager()

template/bot_config_template.toml

@@ -1,5 +1,5 @@
 [inner]
-version = "1.6.0"
+version = "1.6.1"
 
 #----以下是给开发人员阅读的，如果你只是部署了麦麦，不需要阅读----
 #如果你想要修改配置文件，请在修改后将version的值进行变更
@@ -193,6 +193,7 @@ enable = true
 
 [experimental] #实验性功能
 enable_friend_chat = false # 是否启用好友聊天
+talk_allowed_private = [] # 可以回复消息的QQ号
 pfc_chatting = false # 是否启用PFC聊天，该功能仅作用于私聊，与回复模式独立
 
 #下面的模型若使用硅基流动则不需要更改，使用ds官方则改成.env自定义的宏，使用自定义模型则选择定位相似的模型自己填写