炸 service 层

src/plugin_runtime/capabilities/data.py

@@ -0,0 +1,582 @@
+from typing import Any, Dict, List, Optional
+
+from src.chat.message_receive.chat_manager import BotChatSession, chat_manager
+from src.common.logger import get_logger
+
+logger = get_logger("plugin_runtime.integration")
+
+
+class RuntimeDataCapabilityMixin:
+    async def _cap_database_query(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.services import database_service as database_api
+
+        model_name: str = args.get("model_name", "")
+        if not model_name:
+            return {"success": False, "error": "缺少必要参数 model_name"}
+
+        try:
+            import src.common.database.database_model as db_models
+
+            model_class = getattr(db_models, model_name, None)
+            if model_class is None:
+                return {"success": False, "error": f"未找到数据模型: {model_name}"}
+
+            query_type = args.get("query_type", "get")
+            if query_type == "get":
+                result = await database_api.db_get(
+                    model_class=model_class,
+                    filters=args.get("filters"),
+                    limit=args.get("limit"),
+                    order_by=args.get("order_by"),
+                    single_result=args.get("single_result", False),
+                )
+            elif query_type == "create":
+                if not (data := args.get("data")):
+                    return {"success": False, "error": "create 需要 data"}
+                result = await database_api.db_save(model_class=model_class, data=data)
+            elif query_type == "update":
+                if not (data := args.get("data")):
+                    return {"success": False, "error": "update 需要 data"}
+                result = await database_api.db_update(
+                    model_class=model_class,
+                    data=data,
+                    filters=args.get("filters"),
+                )
+            elif query_type == "delete":
+                result = await database_api.db_delete(model_class=model_class, filters=args.get("filters"))
+            elif query_type == "count":
+                result = await database_api.db_count(model_class=model_class, filters=args.get("filters"))
+            else:
+                return {"success": False, "error": f"不支持的 query_type: {query_type}"}
+            return {"success": True, "result": result}
+        except Exception as e:
+            logger.error(f"[cap.database.query] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_database_save(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.services import database_service as database_api
+
+        model_name: str = args.get("model_name", "")
+        data: Optional[Dict[str, Any]] = args.get("data")
+        if not model_name or not data:
+            return {"success": False, "error": "缺少必要参数 model_name 或 data"}
+
+        try:
+            import src.common.database.database_model as db_models
+
+            model_class = getattr(db_models, model_name, None)
+            if model_class is None:
+                return {"success": False, "error": f"未找到数据模型: {model_name}"}
+
+            result = await database_api.db_save(
+                model_class=model_class,
+                data=data,
+                key_field=args.get("key_field"),
+                key_value=args.get("key_value"),
+            )
+            return {"success": True, "result": result}
+        except Exception as e:
+            logger.error(f"[cap.database.save] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_database_get(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.services import database_service as database_api
+
+        model_name: str = args.get("model_name", "")
+        if not model_name:
+            return {"success": False, "error": "缺少必要参数 model_name"}
+
+        try:
+            import src.common.database.database_model as db_models
+
+            model_class = getattr(db_models, model_name, None)
+            if model_class is None:
+                return {"success": False, "error": f"未找到数据模型: {model_name}"}
+
+            result = await database_api.db_get(
+                model_class=model_class,
+                filters=args.get("filters"),
+                limit=args.get("limit"),
+                order_by=args.get("order_by"),
+                single_result=args.get("single_result", False),
+            )
+            return {"success": True, "result": result}
+        except Exception as e:
+            logger.error(f"[cap.database.get] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_database_delete(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.services import database_service as database_api
+
+        model_name: str = args.get("model_name", "")
+        filters = args.get("filters", {})
+        if not model_name:
+            return {"success": False, "error": "缺少必要参数 model_name"}
+        if not filters:
+            return {"success": False, "error": "缺少必要参数 filters（不允许无条件删除）"}
+
+        try:
+            import src.common.database.database_model as db_models
+
+            model_class = getattr(db_models, model_name, None)
+            if model_class is None:
+                return {"success": False, "error": f"未找到数据模型: {model_name}"}
+
+            result = await database_api.db_delete(model_class=model_class, filters=filters)
+            return {"success": True, "result": result}
+        except Exception as e:
+            logger.error(f"[cap.database.delete] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_database_count(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.services import database_service as database_api
+
+        model_name: str = args.get("model_name", "")
+        if not model_name:
+            return {"success": False, "error": "缺少必要参数 model_name"}
+
+        try:
+            import src.common.database.database_model as db_models
+
+            model_class = getattr(db_models, model_name, None)
+            if model_class is None:
+                return {"success": False, "error": f"未找到数据模型: {model_name}"}
+
+            result = await database_api.db_count(model_class=model_class, filters=args.get("filters"))
+            return {"success": True, "count": result}
+        except Exception as e:
+            logger.error(f"[cap.database.count] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    def _list_sessions(self, platform: str, is_group_session: Optional[bool] = None) -> List[BotChatSession]:
+        return [
+            session
+            for session in chat_manager.sessions.values()
+            if (platform == "all_platforms" or session.platform == platform)
+            and (is_group_session is None or session.is_group_session == is_group_session)
+        ]
+
+    @staticmethod
+    def _serialize_stream(stream: BotChatSession) -> Dict[str, Any]:
+        return {
+            "session_id": stream.session_id,
+            "platform": stream.platform,
+            "user_id": stream.user_id,
+            "group_id": stream.group_id,
+            "is_group_session": stream.is_group_session,
+        }
+
+    async def _cap_chat_get_all_streams(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        platform: str = args.get("platform", "qq")
+        try:
+            streams = self._list_sessions(platform=platform)
+            return {"success": True, "streams": [self._serialize_stream(item) for item in streams]}
+        except Exception as e:
+            logger.error(f"[cap.chat.get_all_streams] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_chat_get_group_streams(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        platform: str = args.get("platform", "qq")
+        try:
+            streams = self._list_sessions(platform=platform, is_group_session=True)
+            return {"success": True, "streams": [self._serialize_stream(item) for item in streams]}
+        except Exception as e:
+            logger.error(f"[cap.chat.get_group_streams] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_chat_get_private_streams(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        platform: str = args.get("platform", "qq")
+        try:
+            streams = self._list_sessions(platform=platform, is_group_session=False)
+            return {"success": True, "streams": [self._serialize_stream(item) for item in streams]}
+        except Exception as e:
+            logger.error(f"[cap.chat.get_private_streams] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_chat_get_stream_by_group_id(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        group_id: str = args.get("group_id", "")
+        if not group_id:
+            return {"success": False, "error": "缺少必要参数 group_id"}
+
+        platform: str = args.get("platform", "qq")
+        try:
+            stream = next(
+                (
+                    item
+                    for item in self._list_sessions(platform=platform, is_group_session=True)
+                    if str(item.group_id) == str(group_id)
+                ),
+                None,
+            )
+            return {"success": True, "stream": None if stream is None else self._serialize_stream(stream)}
+        except Exception as e:
+            logger.error(f"[cap.chat.get_stream_by_group_id] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_chat_get_stream_by_user_id(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        user_id: str = args.get("user_id", "")
+        if not user_id:
+            return {"success": False, "error": "缺少必要参数 user_id"}
+
+        platform: str = args.get("platform", "qq")
+        try:
+            stream = next(
+                (
+                    item
+                    for item in self._list_sessions(platform=platform, is_group_session=False)
+                    if str(item.user_id) == str(user_id)
+                ),
+                None,
+            )
+            return {"success": True, "stream": None if stream is None else self._serialize_stream(stream)}
+        except Exception as e:
+            logger.error(f"[cap.chat.get_stream_by_user_id] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    @staticmethod
+    def _serialize_messages(messages: list) -> List[Dict[str, Any]]:
+        result: List[Dict[str, Any]] = []
+        for msg in messages:
+            if hasattr(msg, "model_dump"):
+                result.append(msg.model_dump())
+            elif hasattr(msg, "__dict__"):
+                result.append(dict(msg.__dict__))
+            else:
+                result.append(str(msg))
+        return result
+
+    async def _cap_message_get_by_time(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.services import message_service as message_api
+
+        try:
+            messages = message_api.get_messages_by_time(
+                start_time=float(args.get("start_time", 0.0)),
+                end_time=float(args.get("end_time", 0.0)),
+                limit=args.get("limit", 0),
+                limit_mode=args.get("limit_mode", "latest"),
+                filter_mai=args.get("filter_mai", False),
+            )
+            return {"success": True, "messages": self._serialize_messages(messages)}
+        except Exception as e:
+            logger.error(f"[cap.message.get_by_time] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_message_get_by_time_in_chat(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.services import message_service as message_api
+
+        chat_id: str = args.get("chat_id", "")
+        if not chat_id:
+            return {"success": False, "error": "缺少必要参数 chat_id"}
+
+        try:
+            messages = message_api.get_messages_by_time_in_chat(
+                chat_id=chat_id,
+                start_time=float(args.get("start_time", 0.0)),
+                end_time=float(args.get("end_time", 0.0)),
+                limit=args.get("limit", 0),
+                limit_mode=args.get("limit_mode", "latest"),
+                filter_mai=args.get("filter_mai", False),
+                filter_command=args.get("filter_command", False),
+            )
+            return {"success": True, "messages": self._serialize_messages(messages)}
+        except Exception as e:
+            logger.error(f"[cap.message.get_by_time_in_chat] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_message_get_recent(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.services import message_service as message_api
+
+        chat_id: str = args.get("chat_id", "")
+        if not chat_id:
+            return {"success": False, "error": "缺少必要参数 chat_id"}
+
+        try:
+            messages = message_api.get_recent_messages(
+                chat_id=chat_id,
+                hours=float(args.get("hours", 24.0)),
+                limit=args.get("limit", 100),
+                limit_mode=args.get("limit_mode", "latest"),
+                filter_mai=args.get("filter_mai", False),
+            )
+            return {"success": True, "messages": self._serialize_messages(messages)}
+        except Exception as e:
+            logger.error(f"[cap.message.get_recent] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_message_count_new(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.services import message_service as message_api
+
+        chat_id: str = args.get("chat_id", "")
+        if not chat_id:
+            return {"success": False, "error": "缺少必要参数 chat_id"}
+
+        try:
+            since = args.get("since")
+            start_time = float(since) if since is not None else float(args.get("start_time", 0.0))
+            count = message_api.count_new_messages(
+                chat_id=chat_id,
+                start_time=start_time,
+                end_time=args.get("end_time"),
+            )
+            return {"success": True, "count": count}
+        except Exception as e:
+            logger.error(f"[cap.message.count_new] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_message_build_readable(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.services import message_service as message_api
+
+        try:
+            messages = args.get("messages")
+            if messages is None:
+                if not (chat_id := args.get("chat_id", "")):
+                    return {"success": False, "error": "缺少必要参数: messages 或 chat_id"}
+                messages = message_api.get_messages_by_time_in_chat(
+                    chat_id=chat_id,
+                    start_time=float(args.get("start_time", 0.0)),
+                    end_time=float(args.get("end_time", 0.0)),
+                    limit=args.get("limit", 0),
+                )
+
+            readable = message_api.build_readable_messages_to_str(
+                messages=messages,
+                replace_bot_name=args.get("replace_bot_name", True),
+                timestamp_mode=args.get("timestamp_mode", "relative"),
+                truncate=args.get("truncate", False),
+            )
+            return {"success": True, "text": readable}
+        except Exception as e:
+            logger.error(f"[cap.message.build_readable] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_person_get_id(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.person_info.person_info import Person
+
+        platform: str = args.get("platform", "")
+        user_id = args.get("user_id", "")
+        if not platform or not user_id:
+            return {"success": False, "error": "缺少必要参数 platform 或 user_id"}
+
+        try:
+            pid = Person(platform=platform, user_id=str(user_id)).person_id
+            return {"success": True, "person_id": pid}
+        except Exception as e:
+            logger.error(f"[cap.person.get_id] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_person_get_value(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.person_info.person_info import Person
+
+        person_id: str = args.get("person_id", "")
+        field_name: str = args.get("field_name", "")
+        if not person_id or not field_name:
+            return {"success": False, "error": "缺少必要参数 person_id 或 field_name"}
+
+        try:
+            person = Person(person_id=person_id)
+            value = getattr(person, field_name)
+            if value is None:
+                value = args.get("default")
+            return {"success": True, "value": value}
+        except Exception as e:
+            logger.error(f"[cap.person.get_value] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_person_get_id_by_name(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.person_info.person_info import Person
+
+        person_name: str = args.get("person_name", "")
+        if not person_name:
+            return {"success": False, "error": "缺少必要参数 person_name"}
+
+        try:
+            pid = Person(person_name=person_name).person_id
+            return {"success": True, "person_id": pid}
+        except Exception as e:
+            logger.error(f"[cap.person.get_id_by_name] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_emoji_get_by_description(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.services import emoji_service as emoji_api
+
+        description: str = args.get("description", "")
+        if not description:
+            return {"success": False, "error": "缺少必要参数 description"}
+
+        try:
+            result = await emoji_api.get_by_description(description=description)
+            if result is None:
+                return {"success": True, "emoji": None}
+            emoji_base64, emoji_desc, matched_emotion = result
+            return {
+                "success": True,
+                "emoji": {
+                    "base64": emoji_base64,
+                    "description": emoji_desc,
+                    "emotion": matched_emotion,
+                },
+            }
+        except Exception as e:
+            logger.error(f"[cap.emoji.get_by_description] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_emoji_get_random(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.services import emoji_service as emoji_api
+
+        count: int = args.get("count", 1)
+        try:
+            results = await emoji_api.get_random(count=count)
+            emojis = [{"base64": b64, "description": desc, "emotion": emo} for b64, desc, emo in results]
+            return {"success": True, "emojis": emojis}
+        except Exception as e:
+            logger.error(f"[cap.emoji.get_random] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_emoji_get_count(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.services import emoji_service as emoji_api
+
+        try:
+            return {"success": True, "count": emoji_api.get_count()}
+        except Exception as e:
+            logger.error(f"[cap.emoji.get_count] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_emoji_get_emotions(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.services import emoji_service as emoji_api
+
+        try:
+            return {"success": True, "emotions": emoji_api.get_emotions()}
+        except Exception as e:
+            logger.error(f"[cap.emoji.get_emotions] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_emoji_get_all(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.services import emoji_service as emoji_api
+
+        try:
+            results = await emoji_api.get_all()
+            emojis = [{"base64": b64, "description": desc, "emotion": emo} for b64, desc, emo in results] if results else []
+            return {"success": True, "emojis": emojis}
+        except Exception as e:
+            logger.error(f"[cap.emoji.get_all] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_emoji_get_info(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.services import emoji_service as emoji_api
+
+        try:
+            return {"success": True, "info": emoji_api.get_info()}
+        except Exception as e:
+            logger.error(f"[cap.emoji.get_info] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_emoji_register(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.services import emoji_service as emoji_api
+
+        emoji_base64: str = args.get("emoji_base64", "")
+        if not emoji_base64:
+            return {"success": False, "error": "缺少必要参数 emoji_base64"}
+
+        try:
+            return await emoji_api.register_emoji(emoji_base64)
+        except Exception as e:
+            logger.error(f"[cap.emoji.register] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_emoji_delete(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.services import emoji_service as emoji_api
+
+        emoji_hash: str = args.get("emoji_hash", "")
+        if not emoji_hash:
+            return {"success": False, "error": "缺少必要参数 emoji_hash"}
+
+        try:
+            return await emoji_api.delete_emoji(emoji_hash)
+        except Exception as e:
+            logger.error(f"[cap.emoji.delete] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    @staticmethod
+    def _get_frequency_adjust_value(chat_id: str) -> float:
+        from src.chat.heart_flow.heartflow_manager import heartflow_manager
+
+        heartflow_chat = heartflow_manager.heartflow_chat_list.get(chat_id)
+        return 1.0 if heartflow_chat is None else heartflow_chat._talk_frequency_adjust
+
+    async def _cap_frequency_get_current_talk_value(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.common.utils.utils_config import ChatConfigUtils
+
+        chat_id: str = args.get("chat_id", "")
+        if not chat_id:
+            return {"success": False, "error": "缺少必要参数 chat_id"}
+
+        try:
+            value = self._get_frequency_adjust_value(chat_id) * ChatConfigUtils.get_talk_value(chat_id)
+            return {"success": True, "value": value}
+        except Exception as e:
+            logger.error(f"[cap.frequency.get_current_talk_value] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_frequency_set_adjust(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.chat.heart_flow.heartflow_manager import heartflow_manager
+
+        chat_id: str = args.get("chat_id", "")
+        value = args.get("value")
+        if not chat_id or value is None:
+            return {"success": False, "error": "缺少必要参数 chat_id 或 value"}
+
+        try:
+            heartflow_manager.adjust_talk_frequency(chat_id, float(value))
+            return {"success": True}
+        except Exception as e:
+            logger.error(f"[cap.frequency.set_adjust] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_frequency_get_adjust(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        chat_id: str = args.get("chat_id", "")
+        if not chat_id:
+            return {"success": False, "error": "缺少必要参数 chat_id"}
+
+        try:
+            value = self._get_frequency_adjust_value(chat_id)
+            return {"success": True, "value": value}
+        except Exception as e:
+            logger.error(f"[cap.frequency.get_adjust] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_tool_get_definitions(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        from src.core.component_registry import component_registry as core_registry
+
+        try:
+            tools = core_registry.get_llm_available_tools()
+            return {
+                "success": True,
+                "tools": [{"name": name, "definition": info.get_llm_definition()} for name, info in tools.items()],
+            }
+        except Exception as e:
+            logger.error(f"[cap.tool.get_definitions] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def _cap_knowledge_search(self, plugin_id: str, capability: str, args: Dict[str, Any]) -> Any:
+        query: str = args.get("query", "")
+        if not query:
+            return {"success": False, "error": "缺少必要参数 query"}
+
+        limit = args.get("limit", 5)
+        try:
+            limit_value = max(1, int(limit))
+        except (TypeError, ValueError):
+            limit_value = 5
+
+        try:
+            from src.chat.knowledge import qa_manager
+
+            if qa_manager is None:
+                return {"success": True, "content": "LPMM知识库已禁用"}
+
+            knowledge_info = await qa_manager.get_knowledge(query, limit=limit_value)
+            content = f"你知道这些知识: {knowledge_info}" if knowledge_info else f"你不太了解有关{query}的知识"
+            return {"success": True, "content": content}
+        except Exception as e:
+            logger.error(f"[cap.knowledge.search] 执行失败: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}