Mofox-Core/src/chat/planner_actions/action_manager.py

import asyncio
import time
import traceback
from typing import Any

from src.chat.message_receive.chat_stream import ChatStream, get_chat_manager
from src.chat.utils.timer_calculator import Timer
from src.common.data_models.database_data_model import DatabaseMessages
from src.common.logger import get_logger
from src.config.config import global_config
from src.person_info.person_info import get_person_info_manager
from src.plugin_system.apis import database_api, generator_api, message_api, send_api
from src.plugin_system.base.base_action import BaseAction
from src.plugin_system.base.component_types import ActionInfo, ComponentType
from src.plugin_system.core.component_registry import component_registry

logger = get_logger("action_manager")


class ChatterActionManager:
    """
    动作管理器，用于管理各种类型的动作

    现在统一使用新插件系统，简化了原有的新旧兼容逻辑。
    """

    def __init__(self):
        """初始化动作管理器"""

        # 当前正在使用的动作集合，默认加载默认动作
        self._using_actions: dict[str, ActionInfo] = {}

        # 初始化时将默认动作加载到使用中的动作
        self._using_actions = component_registry.get_default_actions()

        self.log_prefix: str = "ChatterActionManager"
        # 批量存储支持
        self._batch_storage_enabled = False
        self._pending_actions = []
        self._current_chat_id = None

    # === 执行Action方法 ===

    @staticmethod
    def create_action(
        action_name: str,
        action_data: dict,
        reasoning: str,
        cycle_timers: dict,
        thinking_id: str,
        chat_stream: ChatStream,
        log_prefix: str,
        shutting_down: bool = False,
        action_message: DatabaseMessages | None = None,
    ) -> BaseAction | None:
        """
        创建动作处理器实例

        Args:
            action_name: 动作名称
            action_data: 动作数据
            reasoning: 执行理由
            cycle_timers: 计时器字典
            thinking_id: 思考ID
            chat_stream: 聊天流
            log_prefix: 日志前缀
            shutting_down: 是否正在关闭

        Returns:
            Optional[BaseAction]: 创建的动作处理器实例，如果动作名称未注册则返回None
        """
        try:
            # 获取组件类 - 明确指定查询Action类型
            component_class: type[BaseAction] = component_registry.get_component_class(
                action_name, ComponentType.ACTION
            )  # type: ignore
            if not component_class:
                logger.warning(f"{log_prefix} 未找到Action组件: {action_name}")
                return None

            # 获取组件信息
            component_info = component_registry.get_component_info(action_name, ComponentType.ACTION)
            if not component_info:
                logger.warning(f"{log_prefix} 未找到Action组件信息: {action_name}")
                return None

            # 获取插件配置
            plugin_config = component_registry.get_plugin_config(component_info.plugin_name)

            # 创建动作实例
            instance = component_class(
                action_data=action_data,
                reasoning=reasoning,
                cycle_timers=cycle_timers,
                thinking_id=thinking_id,
                chat_stream=chat_stream,
                log_prefix=log_prefix,
                shutting_down=shutting_down,
                plugin_config=plugin_config,
                action_message=action_message,
            )

            logger.debug(f"创建Action实例成功: {action_name}")
            return instance

        except Exception as e:
            logger.error(f"创建Action实例失败 {action_name}: {e}")
            import traceback

            logger.error(traceback.format_exc())
            return None

    def get_using_actions(self) -> dict[str, ActionInfo]:
        """获取当前正在使用的动作集合"""
        return self._using_actions.copy()

    # === Modify相关方法 ===
    def remove_action_from_using(self, action_name: str) -> bool:
        """
        从当前使用的动作集中移除指定动作

        Args:
            action_name: 动作名称

        Returns:
            bool: 移除是否成功
        """
        if action_name not in self._using_actions:
            logger.warning(f"移除失败: 动作 {action_name} 不在当前使用的动作集中")
            return False

        del self._using_actions[action_name]
        logger.debug(f"已从使用集中移除动作 {action_name}")
        return True

    def restore_actions(self) -> None:
        """恢复到默认动作集"""
        actions_to_restore = list(self._using_actions.keys())
        self._using_actions = component_registry.get_default_actions()
        logger.debug(f"恢复动作集: 从 {actions_to_restore} 恢复到默认动作集 {list(self._using_actions.keys())}")

    async def execute_action(
        self,
        action_name: str,
        chat_id: str,
        target_message: DatabaseMessages | None = None,
        reasoning: str = "",
        action_data: dict | None = None,
        thinking_id: str | None = None,
        log_prefix: str = "",
        clear_unread_messages: bool = True,
    ) -> Any:
        """
        执行单个动作的通用函数

        Args:
            action_name: 动作名称
            chat_id: 聊天id
            target_message: 目标消息
            reasoning: 执行理由
            action_data: 动作数据
            thinking_id: 思考ID
            log_prefix: 日志前缀

        Returns:
            执行结果
        """

        chat_stream = None
        try:
            logger.debug(f"🎯 [ActionManager] execute_action接收到 target_message: {target_message}")
            # 通过chat_id获取chat_stream
            chat_manager = get_chat_manager()
            chat_stream = await chat_manager.get_stream(chat_id)

            if not chat_stream:
                logger.error(f"{log_prefix} 无法找到chat_id对应的chat_stream: {chat_id}")
                return {
                    "action_type": action_name,
                    "success": False,
                    "reply_text": "",
                    "error": "chat_stream not found",
                }

            # 设置正在回复的状态
            chat_stream.context_manager.context.is_replying = True

            if action_name == "no_action":
                return {"action_type": "no_action", "success": True, "reply_text": "", "command": ""}

            if action_name == "no_reply":
                # 直接处理no_reply逻辑，不再通过动作系统
                reason = reasoning or "选择不回复"
                logger.info(f"{log_prefix} 选择不回复，原因: {reason}")

                # 存储no_reply信息到数据库（支持批量存储）
                if self._batch_storage_enabled:
                    self.add_action_to_batch(
                        action_name="no_reply",
                        action_data={"reason": reason},
                        thinking_id=thinking_id or "",
                        action_done=True,
                        action_build_into_prompt=False,
                        action_prompt_display=reason,
                    )
                else:
                    asyncio.create_task(  # noqa: RUF006
                        database_api.store_action_info(
                            chat_stream=chat_stream,
                            action_build_into_prompt=False,
                            action_prompt_display=reason,
                            action_done=True,
                            thinking_id=thinking_id or "",
                            action_data={"reason": reason},
                            action_name="no_reply",
                        )
                    )

                # 自动清空所有未读消息
                asyncio.create_task(self._clear_all_unread_messages(chat_stream.stream_id, "no_reply"))  # noqa: RUF006

                return {"action_type": "no_reply", "success": True, "reply_text": "", "command": ""}

            elif action_name != "reply" and action_name != "no_action":
                # 执行普通动作
                success, reply_text, command = await self._handle_action(
                    chat_stream,
                    action_name,
                    reasoning,
                    action_data or {},
                    {},  # cycle_timers
                    thinking_id,
                    target_message,
                )

                # 记录执行的动作到目标消息
                if success:
                    asyncio.create_task(  # noqa: RUF006
                        self._record_action_to_message(chat_stream, action_name, target_message, action_data)
                    )
                    # 自动清空所有未读消息
                    if clear_unread_messages:
                        asyncio.create_task(self._clear_all_unread_messages(chat_stream.stream_id, action_name))  # noqa: RUF006
                    # 重置打断计数
                    asyncio.create_task(self._reset_interruption_count_after_action(chat_stream.stream_id))  # noqa: RUF006

                return {
                    "action_type": action_name,
                    "success": success,
                    "reply_text": reply_text,
                    "command": command,
                }
            else:
                # 生成回复
                try:
                    success, response_set, _ = await generator_api.generate_reply(
                        chat_stream=chat_stream,
                        reply_message=target_message,
                        action_data=action_data or {},
                        available_actions=self.get_using_actions(),
                        enable_tool=global_config.tool.enable_tool,
                        request_type="chat.replyer",
                        from_plugin=False,
                    )
                    if not success or not response_set:
                        # 安全地获取 processed_plain_text
                        if target_message:
                            msg_text = target_message.processed_plain_text or "未知消息"
                        else:
                            msg_text = "未知消息"

                        logger.info(f"对 {msg_text} 的回复生成失败")
                        return {"action_type": "reply", "success": False, "reply_text": "", "loop_info": None}
                except asyncio.CancelledError:
                    logger.debug(f"{log_prefix} 并行执行：回复生成任务已被取消")
                    return {"action_type": "reply", "success": False, "reply_text": "", "loop_info": None}

                # 从action_data中提取should_quote_reply参数
                should_quote_reply = None
                if action_data and isinstance(action_data, dict):
                    should_quote_reply = action_data.get("should_quote_reply", None)

                # 发送并存储回复
                loop_info, reply_text, cycle_timers_reply = await self._send_and_store_reply(
                    chat_stream,
                    response_set,
                    asyncio.get_event_loop().time(),
                    target_message,
                    {},  # cycle_timers
                    thinking_id,
                    [],  # actions
                    should_quote_reply,  # 传递should_quote_reply参数
                )

                # 记录回复动作到目标消息
                asyncio.create_task(self._record_action_to_message(chat_stream, "reply", target_message, action_data))  # noqa: RUF006

                if clear_unread_messages:
                    asyncio.create_task(self._clear_all_unread_messages(chat_stream.stream_id, "reply"))  # noqa: RUF006

                # 回复成功，重置打断计数
                asyncio.create_task(self._reset_interruption_count_after_action(chat_stream.stream_id))  # noqa: RUF006

                return {"action_type": "reply", "success": True, "reply_text": reply_text, "loop_info": loop_info}

        except Exception as e:
            logger.error(f"{log_prefix} 执行动作时出错: {e}")
            logger.error(f"{log_prefix} 错误信息: {traceback.format_exc()}")
            return {
                "action_type": action_name,
                "success": False,
                "reply_text": "",
                "loop_info": None,
                "error": str(e),
            }
        finally:
            # 确保重置正在回复的状态
            if chat_stream:
                chat_stream.context_manager.context.is_replying = False

    async def _record_action_to_message(self, chat_stream, action_name, target_message, action_data):
        """
        记录执行的动作到目标消息中

        Args:
            chat_stream: ChatStream实例
            action_name: 动作名称
            target_message: 目标消息
            action_data: 动作数据
        """
        try:
            from src.chat.message_manager.message_manager import message_manager

            # 获取目标消息ID
            target_message_id = None
            if target_message:
                target_message_id = target_message.message_id
            elif action_data and isinstance(action_data, dict):
                target_message_id = action_data.get("target_message_id")

            if not target_message_id:
                logger.debug(f"无法获取目标消息ID，动作: {action_name}")
                return

            # 通过message_manager更新消息的动作记录并刷新focus_energy
            await message_manager.add_action(
                stream_id=chat_stream.stream_id, message_id=target_message_id, action=action_name
            )
            logger.debug(f"已记录动作 {action_name} 到消息 {target_message_id} 并更新focus_energy")

        except Exception as e:
            logger.error(f"记录动作到消息失败: {e}")
            # 不抛出异常，避免影响主要功能

    async def _reset_interruption_count_after_action(self, stream_id: str):
        """在动作执行成功后重置打断计数"""

        try:
            from src.plugin_system.apis.chat_api import get_chat_manager

            chat_manager = get_chat_manager()
            chat_stream = await chat_manager.get_stream(stream_id)
            if chat_stream:
                context = chat_stream.context_manager
                if context.context.interruption_count > 0:
                    old_count = context.context.interruption_count
                    # old_afc_adjustment = context.context.get_afc_threshold_adjustment()
                    await context.context.reset_interruption_count()
                    logger.debug(
                        f"动作执行成功，重置聊天流 {stream_id} 的打断计数: {old_count} -> 0"
                    )
        except Exception as e:
            logger.warning(f"重置打断计数时出错: {e}")

    async def _clear_all_unread_messages(self, stream_id: str, action_name: str):
        """在动作执行成功后自动清空所有未读消息

        Args:
            stream_id: 聊天流ID
            action_name: 动作名称
        """
        try:
            from src.chat.message_manager.message_manager import message_manager

            # 清空所有未读消息
            await message_manager.clear_all_unread_messages(stream_id)
            logger.debug(f"[{action_name}] 已自动清空聊天流 {stream_id} 的所有未读消息")

        except Exception as e:
            logger.error(f"[{action_name}] 自动清空未读消息时出错: {e}")
            # 不抛出异常，避免影响主要功能

    async def _handle_action(
        self, chat_stream, action, reasoning, action_data, cycle_timers, thinking_id, action_message
    ) -> tuple[bool, str, str]:
        """
        处理具体的动作执行

        Args:
            chat_stream: ChatStream实例
            action: 动作名称
            reasoning: 执行理由
            action_data: 动作数据
            cycle_timers: 循环计时器
            thinking_id: 思考ID
            action_message: 动作消息

        Returns:
            tuple: (执行是否成功, 回复文本, 命令文本)

        功能说明:
        - 创建对应的动作处理器
        - 执行动作并捕获异常
        - 返回执行结果供上级方法整合
        """
        if not chat_stream:
            return False, "", ""
        try:
            # 创建动作处理器
            action_handler = self.create_action(
                action_name=action,
                action_data=action_data,
                reasoning=reasoning,
                cycle_timers=cycle_timers,
                thinking_id=thinking_id,
                chat_stream=chat_stream,
                log_prefix=self.log_prefix,
                action_message=action_message,
            )
            if not action_handler:
                # 动作处理器创建失败，尝试回退机制
                logger.warning(f"{self.log_prefix} 创建动作处理器失败: {action}，尝试回退方案")

                # 获取当前可用的动作
                available_actions = self.get_using_actions()
                fallback_action = None

                # 回退优先级：reply > 第一个可用动作
                if "reply" in available_actions:
                    fallback_action = "reply"
                elif available_actions:
                    fallback_action = next(iter(available_actions.keys()))

                if fallback_action and fallback_action != action:
                    logger.info(f"{self.log_prefix} 使用回退动作: {fallback_action}")
                    action_handler = self.create_action(
                        action_name=fallback_action,
                        action_data=action_data,
                        reasoning=f"原动作'{action}'不可用，自动回退。{reasoning}",
                        cycle_timers=cycle_timers,
                        thinking_id=thinking_id,
                        chat_stream=chat_stream,
                        log_prefix=self.log_prefix,
                        action_message=action_message,
                    )

                if not action_handler:
                    logger.error(f"{self.log_prefix} 回退方案也失败，无法创建任何动作处理器")
                    return False, "", ""

            # 执行动作
            success, reply_text = await action_handler.handle_action()
            return success, reply_text, ""
        except Exception as e:
            logger.error(f"{self.log_prefix} 处理{action}时出错: {e}")
            traceback.print_exc()
            return False, "", ""

    async def _send_and_store_reply(
        self,
        chat_stream: ChatStream,
        response_set,
        loop_start_time,
        action_message,
        cycle_timers: dict[str, float],
        thinking_id,
        actions,
        should_quote_reply: bool | None = None,
    ) -> tuple[dict[str, Any], str, dict[str, float]]:
        """
        发送并存储回复信息

        Args:
            chat_stream: ChatStream实例
            response_set: 回复内容集合
            loop_start_time: 循环开始时间
            action_message: 动作消息
            cycle_timers: 循环计时器
            thinking_id: 思考ID
            actions: 动作列表
            should_quote_reply: 是否应该引用回复原消息，None表示自动决定

        Returns:
            Tuple[Dict[str, Any], str, Dict[str, float]]: 循环信息, 回复文本, 循环计时器
        """
        # 发送回复
        with Timer("回复发送", cycle_timers):
            reply_text = await self.send_response(
                chat_stream, response_set, loop_start_time, action_message, should_quote_reply
            )

        # 存储reply action信息
        person_info_manager = get_person_info_manager()

        # 获取 platform，如果不存在则从 chat_stream 获取，如果还是 None 则使用默认值
        if action_message:
            platform = action_message.chat_info.platform
            user_id = action_message.user_info.user_id
        else:
            platform = getattr(chat_stream, "platform", "unknown")
            user_id = ""

        # 获取用户信息并生成回复提示
        person_id = person_info_manager.get_person_id(
            platform,
            user_id,
        )
        person_name = await person_info_manager.get_value(person_id, "person_name")
        action_prompt_display = f"你对{person_name}进行了回复：{reply_text}"

        # 存储动作信息到数据库（支持批量存储）
        if self._batch_storage_enabled:
            self.add_action_to_batch(
                action_name="reply",
                action_data={"reply_text": reply_text},
                thinking_id=thinking_id or "",
                action_done=True,
                action_build_into_prompt=False,
                action_prompt_display=action_prompt_display,
            )
        else:
            await database_api.store_action_info(
                chat_stream=chat_stream,
                action_build_into_prompt=False,
                action_prompt_display=action_prompt_display,
                action_done=True,
                thinking_id=thinking_id,
                action_data={"reply_text": reply_text},
                action_name="reply",
            )

        # 构建循环信息
        loop_info: dict[str, Any] = {
            "loop_plan_info": {
                "action_result": actions,
            },
            "loop_action_info": {
                "action_taken": True,
                "reply_text": reply_text,
                "command": "",
                "taken_time": time.time(),
            },
        }

        return loop_info, reply_text, cycle_timers

    async def send_response(
        self, chat_stream, reply_set, thinking_start_time, message_data, should_quote_reply: bool | None = None
    ) -> str:
        """
        发送回复内容的具体实现

        Args:
            chat_stream: ChatStream实例
            reply_set: 回复内容集合，包含多个回复段
            thinking_start_time: 思考开始时间
            message_data: 消息数据
            should_quote_reply: 是否应该引用回复原消息，None表示自动决定

        Returns:
            str: 完整的回复文本

        功能说明:
        - 检查是否有新消息需要回复
        - 处理主动思考的"沉默"决定
        - 根据消息数量决定是否添加回复引用
        - 逐段发送回复内容，支持打字效果
        - 正确处理元组格式的回复段
        """
        current_time = time.time()
        # 计算新消息数量
        await message_api.count_new_messages(
            chat_id=chat_stream.stream_id, start_time=thinking_start_time, end_time=current_time
        )

        # 根据新消息数量决定是否需要引用回复
        reply_text = ""
        # 检查是否为主动思考消息
        if message_data:
            is_proactive_thinking = getattr(message_data, "message_type", None) == "proactive_thinking"
        else:
            is_proactive_thinking = True

        logger.debug(f"[send_response] message_data: {message_data}")

        first_replied = False
        for reply_seg in reply_set:
            # 调试日志：验证reply_seg的格式
            logger.debug(f"Processing reply_seg type: {type(reply_seg)}, content: {reply_seg}")

            # 修正：正确处理元组格式 (格式为: (type, content))
            if isinstance(reply_seg, tuple) and len(reply_seg) >= 2:
                _, data = reply_seg
            else:
                # 向下兼容：如果已经是字符串，则直接使用
                data = str(reply_seg)

            if isinstance(data, list):
                data = "".join(map(str, data))
            reply_text += data

            # 如果是主动思考且内容为"沉默"，则不发送
            if is_proactive_thinking and data.strip() == "沉默":
                logger.info(f"{self.log_prefix} 主动思考决定保持沉默，不发送消息")
                continue

            # 发送第一段回复
            if not first_replied:
                # 决定是否引用回复
                is_private_chat = not bool(chat_stream.group_info)

                # 如果明确指定了should_quote_reply，则使用指定值
                if should_quote_reply is not None:
                    set_reply_flag = should_quote_reply and bool(message_data)
                    logger.debug(
                        f"📤 [ActionManager] 使用planner指定的引用设置: should_quote_reply={should_quote_reply}"
                    )
                else:
                    # 否则使用默认逻辑：默认不引用，让对话更流畅自然
                    set_reply_flag = False
                    logger.debug(
                        f"📤 [ActionManager] 使用默认引用逻辑: 默认不引用(is_private={is_private_chat})"
                    )

                logger.debug(
                    f"📤 [ActionManager] 准备发送第一段回复。message_data: {message_data}, set_reply: {set_reply_flag}"
                )
                await send_api.text_to_stream(
                    text=data,
                    stream_id=chat_stream.stream_id,
                    reply_to_message=message_data,
                    set_reply=set_reply_flag,
                    typing=False,
                )
                first_replied = True
            else:
                # 发送后续回复
                await send_api.text_to_stream(
                    text=data,
                    stream_id=chat_stream.stream_id,
                    reply_to_message=None,
                    set_reply=False,
                    typing=True,
                )

        return reply_text

    def enable_batch_storage(self, chat_id: str):
        """启用批量存储模式"""
        self._batch_storage_enabled = True
        self._current_chat_id = chat_id
        self._pending_actions.clear()
        logger.debug(f"已启用批量存储模式，chat_id: {chat_id}")

    def disable_batch_storage(self):
        """禁用批量存储模式"""
        self._batch_storage_enabled = False
        self._current_chat_id = None
        self._pending_actions = []  # 清空队列
        logger.debug("已禁用批量存储模式")

    def add_action_to_batch(
        self,
        action_name: str,
        action_data: dict,
        thinking_id: str = "",
        action_done: bool = True,
        action_build_into_prompt: bool = False,
        action_prompt_display: str = "",
    ):
        """添加动作到批量存储列表"""
        if not self._batch_storage_enabled:
            return False

        action_record = {
            "action_name": action_name,
            "action_data": action_data,
            "thinking_id": thinking_id,
            "action_done": action_done,
            "action_build_into_prompt": action_build_into_prompt,
            "action_prompt_display": action_prompt_display,
            "timestamp": time.time(),
        }
        self._pending_actions.append(action_record)
        logger.debug(f"已添加动作到批量存储列表: {action_name} (当前待处理: {len(self._pending_actions)} 个)")
        return True

    async def flush_batch_storage(self, chat_stream):
        """批量存储所有待处理的动作记录"""
        if not self._pending_actions:
            logger.debug("没有待处理的动作需要批量存储")
            return

        try:
            logger.info(f"开始批量存储 {len(self._pending_actions)} 个动作记录")

            # 批量存储所有动作
            stored_count = 0
            for action_data in self._pending_actions:
                try:
                    result = await database_api.store_action_info(
                        chat_stream=chat_stream,
                        action_name=action_data.get("action_name", ""),
                        action_data=action_data.get("action_data", {}),
                        action_done=action_data.get("action_done", True),
                        action_build_into_prompt=action_data.get("action_build_into_prompt", False),
                        action_prompt_display=action_data.get("action_prompt_display", ""),
                        thinking_id=action_data.get("thinking_id", ""),
                    )
                    if result:
                        stored_count += 1
                except Exception as e:
                    logger.error(f"存储单个动作记录失败: {e}")

            logger.info(f"批量存储完成: 成功存储 {stored_count}/{len(self._pending_actions)} 个动作记录")

            # 清空待处理列表
            self._pending_actions.clear()

        except Exception as e:
            logger.error(f"批量存储动作记录时发生错误: {e}")