diff --git a/interest_monitor_gui.py b/interest_monitor_gui.py index 245a0ae99..fb9e51cf8 100644 --- a/interest_monitor_gui.py +++ b/interest_monitor_gui.py @@ -247,7 +247,7 @@ class InterestMonitorApp: self.stream_chat_states[stream_id] = subflow_entry.get("sub_chat_state", "N/A") self.stream_threshold_status[stream_id] = subflow_entry.get("is_above_threshold", False) self.stream_last_active[stream_id] = subflow_entry.get( - "last_changed_state_time" + "chat_state_changed_time" ) # 存储原始时间戳 self.stream_last_interaction[stream_id] = subflow_entry.get( "last_interaction_time" diff --git a/src/heart_flow/README.md b/src/heart_flow/README.md index 24d094cc6..a2540ebf1 100644 --- a/src/heart_flow/README.md +++ b/src/heart_flow/README.md @@ -105,7 +105,8 @@ c HeartFChatting工作方式 - 负责所有 `SubHeartflow` 实例的生命周期管理，包括： - 创建和获取 (`get_or_create_subheartflow`)。 - 停止和清理 (`sleep_subheartflow`, `cleanup_inactive_subheartflows`)。 - - 根据 `Heartflow` 的状态 (`self.mai_state_info`) 和限制条件，激活、停用或调整子心流的状态（例如 `enforce_subheartflow_limits`, `activate_random_subflows_to_chat`, `evaluate_interest_and_promote`）。 + - 根据 `Heartflow` 的状态 (`self.mai_state_info`) 和限制条件，激活、停用或调整子心流的状态（例如 `enforce_subheartflow_limits`, `randomly_deactivate_subflows`, `evaluate_interest_and_promote`）。 + - **新增**: 通过调用 `evaluate_and_transition_subflows_by_llm` 方法，使用 LLM (配置与 `Heartflow` 主 LLM 相同) 评估处于 `ABSENT` 或 `CHAT` 状态的子心流，根据观察到的活动摘要和 `Heartflow` 的当前状态，判断是否应在 `ABSENT` 和 `CHAT` 之间进行转换 (同样受限于 `CHAT` 状态的数量上限)。 - **清理机制**: 通过后台任务 (`BackgroundTaskManager`) 定期调用 `cleanup_inactive_subheartflows` 方法，此方法会识别并**删除**那些处于 `ABSENT` 状态超过一小时 (`INACTIVE_THRESHOLD_SECONDS`) 的子心流实例。 ### 1.5. 消息处理与回复流程 (Message Processing vs. Replying Flow) @@ -149,9 +150,9 @@ c HeartFChatting工作方式 * `ChatState.FOCUSED` (专注/认真水群): 专注聊天模式。激活 `HeartFlowChatInstance`。 - **选择**: 子心流可以根据外部指令（来自 `SubHeartflowManager`）或内部逻辑（未来的扩展）选择进入 `ABSENT` 状态（不回复不观察），或进入 `CHAT` / `FOCUSED` 中的一种回复模式。 - **状态转换机制** (由 `SubHeartflowManager` 驱动): - - **激活 `CHAT`**: 当 `Heartflow` 状态从 `OFFLINE` 变为允许聊天的状态时，`SubHeartflowManager` 会根据限制（通过 `self.mai_state_info` 获取），选择部分 `ABSENT` 状态的子心流，**检查当前 CHAT 状态数量是否达到上限**，如果未达上限，则调用其 `change_chat_state` 方法将其转换为 `CHAT`。 + - **激活 `CHAT`**: 当 `Heartflow` 状态从 `OFFLINE` 变为允许聊天的状态时，`SubHeartflowManager` 会根据限制（通过 `self.mai_state_info` 获取），选择部分 `ABSENT` 状态的子心流，**检查当前 CHAT 状态数量是否达到上限**，如果未达上限，则调用其 `change_chat_state` 方法将其转换为 `CHAT`。此外，`evaluate_and_transition_subflows_by_llm` 方法也会根据 LLM 的判断，在未达上限时将 `ABSENT` 状态的子心流激活为 `CHAT`。 - **激活 `FOCUSED`**: `SubHeartflowManager` 会定期评估处于 `CHAT` 状态的子心流的兴趣度 (`InterestChatting.start_hfc_probability`)，若满足条件且**检查当前 FOCUSED 状态数量未达上限**（通过 `self.mai_state_info` 获取限制），则调用 `change_chat_state` 将其提升为 `FOCUSED`。 - - **停用/回退**: `SubHeartflowManager` 可能因 `Heartflow` 状态变化、达到数量限制、长时间不活跃或随机概率等原因，调用 `change_chat_state` 将子心流状态设置为 `ABSENT` 或从 `FOCUSED` 回退到 `CHAT`。当子心流进入 `ABSENT` 状态后，如果持续一小时不活跃，才会被后台清理任务删除。 + - **停用/回退**: `SubHeartflowManager` 可能因 `Heartflow` 状态变化、达到数量限制、长时间不活跃、随机概率 (`randomly_deactivate_subflows`) 或 LLM 评估 (`evaluate_and_transition_subflows_by_llm` 判断 `CHAT` 状态子心流应休眠) 等原因，调用 `change_chat_state` 将子心流状态设置为 `ABSENT` 或从 `FOCUSED` 回退到 `CHAT`。当子心流进入 `ABSENT` 状态后，如果持续一小时不活跃，才会被后台清理任务删除。 - **注意**: `change_chat_state` 方法本身只负责执行状态转换和管理内部聊天实例（`NormalChatInstance`/`HeartFlowChatInstance`），不再进行限额检查。限额检查的责任完全由调用方（即 `SubHeartflowManager` 中的相关方法，这些方法会使用内部存储的 `mai_state_info` 来获取限制）承担。 ## 3. 聊天实例详解 (Chat Instances Explained) diff --git a/src/heart_flow/background_tasks.py b/src/heart_flow/background_tasks.py index 85b77579e..a1a226684 100644 --- a/src/heart_flow/background_tasks.py +++ b/src/heart_flow/background_tasks.py @@ -34,7 +34,6 @@ class BackgroundTaskManager: update_interval: int, cleanup_interval: int, log_interval: int, - inactive_threshold: int, # 新增兴趣评估间隔参数 interest_eval_interval: int = INTEREST_EVAL_INTERVAL_SECONDS, # 新增随机停用间隔参数 @@ -58,6 +57,7 @@ class BackgroundTaskManager: self._logging_task: Optional[asyncio.Task] = None self._interest_eval_task: Optional[asyncio.Task] = None # 新增兴趣评估任务引用 self._random_deactivation_task: Optional[asyncio.Task] = None # 新增随机停用任务引用 + self._hf_judge_state_update_task: Optional[asyncio.Task] = None # 新增状态评估任务引用 self._tasks: List[Optional[asyncio.Task]] = [] # Keep track of all tasks async def start_tasks(self): @@ -79,12 +79,20 @@ class BackgroundTaskManager: f"聊天状态更新任务已启动 间隔:{self.update_interval}s", "_state_update_task", ), + ( + self._hf_judge_state_update_task, + lambda: self._run_hf_judge_state_update_cycle(300), + "hf_judge_state_update", + "debug", + f"状态评估任务已启动 间隔:{300}s", + "_hf_judge_state_update_task", + ), ( self._cleanup_task, self._run_cleanup_cycle, "hf_cleanup", "info", - f"清理任务已启动 间隔:{self.cleanup_interval}s 阈值:{self.inactive_threshold}s", + f"清理任务已启动 间隔:{self.cleanup_interval}s", "_cleanup_task", ), ( @@ -203,21 +211,21 @@ class BackgroundTaskManager: if state_changed: current_state = self.mai_state_info.get_current_state() - await self.subheartflow_manager.enforce_subheartflow_limits(current_state) + await self.subheartflow_manager.enforce_subheartflow_limits() # 状态转换处理 + if ( - previous_status == self.mai_state_info.mai_status.OFFLINE - and current_state != self.mai_state_info.mai_status.OFFLINE - ): - logger.info("[后台任务] 主状态激活，触发子流激活") - await self.subheartflow_manager.activate_random_subflows_to_chat(current_state) - elif ( current_state == self.mai_state_info.mai_status.OFFLINE and previous_status != self.mai_state_info.mai_status.OFFLINE ): logger.info("检测到离线，停用所有子心流") await self.subheartflow_manager.deactivate_all_subflows() + + async def _perform_hf_judge_state_update_work(self): + """调用llm检测是否转换ABSENT-CHAT状态""" + logger.info("[状态评估任务] 开始基于LLM评估子心流状态...") + await self.subheartflow_manager.evaluate_and_transition_subflows_by_llm() async def _perform_cleanup_work(self): """执行子心流清理任务 @@ -252,7 +260,7 @@ class BackgroundTaskManager: async def _perform_interest_eval_work(self): """执行一轮子心流兴趣评估与提升检查。""" # 直接调用 subheartflow_manager 的方法，并传递当前状态信息 - await self.subheartflow_manager.evaluate_interest_and_promote(self.mai_state_info) + await self.subheartflow_manager.evaluate_interest_and_promote() # --- 结束新增 --- @@ -268,6 +276,11 @@ class BackgroundTaskManager: await self._run_periodic_loop( task_name="State Update", interval=interval, task_func=self._perform_state_update_work ) + + async def _run_hf_judge_state_update_cycle(self, interval: int): + await self._run_periodic_loop( + task_name="State Update", interval=interval, task_func=self._perform_hf_judge_state_update_work + ) async def _run_cleanup_cycle(self): await self._run_periodic_loop( diff --git a/src/heart_flow/heartflow.py b/src/heart_flow/heartflow.py index 7d92ae528..a0fb8e4fa 100644 --- a/src/heart_flow/heartflow.py +++ b/src/heart_flow/heartflow.py @@ -72,7 +72,6 @@ class Heartflow: update_interval=STATE_UPDATE_INTERVAL_SECONDS, cleanup_interval=CLEANUP_INTERVAL_SECONDS, log_interval=3, # Example: Using value directly, ideally get from config - inactive_threshold=INACTIVE_THRESHOLD_SECONDS, ) async def get_or_create_subheartflow(self, subheartflow_id: Any) -> Optional["SubHeartflow"]: diff --git a/src/heart_flow/interest_logger.py b/src/heart_flow/interest_logger.py index 7802f87b4..d4e746e63 100644 --- a/src/heart_flow/interest_logger.py +++ b/src/heart_flow/interest_logger.py @@ -58,7 +58,7 @@ class InterestLogger: return results for subheartflow in all_flows: - if self.subheartflow_manager.get_or_create_subheartflow(subheartflow.subheartflow_id): + if await self.subheartflow_manager.get_or_create_subheartflow(subheartflow.subheartflow_id): tasks.append( asyncio.create_task(subheartflow.get_full_state(), name=f"get_state_{subheartflow.subheartflow_id}") ) diff --git a/src/heart_flow/sub_heartflow.py b/src/heart_flow/sub_heartflow.py index 9cbd7b3a4..33218f5fd 100644 --- a/src/heart_flow/sub_heartflow.py +++ b/src/heart_flow/sub_heartflow.py @@ -481,7 +481,7 @@ class SubHeartflow: "interest_state": interest_state, "current_mind": self.sub_mind.current_mind, "chat_state": self.chat_state.chat_status.value, - "last_changed_state_time": self.last_changed_state_time, + "chat_state_changed_time": self.chat_state_changed_time, } async def shutdown(self): diff --git a/src/heart_flow/subheartflow_manager.py b/src/heart_flow/subheartflow_manager.py index cd32136ae..33fdae4e4 100644 --- a/src/heart_flow/subheartflow_manager.py +++ b/src/heart_flow/subheartflow_manager.py @@ -12,7 +12,11 @@ from src.plugins.chat.chat_stream import chat_manager # 导入心流相关类 from src.heart_flow.sub_heartflow import SubHeartflow, ChatState from src.heart_flow.mai_state_manager import MaiStateInfo -from .observation import ChattingObservation +from .observation import ChattingObservation, Observation + +# 导入LLM请求工具 +from src.plugins.models.utils_model import LLMRequest +from src.config.config import global_config # 初始化日志记录器 @@ -34,6 +38,15 @@ class SubHeartflowManager: self._lock = asyncio.Lock() # 用于保护 self.subheartflows 的访问 self.mai_state_info: MaiStateInfo = mai_state_info # 存储传入的 MaiStateInfo 实例 + # 为 LLM 状态评估创建一个 LLMRequest 实例 + # 使用与 Heartflow 相同的模型和参数 + self.llm_state_evaluator = LLMRequest( + model=global_config.llm_heartflow, # 与 Heartflow 一致 + temperature=0.6, # 与 Heartflow 一致 + max_tokens=1000, # 与 Heartflow 一致 (虽然可能不需要这么多) + request_type="subheartflow_state_eval" # 保留特定的请求类型 + ) + def get_all_subheartflows(self) -> List["SubHeartflow"]: """获取所有当前管理的 SubHeartflow 实例列表 (快照)。""" return list(self.subheartflows.values()) @@ -103,24 +116,6 @@ class SubHeartflowManager: except Exception as e: logger.error(f"[子心流管理] 设置ABSENT状态失败: {e}") - # 停止子心流内部循环 - subheartflow.should_stop = True - - # 取消后台任务 - task = subheartflow.task - if task and not task.done(): - task.cancel() - logger.debug(f"[子心流管理] 已取消 {stream_name} 的后台任务") - - # 从管理字典中移除 - if subheartflow_id in self.subheartflows: - del self.subheartflows[subheartflow_id] - logger.debug(f"[子心流管理] 已移除 {stream_name}") - return True - else: - logger.warning(f"[子心流管理] {stream_name} 已被提前移除") - return False - def get_inactive_subheartflows(self, max_age_seconds=INACTIVE_THRESHOLD_SECONDS): """识别并返回需要清理的不活跃(处于ABSENT状态超过一小时)子心流(id, 原因)""" current_time = time.time() @@ -185,52 +180,6 @@ class SubHeartflowManager: else: logger.debug(f"[限制] 无需停止, 当前总数:{len(self.subheartflows)}") - async def activate_random_subflows_to_chat(self): - """主状态激活时，随机选择ABSENT子心流进入CHAT状态""" - # 使用 self.mai_state_info 获取当前状态和限制 - current_mai_state = self.mai_state_info.get_current_state() - limit = current_mai_state.get_normal_chat_max_num() - if limit <= 0: - logger.info("[激活] 当前状态不允许CHAT子心流") - return - - # 获取所有ABSENT状态的子心流 - absent_flows = [flow for flow in self.subheartflows.values() if flow.chat_state.chat_status == ChatState.ABSENT] - - num_to_activate = min(limit, len(absent_flows)) - if num_to_activate <= 0: - logger.info(f"[激活] 无可用ABSENT子心流(限额:{limit}, 可用:{len(absent_flows)})") - return - - logger.info(f"[激活] 随机选择{num_to_activate}个ABSENT子心流进入CHAT状态") - activated_count = 0 - - for flow in random.sample(absent_flows, num_to_activate): - flow_id = flow.subheartflow_id - stream_name = chat_manager.get_stream_name(flow_id) or flow_id - - if flow_id not in self.subheartflows: - logger.warning(f"[激活] 跳过{stream_name}, 子心流已不存在") - continue - - logger.debug(f"[激活] 正在激活子心流{stream_name}") - - # --- 限额检查 --- # - current_chat_count = self.count_subflows_by_state(ChatState.CHAT) - if current_chat_count >= limit: - logger.warning(f"[激活] 跳过{stream_name}, 普通聊天已达上限 ({current_chat_count}/{limit})") - continue # 跳过此子心流，继续尝试激活下一个 - # --- 结束限额检查 --- # - - # 移除 states_num 参数 - await flow.change_chat_state(ChatState.CHAT) - - if flow.chat_state.chat_status == ChatState.CHAT: - activated_count += 1 - else: - logger.warning(f"[激活] {stream_name}状态设置失败") - - logger.info(f"[激活] 完成, 成功激活{activated_count}个子心流") async def deactivate_all_subflows(self): """将所有子心流的状态更改为 ABSENT (例如主状态变为OFFLINE时调用)""" @@ -394,15 +343,172 @@ class SubHeartflowManager: else: logger.debug(f"{log_prefix_manager} 随机停用周期结束, 未停用任何子心流。") - def count_subflows_by_state(self, state: ChatState) -> int: - """统计指定状态的子心流数量 + + async def evaluate_and_transition_subflows_by_llm(self): + """ + 使用LLM评估每个子心流的状态，并根据LLM的判断执行状态转换（ABSENT <-> CHAT）。 + 注意：此函数包含对假设的LLM函数的调用。 + """ + log_prefix = "[LLM状态评估]" + logger.info(f"{log_prefix} 开始基于LLM评估子心流状态...") + + # 获取当前状态和限制，用于CHAT激活检查 + current_mai_state = self.mai_state_info.get_current_state() + chat_limit = current_mai_state.get_normal_chat_max_num() + + transitioned_to_chat = 0 + transitioned_to_absent = 0 + + async with self._lock: # 在锁内获取快照并迭代 + subflows_snapshot = list(self.subheartflows.values()) + # 使用不上锁的版本，因为我们已经在锁内 + current_chat_count = self.count_subflows_by_state_nolock(ChatState.CHAT) + + if not subflows_snapshot: + logger.info(f"{log_prefix} 当前没有子心流需要评估。") + return + + for sub_hf in subflows_snapshot: + flow_id = sub_hf.subheartflow_id + stream_name = chat_manager.get_stream_name(flow_id) or flow_id + current_subflow_state = sub_hf.chat_state.chat_status + + # --- 获取观察内容 --- + # 从 sub_hf.observations 获取 ChattingObservation 并提取信息 + observation_summary = "没有可用的观察信息。" # 默认值 + try: + # 检查 observations 列表是否存在且不为空 + + # 假设第一个观察者是 ChattingObservation + first_observation = sub_hf.observations[0] + if isinstance(first_observation, ChattingObservation): + # 组合中期记忆和当前聊天内容 + current_chat = first_observation.talking_message_str or "当前无聊天内容。" + combined_summary = f"当前聊天内容:\n{current_chat}" + else: + logger.warning(f"{log_prefix} [{stream_name}] 第一个观察者不是 ChattingObservation 类型。") + + + except Exception as e: + logger.warning(f"{log_prefix} [{stream_name}] 获取观察信息失败: {e}", exc_info=True) + # 保留默认值或错误信息 + combined_summary = f"获取观察信息时出错: {e}" + + + # --- 获取麦麦状态 --- + mai_state_description = f"麦麦当前状态: {current_mai_state.value}。" + + # --- 针对 ABSENT 状态 --- + if current_subflow_state == ChatState.ABSENT: + # 构建Prompt + prompt = ( + f"子心流 [{stream_name}] 当前处于非活跃(ABSENT)状态。\n" + f"{mai_state_description}\n" + f"最近观察到的内容摘要:\n---\n{combined_summary}\n---\n" + f"基于以上信息，该子心流是否表现出足够的活跃迹象或重要性，" + f"值得将其唤醒并进入常规聊天(CHAT)状态？" + f"请回答 '是' 或 '否'。" + ) + + # 调用LLM评估 + try: + # 使用 self._llm_evaluate_state_transition + should_activate = await self._llm_evaluate_state_transition(prompt) + if should_activate: + # 检查CHAT限额 + if current_chat_count < chat_limit: + logger.info(f"{log_prefix} [{stream_name}] LLM建议激活到CHAT状态，且未达上限({current_chat_count}/{chat_limit})。正在尝试转换...") + await sub_hf.change_chat_state(ChatState.CHAT) + if sub_hf.chat_state.chat_status == ChatState.CHAT: + transitioned_to_chat += 1 + current_chat_count += 1 # 更新计数器 + else: + logger.warning(f"{log_prefix} [{stream_name}] 尝试激活到CHAT失败。") + else: + logger.info(f"{log_prefix} [{stream_name}] LLM建议激活到CHAT状态，但已达到上限({current_chat_count}/{chat_limit})。跳过转换。") + except Exception as e: + logger.error(f"{log_prefix} [{stream_name}] LLM评估或状态转换(ABSENT->CHAT)时出错: {e}", exc_info=True) + + + # --- 针对 CHAT 状态 --- + elif current_subflow_state == ChatState.CHAT: + # 构建Prompt + prompt = ( + f"子心流 [{stream_name}] 当前处于常规聊天(CHAT)状态。\n" + f"{mai_state_description}\n" + f"最近观察到的内容摘要:\n---\n{combined_summary}\n---\n" + f"基于以上信息，该子心流是否表现出不活跃、对话结束或不再需要关注的迹象，" + f"应该让其进入休眠(ABSENT)状态？" + f"请回答 '是' 或 '否'。" + ) + + # 调用LLM评估 + try: + # 使用 self._llm_evaluate_state_transition + should_deactivate = await self._llm_evaluate_state_transition(prompt) + if should_deactivate: + logger.info(f"{log_prefix} [{stream_name}] LLM建议进入ABSENT状态。正在尝试转换...") + await sub_hf.change_chat_state(ChatState.ABSENT) + if sub_hf.chat_state.chat_status == ChatState.ABSENT: + transitioned_to_absent += 1 + current_chat_count -= 1 # 更新计数器 + else: + logger.warning(f"{log_prefix} [{stream_name}] 尝试转换为ABSENT失败。") + except Exception as e: + logger.error(f"{log_prefix} [{stream_name}] LLM评估或状态转换(CHAT->ABSENT)时出错: {e}", exc_info=True) + + # 可以选择性地为 FOCUSED 状态添加评估逻辑，例如判断是否降级回 CHAT 或 ABSENT + + logger.info( + f"{log_prefix} LLM评估周期结束。" + f" 成功转换到CHAT: {transitioned_to_chat}." + f" 成功转换到ABSENT: {transitioned_to_absent}." + ) + + + async def _llm_evaluate_state_transition(self, prompt: str) -> bool: + """ + 使用 LLM 评估是否应进行状态转换。 Args: - state: 要统计的聊天状态枚举值 + prompt: 提供给 LLM 的提示信息。 Returns: - int: 处于该状态的子心流数量 + bool: True 表示应该转换，False 表示不应该转换。 """ + log_prefix = "[LLM状态评估]" + try: + # --- 真实的 LLM 调用 --- + response_text, _, model_name = await self.llm_state_evaluator.generate_response_async(prompt) + logger.debug(f"{log_prefix} 使用模型 {model_name} 评估，原始响应: {response_text}") + # 解析响应 - 这里需要根据你的LLM的确切输出来调整逻辑 + # 假设 LLM 会明确回答 "是" 或 "否" + if response_text and "是" in response_text.strip(): + logger.debug(f"{log_prefix} LLM评估结果: 建议转换 (响应包含 '是')") + return True + elif response_text and "否" in response_text.strip(): + logger.debug(f"{log_prefix} LLM评估结果: 建议不转换 (响应包含 '否')") + return False + else: + logger.warning(f"{log_prefix} LLM 未明确回答 '是' 或 '否'，响应: {response_text}") + # 可以设定一个默认行为，例如默认不转换 + return False + # --- 真实的 LLM 调用结束 --- + + # # --- 占位符逻辑：随机返回 True/False --- + # # 请在接入真实 LLM 后移除此部分 + # await asyncio.sleep(0.1) # 模拟LLM调用延迟 + # result = random.choice([True, False]) + # logger.debug(f"{log_prefix} (占位符) LLM评估结果: {'建议转换' if result else '建议不转换'}") + # return result + # # --- 占位符逻辑结束 --- + + except Exception as e: + logger.error(f"{log_prefix} 调用 LLM 进行状态评估时出错: {e}", exc_info=True) + + + def count_subflows_by_state(self, state: ChatState) -> int: + """统计指定状态的子心流数量""" count = 0 # 遍历所有子心流实例 for subheartflow in self.subheartflows.values(): @@ -411,12 +517,19 @@ class SubHeartflowManager: count += 1 return count - def get_active_subflow_minds(self) -> List[str]: - """获取所有活跃(非ABSENT)子心流的当前想法 - - 返回: - List[str]: 包含所有活跃子心流当前想法的列表 + def count_subflows_by_state_nolock(self, state: ChatState) -> int: """ + 统计指定状态的子心流数量 (不上锁版本)。 + 警告：仅应在已持有 self._lock 的上下文中使用此方法。 + """ + count = 0 + for subheartflow in self.subheartflows.values(): + if subheartflow.chat_state.chat_status == state: + count += 1 + return count + + def get_active_subflow_minds(self) -> List[str]: + """获取所有活跃(非ABSENT)子心流的当前想法""" minds = [] for subheartflow in self.subheartflows.values(): # 检查子心流是否活跃(非ABSENT状态) diff --git a/src/plugins/heartFC_chat/heartflow_processor.py b/src/plugins/heartFC_chat/heartflow_processor.py index 1f771688d..c907f98a8 100644 --- a/src/plugins/heartFC_chat/heartflow_processor.py +++ b/src/plugins/heartFC_chat/heartflow_processor.py @@ -167,7 +167,7 @@ class HeartFCProcessor: # 6. 兴趣度计算与更新 interested_rate, is_mentioned = await self._calculate_interest(message) await subheartflow.interest_chatting.increase_interest(value=interested_rate) - await subheartflow.interest_chatting.add_interest_dict(message, interested_rate, is_mentioned) + subheartflow.interest_chatting.add_interest_dict(message, interested_rate, is_mentioned) # 7. 日志记录 mes_name = chat.group_info.group_name if chat.group_info else "私聊"