fix：进一步模块化，修复观察错位问题

2025-04-25 18:12:11 +08:00
parent 1e75082141
commit d7ca0255fe
16 changed files with 1217 additions and 668 deletions
--- a/src/heart_flow/mai_state_manager.py
+++ b/src/heart_flow/mai_state_manager.py
@@ -13,8 +13,8 @@ mai_state_config = LogConfig(
 logger = get_module_logger("mai_state_manager", config=mai_state_config)


-# enable_unlimited_hfc_chat = True
-enable_unlimited_hfc_chat = False
+enable_unlimited_hfc_chat = True
+# enable_unlimited_hfc_chat = False


 class MaiState(enum.Enum):
@@ -22,14 +22,14 @@ class MaiState(enum.Enum):
    聊天状态:
    OFFLINE: 不在线：回复概率极低，不会进行任何聊天
    PEEKING: 看一眼手机：回复概率较低，会进行一些普通聊天
-    NORMAL_CHAT: 正常聊天：回复概率较高，会进行一些普通聊天和少量的专注聊天
+    NORMAL_CHAT: 正常看手机：回复概率较高，会进行一些普通聊天和少量的专注聊天
    FOCUSED_CHAT: 专注聊天：回复概率极高，会进行专注聊天和少量的普通聊天
    """

    OFFLINE = "不在线"
-    PEEKING = "看一眼"
-    NORMAL_CHAT = "正常聊天"
-    FOCUSED_CHAT = "专心聊天"
+    PEEKING = "看一眼手机"
+    NORMAL_CHAT = "正常看手机"
+    FOCUSED_CHAT = "专心看手机"

    def get_normal_chat_max_num(self):
        # 调试用
@@ -137,11 +137,11 @@ class MaiStateManager:
        if current_status == MaiState.OFFLINE:
            logger.info("当前[离线]，没看手机，思考要不要上线看看......")
        elif current_status == MaiState.PEEKING:
-            logger.info("当前[看一眼]，思考要不要继续聊下去......")
+            logger.info("当前[看一眼手机]，思考要不要继续聊下去......")
        elif current_status == MaiState.NORMAL_CHAT:
-            logger.info("当前在[正常聊天]思考要不要继续聊下去......")
+            logger.info("当前在[正常看手机]思考要不要继续聊下去......")
        elif current_status == MaiState.FOCUSED_CHAT:
-            logger.info("当前在[专心聊天]思考要不要继续聊下去......")
+            logger.info("当前在[专心看手机]思考要不要继续聊下去......")

        # 1. 麦麦每分钟都有概率离线
        if time_since_last_min_check >= 60:
--- a/src/heart_flow/observation.py
+++ b/src/heart_flow/observation.py
@@ -22,6 +22,9 @@ class Observation:
        self.observe_type = observe_type
        self.observe_id = observe_id
        self.last_observe_time = datetime.now().timestamp()  # 初始化为当前时间
+    
+    async def observe(self):
+        pass


 # 聊天观察
--- a/src/heart_flow/sub_heartflow.py
+++ b/src/heart_flow/sub_heartflow.py
@@ -43,6 +43,7 @@ class InterestChatting:
        max_probability=max_reply_probability,
        state_change_callback: Optional[Callable[[ChatState], None]] = None,
    ):
+        # 基础属性初始化
        self.interest_level: float = 0.0
        self.last_update_time: float = time.time()
        self.decay_rate_per_second: float = decay_rate
@@ -56,16 +57,26 @@ class InterestChatting:
        self.max_reply_probability: float = max_probability
        self.current_reply_probability: float = 0.0
        self.is_above_threshold: bool = False
+        
+        # 任务相关属性初始化
        self.update_task: Optional[asyncio.Task] = None
        self._stop_event = asyncio.Event()
+        self._task_lock = asyncio.Lock()
+        self._is_running = False

        self.interest_dict: Dict[str, tuple[MessageRecv, float, bool]] = {}
        self.update_interval = 1.0
-        self.start_updates(self.update_interval)  # 初始化时启动后台更新任务

        self.above_threshold = False
        self.start_hfc_probability = 0.0

+    @classmethod
+    async def create(cls, *args, **kwargs):
+        """异步工厂方法，用于创建并初始化 InterestChatting 实例"""
+        instance = cls(*args, **kwargs)
+        await instance.start_updates(instance.update_interval)
+        return instance
+
    def add_interest_dict(self, message: MessageRecv, interest_value: float, is_mentioned: bool):
        self.interest_dict[message.message_info.message_id] = (message, interest_value, is_mentioned)
        self.last_interaction_time = time.time()
@@ -141,59 +152,74 @@ class InterestChatting:
    # --- 新增后台更新任务相关方法 ---
    async def _run_update_loop(self, update_interval: float = 1.0):
        """后台循环，定期更新兴趣和回复概率。"""
-        while not self._stop_event.is_set():
-            try:
-                if self.interest_level != 0:
-                    await self._calculate_decay()
+        try:
+            while not self._stop_event.is_set():
+                try:
+                    if self.interest_level != 0:
+                        await self._calculate_decay()

-                await self._update_reply_probability()
+                    await self._update_reply_probability()

-                # 等待下一个周期或停止事件
-                await asyncio.wait_for(self._stop_event.wait(), timeout=update_interval)
-            except asyncio.TimeoutError:
-                # 正常超时，继续循环
-                continue
-            except asyncio.CancelledError:
-                logger.info("InterestChatting 更新循环被取消。")
-                break
-            except Exception as e:
-                logger.error(f"InterestChatting 更新循环出错: {e}")
-                logger.error(traceback.format_exc())
-                # 防止错误导致CPU飙升，稍作等待
-                await asyncio.sleep(5)
-        logger.info("InterestChatting 更新循环已停止。")
+                    # 等待下一个周期或停止事件
+                    await asyncio.wait_for(self._stop_event.wait(), timeout=update_interval)
+                except asyncio.TimeoutError:
+                    # 正常超时，继续循环
+                    continue
+                except Exception as e:
+                    logger.error(f"InterestChatting 更新循环出错: {e}")
+                    logger.error(traceback.format_exc())
+                    # 防止错误导致CPU飙升，稍作等待
+                    await asyncio.sleep(5)
+        except asyncio.CancelledError:
+            logger.info("InterestChatting 更新循环被取消。")
+        finally:
+            self._is_running = False
+            logger.info("InterestChatting 更新循环已停止。")

-    def start_updates(self, update_interval: float = 1.0):
-        """启动后台更新任务"""
-        if self.update_task is None or self.update_task.done():
-            self._stop_event.clear()
-            self.update_task = asyncio.create_task(self._run_update_loop(update_interval))
-            logger.debug("后台兴趣更新任务已创建并启动。")
-        else:
-            logger.debug("后台兴趣更新任务已在运行中。")
+    async def start_updates(self, update_interval: float = 1.0):
+        """启动后台更新任务，使用锁确保并发安全"""
+        async with self._task_lock:
+            if self._is_running:
+                logger.debug("后台兴趣更新任务已在运行中。")
+                return
+
+            # 清理已完成或已取消的任务
+            if self.update_task and (self.update_task.done() or self.update_task.cancelled()):
+                self.update_task = None
+
+            if not self.update_task:
+                self._stop_event.clear()
+                self._is_running = True
+                self.update_task = asyncio.create_task(self._run_update_loop(update_interval))
+                logger.debug("后台兴趣更新任务已创建并启动。")

    async def stop_updates(self):
-        """停止后台更新任务"""
-        if self.update_task and not self.update_task.done():
+        """停止后台更新任务，使用锁确保并发安全"""
+        async with self._task_lock:
+            if not self._is_running:
+                logger.debug("后台兴趣更新任务未运行。")
+                return
+
            logger.info("正在停止 InterestChatting 后台更新任务...")
-            self._stop_event.set()  # 发送停止信号
-            try:
-                # 等待任务结束，设置超时
-                await asyncio.wait_for(self.update_task, timeout=5.0)
-                logger.info("InterestChatting 后台更新任务已成功停止。")
-            except asyncio.TimeoutError:
-                logger.warning("停止 InterestChatting 后台任务超时，尝试取消...")
-                self.update_task.cancel()
+            self._stop_event.set()
+
+            if self.update_task and not self.update_task.done():
                try:
-                    await self.update_task  # 等待取消完成
-                except asyncio.CancelledError:
-                    logger.info("InterestChatting 后台更新任务已被取消。")
-            except Exception as e:
-                logger.error(f"停止 InterestChatting 后台任务时发生异常: {e}")
-            finally:
-                self.update_task = None
-        else:
-            logger.debug("InterestChatting 后台更新任务未运行或已完成。")
+                    # 等待任务结束，设置超时
+                    await asyncio.wait_for(self.update_task, timeout=5.0)
+                    logger.info("InterestChatting 后台更新任务已成功停止。")
+                except asyncio.TimeoutError:
+                    logger.warning("停止 InterestChatting 后台任务超时，尝试取消...")
+                    self.update_task.cancel()
+                    try:
+                        await self.update_task  # 等待取消完成
+                    except asyncio.CancelledError:
+                        logger.info("InterestChatting 后台更新任务已被取消。")
+                except Exception as e:
+                    logger.error(f"停止 InterestChatting 后台任务时发生异常: {e}")
+                finally:
+                    self.update_task = None
+                    self._is_running = False

    # --- 结束 新增方法 ---

@@ -214,7 +240,7 @@ class SubHeartflow:

        # 聊天状态管理
        self.chat_state: ChatStateInfo = ChatStateInfo()  # 该sub_heartflow的聊天状态信息
-        self.interest_chatting = InterestChatting(state_change_callback=self.set_chat_state)
+        self.interest_chatting = None  # 将在 initialize 中创建

        # 活动状态管理
        self.last_active_time = time.time()  # 最后活跃时间
@@ -234,6 +260,11 @@ class SubHeartflow:

        self.log_prefix = chat_manager.get_stream_name(self.subheartflow_id) or self.subheartflow_id

+    async def initialize(self):
+        """异步初始化方法"""
+        self.interest_chatting = await InterestChatting.create(state_change_callback=self.set_chat_state)
+        logger.debug(f"{self.log_prefix} InterestChatting 实例已创建并初始化。")
+
    async def add_time_current_state(self, add_time: float):
        self.current_state_time += add_time

@@ -412,7 +443,7 @@ class SubHeartflow:
        - 负责子心流的主要后台循环
        - 每30秒检查一次停止标志
        """
-        logger.info(f"{self.log_prefix} 子心流开始工作...")
+        logger.trace(f"{self.log_prefix} 子心流开始工作...")

        while not self.should_stop:
            await asyncio.sleep(30)  # 30秒检查一次停止标志
--- a/src/heart_flow/sub_mind.py
+++ b/src/heart_flow/sub_mind.py
@@ -10,7 +10,7 @@ from ..plugins.utils.prompt_builder import Prompt, global_prompt_manager
 from src.do_tool.tool_use import ToolUser
 from src.plugins.utils.json_utils import safe_json_dumps, normalize_llm_response, process_llm_tool_calls
 from src.heart_flow.chat_state_info import ChatStateInfo
-
+from src.plugins.chat.chat_stream import chat_manager

 subheartflow_config = LogConfig(
    console_format=SUB_HEARTFLOW_STYLE_CONFIG["console_format"],
@@ -30,6 +30,8 @@ def init_prompt():
    prompt += "现在请你生成你的内心想法，要求思考群里正在进行的话题，之前大家聊过的话题，群里成员的关系。"
    prompt += "请你思考，要不要对群里的话题进行回复，以及如何对群聊内容进行回复\n"
    prompt += "回复的要求是：不要总是重复自己提到过的话题，如果你要回复，最好只回复一个人的一个话题\n"
+    prompt += "如果最后一条消息是你自己发的，观察到的内容只有你自己的发言，并且之后没有人回复你，不要回复。"
+    prompt += "如果聊天记录中最新的消息是你自己发送的，并且你还想继续回复，你应该紧紧衔接你发送的消息，进行话题的深入，补充，或追问等等。"
    prompt += "请注意不要输出多余内容(包括前后缀，冒号和引号，括号， 表情，等)，不要回复自己的发言\n"
    prompt += "现在请你先输出想法，{hf_do_next}，不要分点输出,文字不要浮夸"
    prompt += "在输出完想法后，请你思考应该使用什么工具。工具可以帮你取得一些你不知道的信息，或者进行一些操作。"
@@ -138,7 +140,7 @@ class SubMind:
            hf_do_next=hf_do_next,
        )

-        logger.debug(f"[{self.subheartflow_id}] 心流思考提示词构建完成")
+        # logger.debug(f"[{self.subheartflow_id}] 心流思考提示词构建完成")

        # ---------- 5. 执行LLM请求并处理响应 ----------
        content = ""  # 初始化内容变量
@@ -190,7 +192,8 @@ class SubMind:
            content = "思考过程中出现错误"

        # 记录最终思考结果
-        logger.debug(f"[{self.subheartflow_id}] 心流思考结果:\n{content}\n")
+        name = chat_manager.get_stream_name(self.subheartflow_id)
+        logger.debug(f"[{name}] \nPrompt:\n{prompt}\n\n心流思考结果:\n{content}\n")

        # 处理空响应情况
        if not content:
--- a/src/heart_flow/subheartflow_manager.py
+++ b/src/heart_flow/subheartflow_manager.py
@@ -75,18 +75,22 @@ class SubHeartflowManager:
                return subflow

            # 创建新的子心流实例
-            logger.info(f"子心流 {subheartflow_id} 不存在，正在创建...")
+            # logger.info(f"子心流 {subheartflow_id} 不存在，正在创建...")
            try:
                # 初始化子心流
                new_subflow = SubHeartflow(subheartflow_id, mai_states)

+                # 异步初始化
+                await new_subflow.initialize()
+
                # 添加聊天观察者
                observation = ChattingObservation(chat_id=subheartflow_id)
                new_subflow.add_observation(observation)

                # 注册子心流
                self.subheartflows[subheartflow_id] = new_subflow
-                logger.info(f"子心流 {subheartflow_id} 创建成功")
+                heartflow_name = chat_manager.get_stream_name(subheartflow_id) or subheartflow_id
+                logger.info(f"[{heartflow_name}] 开始看消息")

                # 启动后台任务
                asyncio.create_task(new_subflow.subheartflow_start_working())
@@ -264,104 +268,70 @@ class SubHeartflowManager:

    async def evaluate_interest_and_promote(self, current_mai_state: MaiStateInfo):
        """评估子心流兴趣度，满足条件且未达上限则提升到FOCUSED状态（基于start_hfc_probability）"""
-        log_prefix_manager = "[子心流管理器-兴趣评估]"
-        logger.debug(f"{log_prefix_manager} 开始周期... 当前状态: {current_mai_state.get_current_state().value}")
-
-        # 获取 FOCUSED 状态的数量上限
-        current_state_enum = current_mai_state.get_current_state()
-        focused_limit = current_state_enum.get_focused_chat_max_num()
+        log_prefix = "[兴趣评估]"
+        current_state = current_mai_state.get_current_state()
+        focused_limit = current_state.get_focused_chat_max_num()
+        
+        
+        if int(time.time()) % 20 == 0:  # 每20秒输出一次
+            logger.debug(f"{log_prefix} 当前状态 ({current_state.value}) 可以在{focused_limit}个群激情聊天")
+        
        if focused_limit <= 0:
-            logger.debug(
-                f"{log_prefix_manager} 当前状态 ({current_state_enum.value}) 不允许 FOCUSED 子心流, 跳过提升检查。"
-            )
+            # logger.debug(f"{log_prefix} 当前状态 ({current_state.value}) 不允许 FOCUSED 子心流")
            return

-        # 获取当前 FOCUSED 状态的数量 (初始值)
        current_focused_count = self.count_subflows_by_state(ChatState.FOCUSED)
-        logger.debug(f"{log_prefix_manager} 专注上限: {focused_limit}, 当前专注数: {current_focused_count}")
+        if current_focused_count >= focused_limit:
+            logger.debug(f"{log_prefix} 已达专注上限 ({current_focused_count}/{focused_limit})")
+            return

-        # 使用快照安全遍历
-        subflows_snapshot = list(self.subheartflows.values())
-        promoted_count = 0  # 记录本次提升的数量
-        try:
-            for sub_hf in subflows_snapshot:
-                flow_id = sub_hf.subheartflow_id
-                stream_name = chat_manager.get_stream_name(flow_id) or flow_id
-                log_prefix_flow = f"[{stream_name}]"
+        states_num = (
+            self.count_subflows_by_state(ChatState.ABSENT),
+            self.count_subflows_by_state(ChatState.CHAT),
+            current_focused_count
+        )

-                # 只处理 CHAT 状态的子心流
-                # The code snippet is checking if the `chat_status` attribute of `sub_hf.chat_state` is not equal to
-                # `ChatState.CHAT`. If the condition is met, the code will continue to the next iteration of the loop
-                # or block of code where this snippet is located.
-                # if sub_hf.chat_state.chat_status != ChatState.CHAT:
-                #     continue
-
-                # 检查是否满足提升概率
-                should_hfc = random.random() < sub_hf.interest_chatting.start_hfc_probability
-                if not should_hfc:
+        for sub_hf in list(self.subheartflows.values()):
+            flow_id = sub_hf.subheartflow_id
+            stream_name = chat_manager.get_stream_name(flow_id) or flow_id
+            
+            # 跳过非CHAT状态或已经是FOCUSED状态的子心流
+            if sub_hf.chat_state.chat_status == ChatState.FOCUSED:
+                continue
+            
+            from .mai_state_manager import enable_unlimited_hfc_chat
+            if not enable_unlimited_hfc_chat:
+                if sub_hf.chat_state.chat_status != ChatState.CHAT:
                    continue
+                
+            # 检查是否满足提升概率
+            if random.random() >= sub_hf.interest_chatting.start_hfc_probability:
+                continue

-                # --- 关键检查：检查 FOCUSED 数量是否已达上限 ---
-                # 注意：在循环内部再次获取当前数量，因为之前的提升可能已经改变了计数
-                # 使用已经记录并在循环中更新的 current_focused_count
-                if current_focused_count >= focused_limit:
-                    logger.debug(
-                        f"{log_prefix_manager} {log_prefix_flow} 达到专注上限 ({current_focused_count}/{focused_limit}), 无法提升。概率={sub_hf.interest_chatting.start_hfc_probability:.2f}"
-                    )
-                    continue  # 跳过这个子心流，继续检查下一个
+            # 再次检查是否达到上限
+            if current_focused_count >= focused_limit:
+                logger.debug(f"{log_prefix} [{stream_name}] 已达专注上限")
+                break

-                # --- 执行提升 ---
-                # 获取当前实例以检查最新状态 (防御性编程)
-                current_subflow = self.subheartflows.get(flow_id)
-                if not current_subflow:
-                    logger.warning(f"{log_prefix_manager} {log_prefix_flow} 尝试提升时状态已改变或实例消失，跳过。")
-                    continue
+            # 获取最新状态并执行提升
+            current_subflow = self.subheartflows.get(flow_id)
+            if not current_subflow:
+                continue

-                logger.info(
-                    f"{log_prefix_manager} {log_prefix_flow} 兴趣评估触发升级 (prob={sub_hf.interest_chatting.start_hfc_probability:.2f}, 上限:{focused_limit}, 当前:{current_focused_count}) -> FOCUSED"
-                )
+            logger.info(
+                f"{log_prefix} [{stream_name}] 触发 激情水群 (概率={current_subflow.interest_chatting.start_hfc_probability:.2f})"
+            )

-                states_num = (
-                    self.count_subflows_by_state(ChatState.ABSENT),
-                    self.count_subflows_by_state(ChatState.CHAT),  # 这个值在提升前计算
-                    current_focused_count,  # 这个值在提升前计算
-                )
+            # 执行状态提升
+            await current_subflow.set_chat_state(ChatState.FOCUSED, states_num)
+            
+            # 验证提升结果
+            if (final_subflow := self.subheartflows.get(flow_id)) and \
+                final_subflow.chat_state.chat_status == ChatState.FOCUSED:
+                current_focused_count += 1

-                # --- 状态设置 ---
-                original_state = current_subflow.chat_state.chat_status  # 记录原始状态
-                await current_subflow.set_chat_state(ChatState.FOCUSED, states_num)

-                # --- 状态验证 ---
-                final_subflow = self.subheartflows.get(flow_id)
-                if final_subflow:
-                    final_state = final_subflow.chat_state.chat_status
-                    if final_state == ChatState.FOCUSED:
-                        logger.debug(
-                            f"{log_prefix_manager} {log_prefix_flow} 成功从 {original_state.value} 升级到 FOCUSED 状态"
-                        )
-                        promoted_count += 1
-                        # 提升成功后，更新当前专注计数，以便后续检查能使用最新值
-                        current_focused_count += 1
-                    elif final_state == original_state:  # 状态未变
-                        logger.warning(
-                            f"{log_prefix_manager} {log_prefix_flow} 尝试从 {original_state.value} 升级 FOCUSED 失败，状态仍为: {final_state.value} (可能被内部逻辑阻止)"
-                        )
-                    else:  # 状态变成其他了?
-                        logger.warning(
-                            f"{log_prefix_manager} {log_prefix_flow} 尝试从 {original_state.value} 升级 FOCUSED 后状态变为 {final_state.value}"
-                        )
-                else:  # 子心流消失了?
-                    logger.warning(f"{log_prefix_manager} {log_prefix_flow} 升级后验证时子心流 {flow_id} 消失")
-
-        except Exception as e:
-            logger.error(f"{log_prefix_manager} 兴趣评估周期出错: {e}", exc_info=True)
-
-        if promoted_count > 0:
-            logger.info(f"{log_prefix_manager} 评估周期结束, 成功提升 {promoted_count} 个子心流到 FOCUSED。")
-        else:
-            logger.debug(f"{log_prefix_manager} 评估周期结束, 未提升任何子心流。")
-
-    async def randomly_deactivate_subflows(self, deactivation_probability: float = 0.3):
+    async def randomly_deactivate_subflows(self, deactivation_probability: float = 0.1):
        """以一定概率将 FOCUSED 或 CHAT 状态的子心流回退到 ABSENT 状态。"""
        log_prefix_manager = "[子心流管理器-随机停用]"
        logger.debug(f"{log_prefix_manager} 开始随机停用检查... (概率: {deactivation_probability:.0%})")