Merge branch 'master' of https://github.com/MoFox-Studio/MoFox_Bot

plugins/napcat_adapter_plugin/event_handlers.py

@@ -48,45 +48,505 @@ class SetProfileHandler(BaseEventHandler):
         else:
             logger.error("事件 napcat_set_qq_profile 请求失败！")
             return HandlerResult(False,False,{"status":"error"})
-'''
+
-class SetProfileHandler(BaseEventHandler):
+
-    handler_name: str = "napcat_set_qq_profile_handler"
+class GetOnlineClientsHandler(BaseEventHandler):
-    handler_description: str = "设置账号信息"
+    handler_name: str = "napcat_get_online_clients_handler"
+    handler_description: str = "获取当前账号在线客户端列表"
     weight: int = 100
     intercept_message: bool = False
-    init_subscribe = [NapcatEvent.ACCOUNT.SET_PROFILE]
+    init_subscribe = [NapcatEvent.ACCOUNT.GET_ONLINE_CLIENTS]
 
-    async def execute(
+    async def execute(self, params: dict):
-            self,
+        raw = params.get("raw", {})
-            nickname: Optional[str] = "", 
+        no_cache = params.get("no_cache", False)
-            personal_note: Optional[str] = "",
-            sex: Optional[list["1","2","3"]] = "",
-            raw: dict = {}
-            ):
-        if raw:
-            nickname = raw.get("nickname","")
-            personal_note = raw.get("personal_note","")
-            sex = raw.get("sex","")
 
-        if not nickname:
+        if params.get("raw", ""):
-            logger.error("事件 napcat_set_qq_profile 缺少必要参数: nickname ")
+            no_cache = raw.get("no_cache", False)
-            return HandlerResult(False,False,"缺少必要参数: nickname")
 
         payload = {
-            "nickname": nickname,
+            "no_cache": no_cache
-            "personal_note": personal_note,
-            "sex": sex
         }
-        response = await send_handler.send_message_to_napcat(action="set_qq_profile",params=payload)
+        response = await send_handler.send_message_to_napcat(action="get_online_clients", params=payload)
-        if response.get("status","") == "ok":
+        if response.get("status", "") == "ok":
-            if response.get("data","").get("result","") == 0:
+            return HandlerResult(True, True, response)
-                return HandlerResult(True,True,True)
         else:
-                logger.error(f"事件 napcat_set_qq_profile 请求失败！err={response.get("data","").get("errMsg","")}")
+            logger.error("事件 napcat_get_online_clients 请求失败！")
-                return HandlerResult(False,False,False)
+            return HandlerResult(False, False, {"status": "error"})
-        else:
-            logger.error("事件 napcat_set_qq_profile 请求失败！")
-            return HandlerResult(False,False,False)
-'''   
 
 
+class SetOnlineStatusHandler(BaseEventHandler):
+    handler_name: str = "napcat_set_online_status_handler"
+    handler_description: str = "设置在线状态"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.ACCOUNT.SET_ONLINE_STATUS]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        status = params.get("status", "")
+        ext_status = params.get("ext_status", "0")
+        battery_status = params.get("battery_status", "0")
+
+        if params.get("raw", ""):
+            status = raw.get("status", "")
+            ext_status = raw.get("ext_status", "0")
+            battery_status = raw.get("battery_status", "0")
+
+        if not status:
+            logger.error("事件 napcat_set_online_status 缺少必要参数: status")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "status": status,
+            "ext_status": ext_status,
+            "battery_status": battery_status
+        }
+        response = await send_handler.send_message_to_napcat(action="set_online_status", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_set_online_status 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+
+class GetFriendsWithCategoryHandler(BaseEventHandler):
+    handler_name: str = "napcat_get_friends_with_category_handler"
+    handler_description: str = "获取好友分组列表"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.ACCOUNT.GET_FRIENDS_WITH_CATEGORY]
+
+    async def execute(self, params: dict):
+        payload = {}
+        response = await send_handler.send_message_to_napcat(action="get_friends_with_category", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_get_friends_with_category 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+
+class SetAvatarHandler(BaseEventHandler):
+    handler_name: str = "napcat_set_qq_avatar_handler"
+    handler_description: str = "设置头像"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.ACCOUNT.SET_AVATAR]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        file = params.get("file", "")
+
+        if params.get("raw", ""):
+            file = raw.get("file", "")
+
+        if not file:
+            logger.error("事件 napcat_set_qq_avatar 缺少必要参数: file")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "file": file
+        }
+        response = await send_handler.send_message_to_napcat(action="set_qq_avatar", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_set_qq_avatar 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+
+class SendLikeHandler(BaseEventHandler):
+    handler_name: str = "napcat_send_like_handler"
+    handler_description: str = "点赞"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.ACCOUNT.SEND_LIKE]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        user_id = params.get("user_id", "")
+        times = params.get("times", 1)
+
+        if params.get("raw", ""):
+            user_id = raw.get("user_id", "")
+            times = raw.get("times", 1)
+
+        if not user_id:
+            logger.error("事件 napcat_send_like 缺少必要参数: user_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "user_id": str(user_id),
+            "times": times
+        }
+        response = await send_handler.send_message_to_napcat(action="send_like", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_send_like 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+
+class SetFriendAddRequestHandler(BaseEventHandler):
+    handler_name: str = "napcat_set_friend_add_request_handler"
+    handler_description: str = "处理好友请求"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.ACCOUNT.SET_FRIEND_ADD_REQUEST]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        flag = params.get("flag", "")
+        approve = params.get("approve", True)
+        remark = params.get("remark", "")
+
+        if params.get("raw", ""):
+            flag = raw.get("flag", "")
+            approve = raw.get("approve", True)
+            remark = raw.get("remark", "")
+
+        if not flag or approve is None or remark is None:
+            logger.error("事件 napcat_set_friend_add_request 缺少必要参数")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "flag": flag,
+            "approve": approve,
+            "remark": remark
+        }
+        response = await send_handler.send_message_to_napcat(action="set_friend_add_request", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_set_friend_add_request 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+
+class SetSelfLongnickHandler(BaseEventHandler):
+    handler_name: str = "napcat_set_self_longnick_handler"
+    handler_description: str = "设置个性签名"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.ACCOUNT.SET_SELF_LONGNICK]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        longNick = params.get("longNick", "")
+
+        if params.get("raw", ""):
+            longNick = raw.get("longNick", "")
+
+        if not longNick:
+            logger.error("事件 napcat_set_self_longnick 缺少必要参数: longNick")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "longNick": longNick
+        }
+        response = await send_handler.send_message_to_napcat(action="set_self_longnick", params=payload)
+        if response.get("status", "") == "ok":
+            if response.get("data", {}).get("result", "") == 0:
+                return HandlerResult(True, True, response)
+            else:
+                logger.error(f"事件 napcat_set_self_longnick 请求失败！err={response.get('data', {}).get('errMsg', '')}")
+                return HandlerResult(False, False, response)
+        else:
+            logger.error("事件 napcat_set_self_longnick 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+
+class GetLoginInfoHandler(BaseEventHandler):
+    handler_name: str = "napcat_get_login_info_handler"
+    handler_description: str = "获取登录号信息"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.ACCOUNT.GET_LOGIN_INFO]
+
+    async def execute(self, params: dict):
+        payload = {}
+        response = await send_handler.send_message_to_napcat(action="get_login_info", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_get_login_info 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+
+class GetRecentContactHandler(BaseEventHandler):
+    handler_name: str = "napcat_get_recent_contact_handler"
+    handler_description: str = "最近消息列表"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.ACCOUNT.GET_RECENT_CONTACT]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        count = params.get("count", 20)
+
+        if params.get("raw", ""):
+            count = raw.get("count", 20)
+
+        payload = {
+            "count": count
+        }
+        response = await send_handler.send_message_to_napcat(action="get_recent_contact", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_get_recent_contact 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+
+class GetStrangerInfoHandler(BaseEventHandler):
+    handler_name: str = "napcat_get_stranger_info_handler"
+    handler_description: str = "获取(指定)账号信息"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.ACCOUNT.GET_STRANGER_INFO]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        user_id = params.get("user_id", "")
+
+        if params.get("raw", ""):
+            user_id = raw.get("user_id", "")
+
+        if not user_id:
+            logger.error("事件 napcat_get_stranger_info 缺少必要参数: user_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "user_id": str(user_id)
+        }
+        response = await send_handler.send_message_to_napcat(action="get_stranger_info", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_get_stranger_info 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+
+class GetFriendListHandler(BaseEventHandler):
+    handler_name: str = "napcat_get_friend_list_handler"
+    handler_description: str = "获取好友列表"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.ACCOUNT.GET_FRIEND_LIST]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        no_cache = params.get("no_cache", False)
+
+        if params.get("raw", ""):
+            no_cache = raw.get("no_cache", False)
+
+        payload = {
+            "no_cache": no_cache
+        }
+        response = await send_handler.send_message_to_napcat(action="get_friend_list", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_get_friend_list 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+
+class GetProfileLikeHandler(BaseEventHandler):
+    handler_name: str = "napcat_get_profile_like_handler"
+    handler_description: str = "获取点赞列表"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.ACCOUNT.GET_PROFILE_LIKE]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        user_id = params.get("user_id", "")
+        start = params.get("start", 0)
+        count = params.get("count", 10)
+
+        if params.get("raw", ""):
+            user_id = raw.get("user_id", "")
+            start = raw.get("start", 0)
+            count = raw.get("count", 10)
+
+        payload = {
+            "start": start,
+            "count": count
+        }
+        if user_id:
+            payload["user_id"] = str(user_id)
+
+        response = await send_handler.send_message_to_napcat(action="get_profile_like", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_get_profile_like 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+
+class DeleteFriendHandler(BaseEventHandler):
+    handler_name: str = "napcat_delete_friend_handler"
+    handler_description: str = "删除好友"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.ACCOUNT.DELETE_FRIEND]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        user_id = params.get("user_id", "")
+        temp_block = params.get("temp_block", False)
+        temp_both_del = params.get("temp_both_del", False)
+
+        if params.get("raw", ""):
+            user_id = raw.get("user_id", "")
+            temp_block = raw.get("temp_block", False)
+            temp_both_del = raw.get("temp_both_del", False)
+
+        if not user_id or temp_block is None or temp_both_del is None:
+            logger.error("事件 napcat_delete_friend 缺少必要参数")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "user_id": str(user_id),
+            "temp_block": temp_block,
+            "temp_both_del": temp_both_del
+        }
+        response = await send_handler.send_message_to_napcat(action="delete_friend", params=payload)
+        if response.get("status", "") == "ok":
+            if response.get("data", {}).get("result", "") == 0:
+                return HandlerResult(True, True, response)
+            else:
+                logger.error(f"事件 napcat_delete_friend 请求失败！err={response.get('data', {}).get('errMsg', '')}")
+                return HandlerResult(False, False, response)
+        else:
+            logger.error("事件 napcat_delete_friend 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+
+class GetUserStatusHandler(BaseEventHandler):
+    handler_name: str = "napcat_get_user_status_handler"
+    handler_description: str = "获取(指定)用户状态"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.ACCOUNT.GET_USER_STATUS]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        user_id = params.get("user_id", "")
+
+        if params.get("raw", ""):
+            user_id = raw.get("user_id", "")
+
+        if not user_id:
+            logger.error("事件 napcat_get_user_status 缺少必要参数: user_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "user_id": str(user_id)
+        }
+        response = await send_handler.send_message_to_napcat(action="get_user_status", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_get_user_status 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+
+class GetStatusHandler(BaseEventHandler):
+    handler_name: str = "napcat_get_status_handler"
+    handler_description: str = "获取状态"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.ACCOUNT.GET_STATUS]
+
+    async def execute(self, params: dict):
+        payload = {}
+        response = await send_handler.send_message_to_napcat(action="get_status", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_get_status 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+
+class GetMiniAppArkHandler(BaseEventHandler):
+    handler_name: str = "napcat_get_mini_app_ark_handler"
+    handler_description: str = "获取小程序卡片"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.ACCOUNT.GET_MINI_APP_ARK]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        type = params.get("type", "")
+        title = params.get("title", "")
+        desc = params.get("desc", "")
+        picUrl = params.get("picUrl", "")
+        jumpUrl = params.get("jumpUrl", "")
+        webUrl = params.get("webUrl", "")
+        rawArkData = params.get("rawArkData", False)
+
+        if params.get("raw", ""):
+            type = raw.get("type", "")
+            title = raw.get("title", "")
+            desc = raw.get("desc", "")
+            picUrl = raw.get("picUrl", "")
+            jumpUrl = raw.get("jumpUrl", "")
+            webUrl = raw.get("webUrl", "")
+            rawArkData = raw.get("rawArkData", False)
+
+        if not type or not title or not desc or not picUrl or not jumpUrl:
+            logger.error("事件 napcat_get_mini_app_ark 缺少必要参数")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "type": type,
+            "title": title,
+            "desc": desc,
+            "picUrl": picUrl,
+            "jumpUrl": jumpUrl,
+            "webUrl": webUrl,
+            "rawArkData": rawArkData
+        }
+        response = await send_handler.send_message_to_napcat(action="get_mini_app_ark", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_get_mini_app_ark 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})
+
+
+class SetDiyOnlineStatusHandler(BaseEventHandler):
+    handler_name: str = "napcat_set_diy_online_status_handler"
+    handler_description: str = "设置自定义在线状态"
+    weight: int = 100
+    intercept_message: bool = False
+    init_subscribe = [NapcatEvent.ACCOUNT.SET_DIY_ONLINE_STATUS]
+
+    async def execute(self, params: dict):
+        raw = params.get("raw", {})
+        face_id = params.get("face_id", "")
+        face_type = params.get("face_type", "0")
+        wording = params.get("wording", "")
+
+        if params.get("raw", ""):
+            face_id = raw.get("face_id", "")
+            face_type = raw.get("face_type", "0")
+            wording = raw.get("wording", "")
+
+        if not face_id:
+            logger.error("事件 napcat_set_diy_online_status 缺少必要参数: face_id")
+            return HandlerResult(False, False, {"status": "error"})
+
+        payload = {
+            "face_id": str(face_id),
+            "face_type": str(face_type),
+            "wording": wording
+        }
+        response = await send_handler.send_message_to_napcat(action="set_diy_online_status", params=payload)
+        if response.get("status", "") == "ok":
+            return HandlerResult(True, True, response)
+        else:
+            logger.error("事件 napcat_set_diy_online_status 请求失败！")
+            return HandlerResult(False, False, {"status": "error"})

plugins/napcat_adapter_plugin/event_types.py

@@ -43,7 +43,7 @@ class NapcatEvent(Enum):
         Args:
             nickname (Optional[str]): 名称(必须)
             personal_note (Optional[str]): 个性签名
-            sex (Optional['0'|'1'|'2']): 性别
+            sex ('0'|'1'|'2'): 性别
             raw (Optional[dict]): 原始请求体
 
         Returns:
@@ -61,38 +61,504 @@ class NapcatEvent(Enum):
 
         '''
         GET_ONLINE_CLIENTS = "napcat_get_online_clients"    
-        '''获取当前账号在线客户端列表'''
+        '''获取当前账号在线客户端列表
+        
+        Args:
+            no_cache (Optional[bool]):  是否不使用缓存
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": [
+                "string"
+            ],
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         SET_ONLINE_STATUS = "napcat_set_online_status" 
-        '''设置在线状态'''
+        '''设置在线状态
+        
+        Args:
+            status (Optional[str]): 状态代码(必须)
+            ext_status (Optional[str]): 额外状态代码,默认为0
+            battery_status (Optional[str]): 电池信息,默认为0
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": null,
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         GET_FRIENDS_WITH_CATEGORY = "napcat_get_friends_with_category" 
-        '''获取好友分组列表'''
+        '''获取好友分组列表
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": [
+                {
+                    "categoryId": 0,
+                    "categorySortId": 0,
+                    "categoryName": "string",
+                    "categoryMbCount": 0,
+                    "onlineCount": 0,
+                    "buddyList": [
+                        {
+                            "birthday_year": 0,
+                            "birthday_month": 0,
+                            "birthday_day": 0,
+                            "user_id": 0,
+                            "age": 0,
+                            "phone_num": "string",
+                            "email": "string",
+                            "category_id": 0,
+                            "nickname": "string",
+                            "remark": "string",
+                            "sex": "string",
+                            "level": 0
+                        }
+                    ]
+                }
+            ],
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         SET_AVATAR = "napcat_set_qq_avatar" 
-        '''设置头像'''
+        '''设置头像
-        SEND_LIKE = "napcat_send_like"  '''点赞'''
+        
+        Args:
+            file (Optional[str]): 文件路径或base64(必需)
+            raw (Optional[dict]): 原始请求体
+
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": null,
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
+        SEND_LIKE = "napcat_send_like"  
+        '''点赞
+        
+        Args:
+            user_id (Optional[str|int]): 用户id(必需)
+            times (Optional[int]): 点赞次数,默认1
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": null,
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         SET_FRIEND_ADD_REQUEST = "napcat_set_friend_add_request"    
-        '''处理好友请求'''
+        '''处理好友请求
+        
+        Args:
+            flag (Optional[str]): 请求id(必需)
+            approve (Optional[bool]): 是否同意(必需)
+            remark (Optional[str]): 好友备注(必需)
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": null,
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         SET_SELF_LONGNICK = "napcat_set_self_longnick"  
-        '''设置个性签名'''
+        '''设置个性签名
+        
+        Args:
+            longNick (Optional[str]): 内容(必需)
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": {
+                "result": 0,
+                "errMsg": "string"
+            },
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         GET_LOGIN_INFO = "napcat_get_login_info"  
-        '''获取登录号信息'''
+        '''获取登录号信息
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": {
+                "user_id": 0,
+                "nickname": "string"
+            },
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         GET_RECENT_CONTACT = "napcat_get_recent_contact"    
-        '''最近消息列表'''
+        '''最近消息列表
+
+        Args:
+            count (Optional[int]): 会话数量
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": [
+                {
+                    "lastestMsg": {
+                        "self_id": 0,
+                        "user_id": 0,
+                        "time": 0,
+                        "real_seq": "string",
+                        "message_type": "string",
+                        "sender": {
+                            "user_id": 0,
+                            "nickname": "string",
+                            "sex": "male",
+                            "age": 0,
+                            "card": "string",
+                            "role": "owner"
+                        },
+                        "raw_message": "string",
+                        "font": 0,
+                        "sub_type": "string",
+                        "message": [
+                            {
+                                "type": "text",
+                                "data": {
+                                    "text": "string"
+                                }
+                            }
+                        ],
+                        "message_format": "string",
+                        "post_type": "string",
+                        "group_id": 0
+                    },
+                    "peerUin": "string",
+                    "remark": "string",
+                    "msgTime": "string",
+                    "chatType": 0,
+                    "msgId": "string",
+                    "sendNickName": "string",
+                    "sendMemberName": "string",
+                    "peerName": "string"
+                }
+            ],
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         GET_STRANGER_INFO = "napcat_get_stranger_info"  
-        '''获取(指定)账号信息'''
+        '''获取(指定)账号信息
+        
+        Args:
+            user_id (Optional[str|int]): 用户id(必需)
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": {
+                "user_id": 0,
+                "uid": "string",
+                "uin": "string",
+                "nickname": "string",
+                "age": 0,
+                "qid": "string",
+                "qqLevel": 0,
+                "sex": "string",
+                "long_nick": "string",
+                "reg_time": 0,
+                "is_vip": true,
+                "is_years_vip": true,
+                "vip_level": 0,
+                "remark": "string",
+                "status": 0,
+                "login_days": 0
+            },
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         GET_FRIEND_LIST = "napcat_get_friend_list"  
-        '''获取好友列表'''
+        '''获取好友列表
+        
+        Args:
+            no_cache (Opetional[bool]): 是否不使用缓存
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": [
+                {
+                    "birthday_year": 0,
+                    "birthday_month": 0,
+                    "birthday_day": 0,
+                    "user_id": 0,
+                    "age": 0,
+                    "phone_num": "string",
+                    "email": "string",
+                    "category_id": 0,
+                    "nickname": "string",
+                    "remark": "string",
+                    "sex": "string",
+                    "level": 0
+                }
+            ],
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         GET_PROFILE_LIKE = "napcat_get_profile_like"    
-        '''获取点赞列表'''
+        '''获取点赞列表
+        
+        Args:
+            user_id (Opetional[str|int]): 用户id,指定用户,不填为获取所有
+            start (Opetional[int]): 起始值
+            count (Opetional[int]): 返回数量
+            raw (Optional[dict]): 原始请求体
+
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": {
+                "uid": "string",
+                "time": 0,
+                "favoriteInfo": {
+                    "total_count": 0,
+                    "last_time": 0,
+                    "today_count": 0,
+                    "userInfos": [
+                        {
+                            "uid": "string",
+                            "src": 0,
+                            "latestTime": 0,
+                            "count": 0,
+                            "giftCount": 0,
+                            "customId": 0,
+                            "lastCharged": 0,
+                            "bAvailableCnt": 0,
+                            "bTodayVotedCnt": 0,
+                            "nick": "string",
+                            "gender": 0,
+                            "age": 0,
+                            "isFriend": true,
+                            "isvip": true,
+                            "isSvip": true,
+                            "uin": 0
+                        }
+                    ]
+                },
+                "voteInfo": {
+                    "total_count": 0,
+                    "new_count": 0,
+                    "new_nearby_count": 0,
+                    "last_visit_time": 0,
+                    "userInfos": [
+                        {
+                            "uid": "string",
+                            "src": 0,
+                            "latestTime": 0,
+                            "count": 0,
+                            "giftCount": 0,
+                            "customId": 0,
+                            "lastCharged": 0,
+                            "bAvailableCnt": 0,
+                            "bTodayVotedCnt": 0,
+                            "nick": "string",
+                            "gender": 0,
+                            "age": 0,
+                            "isFriend": true,
+                            "isvip": true,
+                            "isSvip": true,
+                            "uin": 0
+                        }
+                    ]
+                }
+            },
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         DELETE_FRIEND = "napcat_delete_friend"  
-        '''删除好友'''
+        '''删除好友
+        
+        Args:
+            user_id (Opetional[str|int]): 用户id(必需)
+            temp_block (Opetional[bool]): 拉黑(必需)
+            temp_both_del (Opetional[bool]): 双向删除(必需)
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": {
+                "result": 0,
+                "errMsg": "string"
+            },
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         GET_USER_STATUS = "napcat_get_user_status"  
-        '''获取用户状态'''
+        '''获取(指定)用户状态
+        
+        Args:
+            user_id (Opetional[str|int]): 用户id(必需)
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": {
+                "status": 0,
+                "ext_status": 0
+            },
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         GET_STATUS = "napcat_get_status"    
-        '''获取状态'''
+        '''获取状态
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": {
+                "online": true,
+                "good": true,
+                "stat": {}
+            },
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         GET_MINI_APP_ARK = "napcat_get_mini_app_ark"    
-        '''获取小程序卡片'''
+        '''获取小程序卡片
+        
+        Args:
+            type (Optional[str]): 类型(如bili、weibo,必需)
+            title (Optional[str]): 标题(必需)
+            desc (Optional[str]): 描述(必需)
+            picUrl (Optional[str]): 图片URL(必需)
+            jumpUrl (Optional[str]): 跳转URL(必需)
+            webUrl (Optional[str]): 网页URL
+            rawArkData (Optional[bool]): 是否返回原始ark数据
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": {
+                "appName": "string",
+                "appView": "string",
+                "ver": "string",
+                "desc": "string",
+                "prompt": "string",
+                "metaData": {
+                    "detail_1": {
+                        "appid": "string",
+                        "appType": 0,
+                        "title": "string",
+                        "desc": "string",
+                        "icon": "string",
+                        "preview": "string",
+                        "url": "string",
+                        "scene": 0,
+                        "host": {
+                            "uin": 0,
+                            "nick": "string"
+                        },
+                        "shareTemplateId": "string",
+                        "shareTemplateData": {},
+                        "showLittleTail": "string",
+                        "gamePoints": "string",
+                        "gamePointsUrl": "string",
+                        "shareOrigin": 0
+                    }
+                },
+                "config": {
+                    "type": "string",
+                    "width": 0,
+                    "height": 0,
+                    "forward": 0,
+                    "autoSize": 0,
+                    "ctime": 0,
+                    "token": "string"
+                }
+            },
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
         SET_DIY_ONLINE_STATUS = "napcat_set_diy_online_status"  
-        '''设置自定义在线状态'''
+        '''设置自定义在线状态
+        
+        Args:
+            face_id (Optional[str|int]): 表情ID(必需)
+            face_type (Optional[str|int]): 表情类型
+            wording (Optional[str]):描述文本
+            raw (Optional[dict]): 原始请求体
+        
+        Returns:
+            dict: {
+            "status": "ok",
+            "retcode": 0,
+            "data": "string",
+            "message": "string",
+            "wording": "string",
+            "echo": "string"
+        }
+        '''
     
     class MESSAGE(Enum):
         """

plugins/napcat_adapter_plugin/plugin.py

@@ -148,7 +148,6 @@ class NapcatAdapterPlugin(BasePlugin):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        
         for e in event_types.NapcatEvent.ON_RECEIVED:
             event_manager.register_event(e ,allowed_triggers=[self.plugin_name])
         

src/plugin_system/base/base_event.py

@@ -9,7 +9,7 @@ class HandlerResult:
     
     所有事件处理器必须返回此类的实例
     """
-    def __init__(self, success: bool, continue_process: bool, message: Any = {}, handler_name: str = ""):
+    def __init__(self, success: bool, continue_process: bool, message: Any = None, handler_name: str = ""):
         self.success = success
         self.continue_process = continue_process
         self.message = message
@@ -83,8 +83,8 @@ class BaseEvent:
     def __init__(
             self, 
             name: str, 
-            allowed_subscribers: List[str]=[],  
+            allowed_subscribers: List[str] = None,
-            allowed_triggers: List[str]=[]
+            allowed_triggers: List[str] = None
         ):
         self.name = name
         self.enabled = True