Merge branch 'dev' into plugin

src/chat/focus_chat/heartFC_chat.py

@@ -1,5 +1,4 @@
 import asyncio
-import contextlib
 import time
 import traceback
 from collections import deque
@@ -14,11 +13,44 @@ from src.chat.utils.timer_calculator import Timer
 from src.chat.planner_actions.planner import ActionPlanner
 from src.chat.planner_actions.action_modifier import ActionModifier
 from src.chat.planner_actions.action_manager import ActionManager
-from src.chat.focus_chat.focus_loop_info import FocusLoopInfo
-from src.chat.focus_chat.hfc_performance_logger import HFCPerformanceLogger
 from src.chat.focus_chat.hfc_utils import CycleDetail
 from src.person_info.relationship_builder_manager import relationship_builder_manager
 from src.plugin_system.base.component_types import ChatMode
+import random
+from src.chat.focus_chat.hfc_utils import get_recent_message_stats
+from src.person_info.person_info import get_person_info_manager
+from src.plugin_system.apis import generator_api, send_api, message_api
+from src.chat.willing.willing_manager import get_willing_manager
+from .priority_manager import PriorityManager
+from src.chat.utils.chat_message_builder import get_raw_msg_by_timestamp_with_chat
+
+
+ERROR_LOOP_INFO = {
+    "loop_plan_info": {
+        "action_result": {
+            "action_type": "error",
+            "action_data": {},
+            "reasoning": "循环处理失败",
+        },
+    },
+    "loop_action_info": {
+        "action_taken": False,
+        "reply_text": "",
+        "command": "",
+        "taken_time": time.time(),
+    },
+}
+
+NO_ACTION = {
+    "action_result": {
+        "action_type": "no_action",
+        "action_data": {},
+        "reasoning": "规划器初始化默认",
+        "is_parallel": True,
+    },
+    "chat_context": "",
+    "action_prompt": "",
+}
 
 install(extra_lines=3)
 
@@ -37,7 +69,6 @@ class HeartFChatting:
     def __init__(
         self,
         chat_id: str,
-        on_stop_focus_chat: Optional[Callable[[], Awaitable[None]]] = None,
     ):
         """
         HeartFChatting 初始化函数
@@ -56,6 +87,8 @@ class HeartFChatting:
 
         self.relationship_builder = relationship_builder_manager.get_or_create_builder(self.stream_id)
 
+        self.loop_mode = "normal"
+
         # 新增：消息计数器和疲惫阈值
         self._message_count = 0  # 发送的消息计数
         # 基于exit_focus_threshold动态计算疲惫阈值
@@ -63,73 +96,61 @@ class HeartFChatting:
         self._message_threshold = max(10, int(30 * global_config.chat.exit_focus_threshold))
         self._fatigue_triggered = False  # 是否已触发疲惫退出
 
-        self.loop_info: FocusLoopInfo = FocusLoopInfo(observe_id=self.stream_id)
-
         self.action_manager = ActionManager()
         self.action_planner = ActionPlanner(chat_id=self.stream_id, action_manager=self.action_manager)
         self.action_modifier = ActionModifier(action_manager=self.action_manager, chat_id=self.stream_id)
 
-        self._processing_lock = asyncio.Lock()
-
         # 循环控制内部状态
-        self._loop_active: bool = False  # 循环是否正在运行
+        self.running: bool = False
         self._loop_task: Optional[asyncio.Task] = None  # 主循环任务
 
         # 添加循环信息管理相关的属性
+        self.history_loop: List[CycleDetail] = []
         self._cycle_counter = 0
-        self._cycle_history: Deque[CycleDetail] = deque(maxlen=10)  # 保留最近10个循环的信息
         self._current_cycle_detail: Optional[CycleDetail] = None
-        self._shutting_down: bool = False  # 关闭标志位
-
-        # 存储回调函数
-        self.on_stop_focus_chat = on_stop_focus_chat
 
         self.reply_timeout_count = 0
         self.plan_timeout_count = 0
 
-        # 初始化性能记录器
-        # 如果没有指定版本号，则使用全局版本管理器的版本号
+        self.last_read_time = time.time() - 1
 
-        self.performance_logger = HFCPerformanceLogger(chat_id)
+        self.willing_amplifier = 1
+        self.willing_manager = get_willing_manager()
+
+        self.reply_mode = self.chat_stream.context.get_priority_mode()
+        if self.reply_mode == "priority":
+            self.priority_manager = PriorityManager(
+                normal_queue_max_size=5,
+            )
+            self.loop_mode = "priority"
+        else:
+            self.priority_manager = None
 
         logger.info(
             f"{self.log_prefix} HeartFChatting 初始化完成，消息疲惫阈值: {self._message_threshold}条（基于exit_focus_threshold={global_config.chat.exit_focus_threshold}计算，仅在auto模式下生效）"
         )
 
+        self.energy_value = 100
+
     async def start(self):
         """检查是否需要启动主循环，如果未激活则启动。"""
 
         # 如果循环已经激活，直接返回
-        if self._loop_active:
+        if self.running:
             logger.debug(f"{self.log_prefix} HeartFChatting 已激活，无需重复启动")
             return
 
         try:
-            # 重置消息计数器，开始新的focus会话
-            self.reset_message_count()
-
             # 标记为活动状态，防止重复启动
-            self._loop_active = True
+            self.running = True
 
-            # 检查是否已有任务在运行（理论上不应该，因为 _loop_active=False）
-            if self._loop_task and not self._loop_task.done():
-                logger.warning(f"{self.log_prefix} 发现之前的循环任务仍在运行（不符合预期）。取消旧任务。")
-                self._loop_task.cancel()
-                try:
-                    # 等待旧任务确实被取消
-                    await asyncio.wait_for(self._loop_task, timeout=5.0)
-                except Exception as e:
-                    logger.warning(f"{self.log_prefix} 等待旧任务取消时出错: {e}")
-                self._loop_task = None  # 清理旧任务引用
-
-            logger.debug(f"{self.log_prefix} 创建新的 HeartFChatting 主循环任务")
-            self._loop_task = asyncio.create_task(self._run_focus_chat())
+            self._loop_task = asyncio.create_task(self._main_chat_loop())
             self._loop_task.add_done_callback(self._handle_loop_completion)
-            logger.debug(f"{self.log_prefix} HeartFChatting 启动完成")
+            logger.info(f"{self.log_prefix} HeartFChatting 启动完成")
 
         except Exception as e:
             # 启动失败时重置状态
-            self._loop_active = False
+            self.running = False
             self._loop_task = None
             logger.error(f"{self.log_prefix} HeartFChatting 启动失败: {e}")
             raise
@@ -143,266 +164,203 @@ class HeartFChatting:
             else:
                 logger.info(f"{self.log_prefix} HeartFChatting: 脱离了聊天 (外部停止)")
         except asyncio.CancelledError:
-            logger.info(f"{self.log_prefix} HeartFChatting: 脱离了聊天(任务取消)")
-        finally:
-            self._loop_active = False
-            self._loop_task = None
-            if self._processing_lock.locked():
-                logger.warning(f"{self.log_prefix} HeartFChatting: 处理锁在循环结束时仍被锁定，强制释放。")
-                self._processing_lock.release()
+            logger.info(f"{self.log_prefix} HeartFChatting: 结束了聊天")
 
-    async def _run_focus_chat(self):
-        """主循环，持续进行计划并可能回复消息，直到被外部取消。"""
-        try:
-            while True:  # 主循环
-                logger.debug(f"{self.log_prefix} 开始第{self._cycle_counter}次循环")
+    def start_cycle(self):
+        self._cycle_counter += 1
+        self._current_cycle_detail = CycleDetail(self._cycle_counter)
+        self._current_cycle_detail.thinking_id = "tid" + str(round(time.time(), 2))
+        cycle_timers = {}
+        return cycle_timers, self._current_cycle_detail.thinking_id
 
-                # 检查关闭标志
-                if self._shutting_down:
-                    logger.info(f"{self.log_prefix} 检测到关闭标志，退出 Focus Chat 循环。")
-                    break
+    def end_cycle(self, loop_info, cycle_timers):
+        self._current_cycle_detail.set_loop_info(loop_info)
+        self.history_loop.append(self._current_cycle_detail)
+        self._current_cycle_detail.timers = cycle_timers
+        self._current_cycle_detail.end_time = time.time()
 
-                # 创建新的循环信息
-                self._cycle_counter += 1
-                self._current_cycle_detail = CycleDetail(self._cycle_counter)
-                self._current_cycle_detail.prefix = self.log_prefix
+    def print_cycle_info(self, cycle_timers):
+        # 记录循环信息和计时器结果
+        timer_strings = []
+        for name, elapsed in cycle_timers.items():
+            formatted_time = f"{elapsed * 1000:.2f}毫秒" if elapsed < 1 else f"{elapsed:.2f}秒"
+            timer_strings.append(f"{name}: {formatted_time}")
 
-                # 初始化周期状态
-                cycle_timers = {}
+        logger.info(
+            f"{self.log_prefix} 第{self._current_cycle_detail.cycle_id}次思考,"
+            f"耗时: {self._current_cycle_detail.end_time - self._current_cycle_detail.start_time:.1f}秒, "  # type: ignore
+            f"选择动作: {self._current_cycle_detail.loop_plan_info.get('action_result', {}).get('action_type', '未知动作')}"
+            + (f"\n详情: {'; '.join(timer_strings)}" if timer_strings else "")
+        )
 
-                # 执行规划和处理阶段
-                try:
-                    async with self._get_cycle_context():
-                        thinking_id = f"tid{str(round(time.time(), 2))}"
-                        self._current_cycle_detail.set_thinking_id(thinking_id)
+    async def _loopbody(self):
+        if self.loop_mode == "focus":
+            self.energy_value -= 5 * (1 / global_config.chat.exit_focus_threshold)
+            if self.energy_value <= 0:
+                self.loop_mode = "normal"
+                return True
 
-                        # 使用异步上下文管理器处理消息
-                        try:
-                            async with global_prompt_manager.async_message_scope(
-                                self.chat_stream.context.get_template_name()
-                            ):
-                                # 在上下文内部检查关闭状态
-                                if self._shutting_down:
-                                    logger.info(f"{self.log_prefix} 在处理上下文中检测到关闭信号，退出")
-                                    break
+            return await self._observe()
+        elif self.loop_mode == "normal":
+            new_messages_data = get_raw_msg_by_timestamp_with_chat(
+                chat_id=self.stream_id,
+                timestamp_start=self.last_read_time,
+                timestamp_end=time.time(),
+                limit=10,
+                limit_mode="earliest",
+                fliter_bot=True,
+            )
 
-                                logger.debug(f"模板 {self.chat_stream.context.get_template_name()}")
-                                loop_info = await self._observe_process_plan_action_loop(cycle_timers, thinking_id)
+            if len(new_messages_data) > 4 * global_config.chat.auto_focus_threshold:
+                self.loop_mode = "focus"
+                self.energy_value = 100
+                return True
 
-                                if loop_info["loop_action_info"]["command"] == "stop_focus_chat":
-                                    logger.info(f"{self.log_prefix} 麦麦决定停止专注聊天")
+            if new_messages_data:
+                earliest_messages_data = new_messages_data[0]
+                self.last_read_time = earliest_messages_data.get("time")
 
-                                    # 如果设置了回调函数，则调用它
-                                    if self.on_stop_focus_chat:
-                                        try:
-                                            await self.on_stop_focus_chat()
-                                            logger.info(f"{self.log_prefix} 成功调用回调函数处理停止专注聊天")
-                                        except Exception as e:
-                                            logger.error(f"{self.log_prefix} 调用停止专注聊天回调函数时出错: {e}")
-                                            logger.error(traceback.format_exc())
-                                    break
+                await self.normal_response(earliest_messages_data)
+                return True
 
-                        except asyncio.CancelledError:
-                            logger.info(f"{self.log_prefix} 处理上下文时任务被取消")
-                            break
-                        except Exception as e:
-                            logger.error(f"{self.log_prefix} 处理上下文时出错: {e}")
-                            # 为当前循环设置错误状态，防止后续重复报错
-                            error_loop_info = {
-                                "loop_plan_info": {
-                                    "action_result": {
-                                        "action_type": "error",
-                                        "action_data": {},
-                                    },
-                                },
-                                "loop_action_info": {
-                                    "action_taken": False,
-                                    "reply_text": "",
-                                    "command": "",
-                                    "taken_time": time.time(),
-                                },
-                            }
-                            self._current_cycle_detail.set_loop_info(error_loop_info)
-                            self._current_cycle_detail.complete_cycle()
+            await asyncio.sleep(1)
 
-                            # 上下文处理失败，跳过当前循环
-                            await asyncio.sleep(1)
-                            continue
+            return True
 
-                        self._current_cycle_detail.set_loop_info(loop_info)
+    async def build_reply_to_str(self, message_data: dict):
+        person_info_manager = get_person_info_manager()
+        person_id = person_info_manager.get_person_id(
+            message_data.get("chat_info_platform"), message_data.get("user_id")
+        )
+        person_name = await person_info_manager.get_value(person_id, "person_name")
+        reply_to_str = f"{person_name}:{message_data.get('processed_plain_text')}"
+        return reply_to_str
 
-                        self.loop_info.add_loop_info(self._current_cycle_detail)
+    async def _observe(self, message_data: dict = None):
+        # 创建新的循环信息
+        cycle_timers, thinking_id = self.start_cycle()
 
-                        self._current_cycle_detail.timers = cycle_timers
+        logger.info(f"{self.log_prefix} 开始第{self._cycle_counter}次思考[模式：{self.loop_mode}]")
 
-                    # 完成当前循环并保存历史
-                    self._current_cycle_detail.complete_cycle()
-                    self._cycle_history.append(self._current_cycle_detail)
-
-                    # 记录循环信息和计时器结果
-                    timer_strings = []
-                    for name, elapsed in cycle_timers.items():
-                        formatted_time = f"{elapsed * 1000:.2f}毫秒" if elapsed < 1 else f"{elapsed:.2f}秒"
-                        timer_strings.append(f"{name}: {formatted_time}")
-
-                    logger.info(
-                        f"{self.log_prefix} 第{self._current_cycle_detail.cycle_id}次思考,"
-                        f"耗时: {self._current_cycle_detail.end_time - self._current_cycle_detail.start_time:.1f}秒, "  # type: ignore
-                        f"选择动作: {self._current_cycle_detail.loop_plan_info.get('action_result', {}).get('action_type', '未知动作')}"
-                        + (f"\n详情: {'; '.join(timer_strings)}" if timer_strings else "")
-                    )
-
-                    # 记录性能数据
-                    try:
-                        action_result = self._current_cycle_detail.loop_plan_info.get("action_result", {})
-                        cycle_performance_data = {
-                            "cycle_id": self._current_cycle_detail.cycle_id,
-                            "action_type": action_result.get("action_type", "unknown"),
-                            "total_time": self._current_cycle_detail.end_time - self._current_cycle_detail.start_time,  # type: ignore
-                            "step_times": cycle_timers.copy(),
-                            "reasoning": action_result.get("reasoning", ""),
-                            "success": self._current_cycle_detail.loop_action_info.get("action_taken", False),
-                        }
-                        self.performance_logger.record_cycle(cycle_performance_data)
-                    except Exception as perf_e:
-                        logger.warning(f"{self.log_prefix} 记录性能数据失败: {perf_e}")
-
-                    await asyncio.sleep(global_config.focus_chat.think_interval)
-
-                except asyncio.CancelledError:
-                    logger.info(f"{self.log_prefix} 循环处理时任务被取消")
-                    break
-                except Exception as e:
-                    logger.error(f"{self.log_prefix} 循环处理时出错: {e}")
-                    logger.error(traceback.format_exc())
-
-                    # 如果_current_cycle_detail存在但未完成，为其设置错误状态
-                    if self._current_cycle_detail and not hasattr(self._current_cycle_detail, "end_time"):
-                        error_loop_info = {
-                            "loop_plan_info": {
-                                "action_result": {
-                                    "action_type": "error",
-                                    "action_data": {},
-                                    "reasoning": f"循环处理失败: {e}",
-                                },
-                            },
-                            "loop_action_info": {
-                                "action_taken": False,
-                                "reply_text": "",
-                                "command": "",
-                                "taken_time": time.time(),
-                            },
-                        }
-                        try:
-                            self._current_cycle_detail.set_loop_info(error_loop_info)
-                            self._current_cycle_detail.complete_cycle()
-                        except Exception as inner_e:
-                            logger.error(f"{self.log_prefix} 设置错误状态时出错: {inner_e}")
-
-                    await asyncio.sleep(1)  # 出错后等待一秒再继续
-
-        except asyncio.CancelledError:
-            # 设置了关闭标志位后被取消是正常流程
-            if not self._shutting_down:
-                logger.warning(f"{self.log_prefix} 麦麦Focus聊天模式意外被取消")
-            else:
-                logger.info(f"{self.log_prefix} 麦麦已离开Focus聊天模式")
-        except Exception as e:
-            logger.error(f"{self.log_prefix} 麦麦Focus聊天模式意外错误: {e}")
-            print(traceback.format_exc())
-
-    @contextlib.asynccontextmanager
-    async def _get_cycle_context(self):
-        """
-        循环周期的上下文管理器
-
-        用于确保资源的正确获取和释放：
-        1. 获取处理锁
-        2. 执行操作
-        3. 释放锁
-        """
-        acquired = False
-        try:
-            await self._processing_lock.acquire()
-            acquired = True
-            yield acquired
-        finally:
-            if acquired and self._processing_lock.locked():
-                self._processing_lock.release()
-
-    async def _observe_process_plan_action_loop(self, cycle_timers: dict, thinking_id: str) -> dict:
-        try:
+        async with global_prompt_manager.async_message_scope(self.chat_stream.context.get_template_name()):
             loop_start_time = time.time()
-            await self.loop_info.observe()
-
+            # await self.loop_info.observe()
             await self.relationship_builder.build_relation()
 
-            # 顺序执行调整动作和处理器阶段
             # 第一步：动作修改
             with Timer("动作修改", cycle_timers):
                 try:
-                    # 调用完整的动作修改流程
-                    await self.action_modifier.modify_actions(
-                        loop_info=self.loop_info,
-                        mode=ChatMode.FOCUS,
-                    )
+                    await self.action_modifier.modify_actions()
+                    available_actions = self.action_manager.get_using_actions()
                 except Exception as e:
                     logger.error(f"{self.log_prefix} 动作修改失败: {e}")
-                    # 继续执行，不中断流程
+
+            # 如果normal，开始一个回复生成进程，先准备好回复（其实是和planer同时进行的）
+            if self.loop_mode == "normal":
+                reply_to_str = await self.build_reply_to_str(message_data)
+                gen_task = asyncio.create_task(self._generate_response(message_data, available_actions, reply_to_str))
 
             with Timer("规划器", cycle_timers):
-                plan_result = await self.action_planner.plan()
+                plan_result = await self.action_planner.plan(mode=self.loop_mode)
 
-                loop_plan_info = {
-                    "action_result": plan_result.get("action_result", {}),
-                }
-
-            action_type, action_data, reasoning = (
-                plan_result.get("action_result", {}).get("action_type", "error"),
-                plan_result.get("action_result", {}).get("action_data", {}),
-                plan_result.get("action_result", {}).get("reasoning", "未提供理由"),
+            action_result = plan_result.get("action_result", {})
+            action_type, action_data, reasoning, is_parallel = (
+                action_result.get("action_type", "error"),
+                action_result.get("action_data", {}),
+                action_result.get("reasoning", "未提供理由"),
+                action_result.get("is_parallel", True),
             )
 
             action_data["loop_start_time"] = loop_start_time
 
-            if action_type == "reply":
-                action_str = "回复"
-            elif action_type == "no_reply":
-                action_str = "不回复"
+            if self.loop_mode == "normal":
+                if action_type == "no_action":
+                    logger.info(f"[{self.log_prefix}] {global_config.bot.nickname} 决定进行回复")
+                elif is_parallel:
+                    logger.info(
+                        f"[{self.log_prefix}] {global_config.bot.nickname} 决定进行回复, 同时执行{action_type}动作"
+                    )
+                else:
+                    logger.info(f"[{self.log_prefix}] {global_config.bot.nickname} 决定执行{action_type}动作")
+
+            if action_type == "no_action":
+                # 等待回复生成完毕
+                gather_timeout = global_config.chat.thinking_timeout
+                try:
+                    response_set = await asyncio.wait_for(gen_task, timeout=gather_timeout)
+                except asyncio.TimeoutError:
+                    response_set = None
+
+                if response_set:
+                    content = " ".join([item[1] for item in response_set if item[0] == "text"])
+
+                # 模型炸了，没有回复内容生成
+                if not response_set or (action_type not in ["no_action"] and not is_parallel):
+                    if not response_set:
+                        logger.warning(f"[{self.log_prefix}] 模型未生成回复内容")
+                    elif action_type not in ["no_action"] and not is_parallel:
+                        logger.info(
+                            f"[{self.log_prefix}] {global_config.bot.nickname} 原本想要回复：{content}，但选择执行{action_type}，不发表回复"
+                        )
+                    return False
+
+                logger.info(f"[{self.log_prefix}] {global_config.bot.nickname} 决定的回复内容: {content}")
+
+                # 发送回复 (不再需要传入 chat)
+                await self._send_response(response_set, reply_to_str, loop_start_time)
+
+                return True
+
             else:
-                action_str = action_type
+                # 动作执行计时
+                with Timer("动作执行", cycle_timers):
+                    success, reply_text, command = await self._handle_action(
+                        action_type, reasoning, action_data, cycle_timers, thinking_id
+                    )
 
-            logger.debug(f"{self.log_prefix} 麦麦想要：'{action_str}'，理由是：{reasoning}")
-
-            # 动作执行计时
-            with Timer("动作执行", cycle_timers):
-                success, reply_text, command = await self._handle_action(
-                    action_type, reasoning, action_data, cycle_timers, thinking_id
-                )
-
-                loop_action_info = {
-                    "action_taken": success,
-                    "reply_text": reply_text,
-                    "command": command,
-                    "taken_time": time.time(),
+                loop_info = {
+                    "loop_plan_info": {
+                        "action_result": plan_result.get("action_result", {}),
+                    },
+                    "loop_action_info": {
+                        "action_taken": success,
+                        "reply_text": reply_text,
+                        "command": command,
+                        "taken_time": time.time(),
+                    },
                 }
 
-            loop_info = {
-                "loop_plan_info": loop_plan_info,
-                "loop_action_info": loop_action_info,
-            }
+                if loop_info["loop_action_info"]["command"] == "stop_focus_chat":
+                    logger.info(f"{self.log_prefix} 麦麦决定停止专注聊天")
+                    return False
+                    # 停止该聊天模式的循环
 
-            return loop_info
+        self.end_cycle(loop_info, cycle_timers)
+        self.print_cycle_info(cycle_timers)
 
-        except Exception as e:
-            logger.error(f"{self.log_prefix} FOCUS聊天处理失败: {e}")
-            logger.error(traceback.format_exc())
-            return {
-                "loop_plan_info": {
-                    "action_result": {"action_type": "error", "action_data": {}, "reasoning": f"处理失败: {e}"},
-                },
-                "loop_action_info": {"action_taken": False, "reply_text": "", "command": "", "taken_time": time.time()},
-            }
+        if self.loop_mode == "normal":
+            await self.willing_manager.after_generate_reply_handle(message_data.get("message_id"))
+
+        return True
+
+    async def _main_chat_loop(self):
+        """主循环，持续进行计划并可能回复消息，直到被外部取消。"""
+        try:
+            while self.running:  # 主循环
+                success = await self._loopbody()
+                await asyncio.sleep(0.1)
+                if not success:
+                    break
+
+            logger.info(f"{self.log_prefix} 麦麦已强制离开聊天")
+        except asyncio.CancelledError:
+            # 设置了关闭标志位后被取消是正常流程
+            logger.info(f"{self.log_prefix} 麦麦已关闭聊天")
+        except Exception:
+            logger.error(f"{self.log_prefix} 麦麦聊天意外错误")
+            print(traceback.format_exc())
+        # 理论上不能到这里
+        logger.error(f"{self.log_prefix} 麦麦聊天意外错误，结束了聊天循环")
 
     async def _handle_action(
         self,
@@ -436,7 +394,6 @@ class HeartFChatting:
                     thinking_id=thinking_id,
                     chat_stream=self.chat_stream,
                     log_prefix=self.log_prefix,
-                    shutting_down=self._shutting_down,
                 )
             except Exception as e:
                 logger.error(f"{self.log_prefix} 创建动作处理器时出错: {e}")
@@ -452,32 +409,7 @@ class HeartFChatting:
             success, reply_text = result
             command = ""
 
-            # 检查action_data中是否有系统命令，优先使用系统命令
-            if "_system_command" in action_data:
-                command = action_data["_system_command"]
-                logger.debug(f"{self.log_prefix} 从action_data中获取系统命令: {command}")
-
-            # 新增：消息计数和疲惫检查
-            if action == "reply" and success:
-                self._message_count += 1
-                current_threshold = self._get_current_fatigue_threshold()
-                logger.info(
-                    f"{self.log_prefix} 已发送第 {self._message_count} 条消息（动态阈值: {current_threshold}, exit_focus_threshold: {global_config.chat.exit_focus_threshold}）"
-                )
-
-                # 检查是否达到疲惫阈值（只有在auto模式下才会自动退出）
-                if (
-                    global_config.chat.chat_mode == "auto"
-                    and self._message_count >= current_threshold
-                    and not self._fatigue_triggered
-                ):
-                    self._fatigue_triggered = True
-                    logger.info(
-                        f"{self.log_prefix} [auto模式] 已发送 {self._message_count} 条消息，达到疲惫阈值 {current_threshold}，麦麦感到疲惫了，准备退出专注聊天模式"
-                    )
-                    # 设置系统命令，在下次循环检查时触发退出
-                    command = "stop_focus_chat"
-            elif reply_text == "timeout":
+            if reply_text == "timeout":
                 self.reply_timeout_count += 1
                 if self.reply_timeout_count > 5:
                     logger.warning(
@@ -493,38 +425,10 @@ class HeartFChatting:
             traceback.print_exc()
             return False, "", ""
 
-    def _get_current_fatigue_threshold(self) -> int:
-        """动态获取当前的疲惫阈值，基于exit_focus_threshold配置
-
-        Returns:
-            int: 当前的疲惫阈值
-        """
-        return max(10, int(30 / global_config.chat.exit_focus_threshold))
-
-    def get_message_count_info(self) -> dict:
-        """获取消息计数信息
-
-        Returns:
-            dict: 包含消息计数信息的字典
-        """
-        current_threshold = self._get_current_fatigue_threshold()
-        return {
-            "current_count": self._message_count,
-            "threshold": current_threshold,
-            "fatigue_triggered": self._fatigue_triggered,
-            "remaining": max(0, current_threshold - self._message_count),
-        }
-
-    def reset_message_count(self):
-        """重置消息计数器（用于重新启动focus模式时）"""
-        self._message_count = 0
-        self._fatigue_triggered = False
-        logger.info(f"{self.log_prefix} 消息计数器已重置")
-
     async def shutdown(self):
         """优雅关闭HeartFChatting实例，取消活动循环任务"""
         logger.info(f"{self.log_prefix} 正在关闭HeartFChatting...")
-        self._shutting_down = True  # <-- 在开始关闭时设置标志位
+        self.running = False  # <-- 在开始关闭时设置标志位
 
         # 记录最终的消息统计
         if self._message_count > 0:
@@ -547,34 +451,183 @@ class HeartFChatting:
             logger.info(f"{self.log_prefix} 没有活动的HeartFChatting循环任务")
 
         # 清理状态
-        self._loop_active = False
+        self.running = False
         self._loop_task = None
-        if self._processing_lock.locked():
-            self._processing_lock.release()
-            logger.warning(f"{self.log_prefix} 已释放处理锁")
-
-        # 完成性能统计
-        try:
-            self.performance_logger.finalize_session()
-            logger.info(f"{self.log_prefix} 性能统计已完成")
-        except Exception as e:
-            logger.warning(f"{self.log_prefix} 完成性能统计时出错: {e}")
 
         # 重置消息计数器，为下次启动做准备
         self.reset_message_count()
 
         logger.info(f"{self.log_prefix} HeartFChatting关闭完成")
 
-    def get_cycle_history(self, last_n: Optional[int] = None) -> List[Dict[str, Any]]:
-        """获取循环历史记录
-
-        参数:
-            last_n: 获取最近n个循环的信息，如果为None则获取所有历史记录
-
-        返回:
-            List[Dict[str, Any]]: 循环历史记录列表
+    def adjust_reply_frequency(self):
         """
-        history = list(self._cycle_history)
-        if last_n is not None:
-            history = history[-last_n:]
-        return [cycle.to_dict() for cycle in history]
+        根据预设规则动态调整回复意愿（willing_amplifier）。
+        - 评估周期：10分钟
+        - 目标频率：由 global_config.chat.talk_frequency 定义（例如 1条/分钟）
+        - 调整逻辑：
+            - 0条回复 -> 5.0x 意愿
+            - 达到目标回复数 -> 1.0x 意愿（基准）
+            - 达到目标2倍回复数 -> 0.2x 意愿
+            - 中间值线性变化
+        - 增益抑制：如果最近5分钟回复过快，则不增加意愿。
+        """
+        # --- 1. 定义参数 ---
+        evaluation_minutes = 10.0
+        target_replies_per_min = global_config.chat.get_current_talk_frequency(
+            self.stream_id
+        )  # 目标频率：e.g. 1条/分钟
+        target_replies_in_window = target_replies_per_min * evaluation_minutes  # 10分钟内的目标回复数
+
+        if target_replies_in_window <= 0:
+            logger.debug(f"[{self.log_prefix}] 目标回复频率为0或负数，不调整意愿放大器。")
+            return
+
+        # --- 2. 获取近期统计数据 ---
+        stats_10_min = get_recent_message_stats(minutes=evaluation_minutes, chat_id=self.stream_id)
+        bot_reply_count_10_min = stats_10_min["bot_reply_count"]
+
+        # --- 3. 计算新的意愿放大器 (willing_amplifier) ---
+        # 基于回复数在 [0, target*2] 区间内进行分段线性映射
+        if bot_reply_count_10_min <= target_replies_in_window:
+            # 在 [0, 目标数] 区间，意愿从 5.0 线性下降到 1.0
+            new_amplifier = 5.0 + (bot_reply_count_10_min - 0) * (1.0 - 5.0) / (target_replies_in_window - 0)
+        elif bot_reply_count_10_min <= target_replies_in_window * 2:
+            # 在 [目标数, 目标数*2] 区间，意愿从 1.0 线性下降到 0.2
+            over_target_cap = target_replies_in_window * 2
+            new_amplifier = 1.0 + (bot_reply_count_10_min - target_replies_in_window) * (0.2 - 1.0) / (
+                over_target_cap - target_replies_in_window
+            )
+        else:
+            # 超过目标数2倍，直接设为最小值
+            new_amplifier = 0.2
+
+        # --- 4. 检查是否需要抑制增益 ---
+        # "如果邻近5分钟内，回复数量 > 频率/2，就不再进行增益"
+        suppress_gain = False
+        if new_amplifier > self.willing_amplifier:  # 仅在计算结果为增益时检查
+            suppression_minutes = 5.0
+            # 5分钟内目标回复数的一半
+            suppression_threshold = (target_replies_per_min / 2) * suppression_minutes  # e.g., (1/2)*5 = 2.5
+            stats_5_min = get_recent_message_stats(minutes=suppression_minutes, chat_id=self.stream_id)
+            bot_reply_count_5_min = stats_5_min["bot_reply_count"]
+
+            if bot_reply_count_5_min > suppression_threshold:
+                suppress_gain = True
+
+        # --- 5. 更新意愿放大器 ---
+        if suppress_gain:
+            logger.debug(
+                f"[{self.log_prefix}] 回复增益被抑制。最近5分钟内回复数 ({bot_reply_count_5_min}) "
+                f"> 阈值 ({suppression_threshold:.1f})。意愿放大器保持在 {self.willing_amplifier:.2f}"
+            )
+            # 不做任何改动
+        else:
+            # 限制最终值在 [0.2, 5.0] 范围内
+            self.willing_amplifier = max(0.2, min(5.0, new_amplifier))
+            logger.debug(
+                f"[{self.log_prefix}] 调整回复意愿。10分钟内回复: {bot_reply_count_10_min} (目标: {target_replies_in_window:.0f}) -> "
+                f"意愿放大器更新为: {self.willing_amplifier:.2f}"
+            )
+
+    async def normal_response(self, message_data: dict) -> None:
+        """
+        处理接收到的消息。
+        在"兴趣"模式下，判断是否回复并生成内容。
+        """
+
+        is_mentioned = message_data.get("is_mentioned", False)
+        interested_rate = message_data.get("interest_rate", 0.0) * self.willing_amplifier
+
+        reply_probability = (
+            1.0 if is_mentioned and global_config.normal_chat.mentioned_bot_inevitable_reply else 0.0
+        )  # 如果被提及，且开启了提及必回复，则基础概率为1，否则需要意愿判断
+
+        # 意愿管理器：设置当前message信息
+        self.willing_manager.setup(message_data, self.chat_stream)
+
+        # 获取回复概率
+        # 仅在未被提及或基础概率不为1时查询意愿概率
+        if reply_probability < 1:  # 简化逻辑，如果未提及 (reply_probability 为 0)，则获取意愿概率
+            # is_willing = True
+            reply_probability = await self.willing_manager.get_reply_probability(message_data.get("message_id"))
+
+            additional_config = message_data.get("additional_config", {})
+            if additional_config and "maimcore_reply_probability_gain" in additional_config:
+                reply_probability += additional_config["maimcore_reply_probability_gain"]
+                reply_probability = min(max(reply_probability, 0), 1)  # 确保概率在 0-1 之间
+
+        # 处理表情包
+        if message_data.get("is_emoji") or message_data.get("is_picid"):
+            reply_probability = 0
+
+        # 打印消息信息
+        mes_name = self.chat_stream.group_info.group_name if self.chat_stream.group_info else "私聊"
+        if reply_probability > 0.1:
+            logger.info(
+                f"[{mes_name}]"
+                f"{message_data.get('user_nickname')}:"
+                f"{message_data.get('processed_plain_text')}[兴趣:{interested_rate:.2f}][回复概率:{reply_probability * 100:.1f}%]"
+            )
+
+        if random.random() < reply_probability:
+            await self.willing_manager.before_generate_reply_handle(message_data.get("message_id"))
+            await self._observe(message_data=message_data)
+
+        # 意愿管理器：注销当前message信息 (无论是否回复，只要处理过就删除)
+        self.willing_manager.delete(message_data.get("message_id"))
+
+        return True
+
+    async def _generate_response(
+        self, message_data: dict, available_actions: Optional[list], reply_to: str
+    ) -> Optional[list]:
+        """生成普通回复"""
+        try:
+            success, reply_set = await generator_api.generate_reply(
+                chat_stream=self.chat_stream,
+                reply_to=reply_to,
+                available_actions=available_actions,
+                enable_tool=global_config.tool.enable_in_normal_chat,
+                request_type="normal.replyer",
+            )
+
+            if not success or not reply_set:
+                logger.info(f"对 {message_data.get('processed_plain_text')} 的回复生成失败")
+                return None
+
+            return reply_set
+
+        except Exception as e:
+            logger.error(f"[{self.log_prefix}] 回复生成出现错误：{str(e)} {traceback.format_exc()}")
+            return None
+
+    async def _send_response(self, reply_set, reply_to, thinking_start_time):
+        current_time = time.time()
+        new_message_count = message_api.count_new_messages(
+            chat_id=self.chat_stream.stream_id, start_time=thinking_start_time, end_time=current_time
+        )
+
+        need_reply = new_message_count >= random.randint(2, 4)
+
+        logger.info(
+            f"{self.log_prefix} 从思考到回复，共有{new_message_count}条新消息，{'使用' if need_reply else '不使用'}引用回复"
+        )
+
+        reply_text = ""
+        first_replyed = False
+        for reply_seg in reply_set:
+            data = reply_seg[1]
+            if not first_replyed:
+                if need_reply:
+                    await send_api.text_to_stream(
+                        text=data, stream_id=self.chat_stream.stream_id, reply_to=reply_to, typing=False
+                    )
+                    first_replyed = True
+                else:
+                    await send_api.text_to_stream(text=data, stream_id=self.chat_stream.stream_id, typing=False)
+                    first_replyed = True
+            else:
+                await send_api.text_to_stream(text=data, stream_id=self.chat_stream.stream_id, typing=True)
+            reply_text += data
+
+        return reply_text