ErisPulse-QQBotAdapter 1.0.0__tar.gz → 4.0.0__tar.gz

{erispulse_qqbotadapter-1.0.0 → erispulse_qqbotadapter-4.0.0}/ErisPulse_QQBotAdapter.egg-info/PKG-INFO

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: ErisPulse-QQBotAdapter
-Version: 1.0.0
+Version: 4.0.0
 Summary: ErisPulse的QQ官方机器人适配模块
 Author-email: wsu2059 <wsu2059@qq.com>
 Project-URL: homepage, https://github.com/ErisPulse/ErisPulse-QQBotAdapter
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: aiohttp>=3.8.0
 
 # QQBotAdapter 模块文档
 

{erispulse_qqbotadapter-1.0.0 → erispulse_qqbotadapter-4.0.0}/ErisPulse_QQBotAdapter.egg-info/SOURCES.txt

@@ -4,7 +4,6 @@ ErisPulse_QQBotAdapter.egg-info/PKG-INFO
 ErisPulse_QQBotAdapter.egg-info/SOURCES.txt
 ErisPulse_QQBotAdapter.egg-info/dependency_links.txt
 ErisPulse_QQBotAdapter.egg-info/entry_points.txt
-ErisPulse_QQBotAdapter.egg-info/requires.txt
 ErisPulse_QQBotAdapter.egg-info/top_level.txt
 QQBotAdapter/Converter.py
 QQBotAdapter/Core.py

{erispulse_qqbotadapter-1.0.0 → erispulse_qqbotadapter-4.0.0}/PKG-INFO

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: ErisPulse-QQBotAdapter
-Version: 1.0.0
+Version: 4.0.0
 Summary: ErisPulse的QQ官方机器人适配模块
 Author-email: wsu2059 <wsu2059@qq.com>
 Project-URL: homepage, https://github.com/ErisPulse/ErisPulse-QQBotAdapter
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: aiohttp>=3.8.0
 
 # QQBotAdapter 模块文档
 

{erispulse_qqbotadapter-1.0.0 → erispulse_qqbotadapter-4.0.0}/QQBotAdapter/Core.py

@@ -1,21 +1,89 @@
 import asyncio
-import aiohttp
 import json
-import uuid
-from typing import Dict, List, Any, Optional
+import time as _time
+from dataclasses import dataclass, field
+from typing import Dict, Any, Optional
+
 from ErisPulse import sdk
-from ErisPulse.Core import router
+from ErisPulse.Core import client
+from ErisPulse.runtime.config_schema import BotAccountConfig
+
 from .Converter import QQBotConverter
 from .WebSocket import QQBotWebSocket
 
 
+@dataclass
+class QQBotConfig(BotAccountConfig):
+    """QQBot 账户配置"""
+
+    appid: str = field(
+        default="",
+        metadata={
+            "description": "QQ机器人应用ID",
+            "required": True,
+            "webui": {"widget": "text", "group": "basic", "order": 1},
+        },
+    )
+    secret: str = field(
+        default="",
+        metadata={
+            "description": "QQ机器人客户端密钥",
+            "required": True,
+            "secret": True,
+            "webui": {"widget": "password", "group": "basic", "order": 2},
+        },
+    )
+    sandbox: bool = field(
+        default=False,
+        metadata={
+            "description": "是否使用沙盒环境",
+            "webui": {"widget": "switch", "group": "connection", "order": 3},
+        },
+    )
+
+
+@dataclass
+class QQBotAdapterConfig:
+    """QQBot 适配器全局配置"""
+
+    intents: str = field(
+        default="[1, 30, 25]",
+        metadata={
+            "description": "订阅的 intents 位列表（JSON格式）",
+            "webui": {"widget": "text", "group": "connection", "order": 1},
+        },
+    )
+    gateway_url: str = field(
+        default="wss://api.sgroup.qq.com/websocket/",
+        metadata={
+            "description": "WebSocket 网关地址",
+            "webui": {"widget": "text", "group": "connection", "order": 2},
+        },
+    )
+
+
 class QQBotAdapter(sdk.BaseAdapter):
+    """
+    QQ官方机器人适配器
+
+    通过 WebSocket 长连接接收事件，整合群聊、私聊、频道等多种场景
+    """
+
+    _platform = "qqbot"
+    AccountConfigClass = QQBotConfig
+    ConfigClass = QQBotAdapterConfig
+
     class Send(sdk.BaseAdapter.Send):
+
         def __init__(self, adapter, target_type=None, target_id=None, account_id=None):
             super().__init__(adapter, target_type, target_id, account_id)
-            self._at_user_ids = []
-            self._at_all = False
-            self._reply_message_id = None
+            self._keyboard = None
+
+        def Keyboard(self, keyboard: dict):
+            self._keyboard = keyboard
+            return self
+
+        def _reset_modifiers(self):
             self._keyboard = None
 
         def Text(self, text: str):
@@ -24,6 +92,18 @@ class QQBotAdapter(sdk.BaseAdapter):
         def Image(self, file: bytes | str):
             return self.Raw_ob12([{"type": "image", "data": {"file": file}}])
 
+        def Audio(self, file: bytes | str):
+            return self.Raw_ob12([{"type": "audio", "data": {"file": file}}])
+
+        def Voice(self, file: bytes | str):
+            return self.Audio(file)
+
+        def Video(self, file: bytes | str):
+            return self.Raw_ob12([{"type": "video", "data": {"file": file}}])
+
+        def File(self, file: bytes | str):
+            return self.Raw_ob12([{"type": "file", "data": {"file": file}}])
+
         def Markdown(self, content: str):
             return self.Raw_ob12([{"type": "markdown", "data": {"content": content}}])
 
@@ -33,32 +113,10 @@ class QQBotAdapter(sdk.BaseAdapter):
         def Embed(self, embed_data: dict):
             return self.Raw_ob12([{"type": "embed", "data": embed_data}])
 
-        def Keyboard(self, keyboard: dict):
-            self._keyboard = keyboard
-            return self
-
-        def Reply(self, message_id: str) -> "Send":
-            self._reply_message_id = message_id
-            return self
-
-        def At(self, user_id: str) -> "Send":
-            self._at_user_ids.append(user_id)
-            return self
-
-        def AtAll(self) -> "Send":
-            self._at_all = True
-            return self
-
-        def _reset_modifiers(self):
-            self._at_user_ids = []
-            self._at_all = False
-            self._reply_message_id = None
-            self._keyboard = None
-
-        def Raw_ob12(self, message: List[Dict], **kwargs):
+        def Raw_ob12(self, message, **kwargs):
             return asyncio.create_task(self._do_send_raw_ob12(message, **kwargs))
 
-        async def _do_send_raw_ob12(self, message: List[Dict], **kwargs):
+        async def _do_send_raw_ob12(self, message, **kwargs):
             text_parts = []
             media_info = None
             msg_type = 0
@@ -98,6 +156,12 @@ class QQBotAdapter(sdk.BaseAdapter):
                         media_info = await self._adapter._upload_media(file, self._target_type, self._target_id, 4)
                     if media_info:
                         msg_type = 7
+                elif seg_type == "audio":
+                    file = data.get("file", data.get("url", ""))
+                    if isinstance(file, (bytes, str)) and file:
+                        media_info = await self._adapter._upload_media(file, self._target_type, self._target_id, 3)
+                    if media_info:
+                        msg_type = 7
                 elif seg_type == "markdown":
                     msg_type = 2
                     markdown_data = data
@@ -107,6 +171,10 @@ class QQBotAdapter(sdk.BaseAdapter):
                 elif seg_type == "embed":
                     msg_type = 4
                     embed_data = data
+                elif seg_type == "mention":
+                    uid = data.get("user_id", "")
+                    if uid:
+                        text_parts.append(f"<@{uid}>")
 
             for uid in self._at_user_ids:
                 text_parts.append(f"<@{uid}>")
@@ -134,14 +202,7 @@ class QQBotAdapter(sdk.BaseAdapter):
             endpoint = self._get_send_endpoint()
             if not endpoint:
                 self._reset_modifiers()
-                return {
-                    "status": "failed",
-                    "retcode": 10003,
-                    "data": None,
-                    "message_id": "",
-                    "message": "无法确定发送目标",
-                    "qqbot_raw": None,
-                }
+                return self._adapter.make_error(retcode=10003, message="无法确定发送目标")
 
             self._reset_modifiers()
             return await self._adapter.call_api(endpoint=endpoint, **params)
@@ -157,77 +218,153 @@ class QQBotAdapter(sdk.BaseAdapter):
                 return f"/dms/{self._target_id}/messages"
             return None
 
-    def __init__(self, sdk):
-        super().__init__()
-        self.sdk = sdk
-        self.logger = sdk.logger
-        self.config = self._load_config()
-        self.appid = self.config.get("appid", "")
-        self.secret = self.config.get("secret", "")
+    def _get_config_key(self) -> str:
+        return "QQBot_Adapter"
+
+    def _load_accounts(self) -> dict:
+        from ErisPulse.runtime.config_schema import dict_to_dataclass
+        from ErisPulse.Core.config import config as config_mgr
+
+        key = f"{self._get_config_key()}.accounts"
+        data = config_mgr.getConfig(key)
+
+        if not data:
+            old_config = config_mgr.getConfig(self._get_config_key())
+            if old_config:
+                self.logger.info("检测到旧格式配置，迁移到新格式")
+                data = {
+                    "default": {
+                        "appid": old_config.get("appid", ""),
+                        "secret": old_config.get("secret", ""),
+                        "sandbox": old_config.get("sandbox", False),
+                        "enabled": True,
+                    }
+                }
+                try:
+                    config_mgr.setConfig(key, data)
+                except Exception as e:
+                    self.logger.error(f"保存迁移配置失败: {e}")
+            else:
+                self.logger.info("未找到配置，创建默认配置模板")
+                data = {
+                    "default": {
+                        "appid": "YOUR_APPID",
+                        "secret": "YOUR_CLIENT_SECRET",
+                        "sandbox": False,
+                        "enabled": True,
+                    }
+                }
+                try:
+                    config_mgr.setConfig(key, data)
+                    self.logger.warning("QQBot适配器配置不存在，已自动创建默认配置")
+                except Exception as e:
+                    self.logger.error(f"保存默认配置失败: {e}")
+
+        accounts = {}
+        for name, account_data in data.items():
+            if not isinstance(account_data, dict):
+                continue
+
+            appid = account_data.get("appid", "")
+            secret = account_data.get("secret", "")
+
+            if appid in ("YOUR_APPID", "") and secret in ("YOUR_CLIENT_SECRET", ""):
+                self.logger.warning(f"跳过模板账户: {name}")
+                continue
+
+            instance = dict_to_dataclass(QQBotConfig, account_data)
+            instance.name = name
+            accounts[name] = instance
+
+        return accounts
+
+    def __init__(self, sdk_instance=None):
+        super().__init__(sdk_instance)
+
+        self.adapter = sdk.adapter
         self._access_token = None
         self._token_expires = 0
         self.bot_id = ""
-        self.session: Optional[aiohttp.ClientSession] = None
         self.ws_client: Optional[QQBotWebSocket] = None
         self._heartbeat_meta_task: Optional[asyncio.Task] = None
         self._pending_msg_ids: Dict[str, str] = {}
 
+        self._active_account_name = None
+        self._active_account = None
+
         converter = QQBotConverter(bot_id_getter=lambda: self.bot_id)
         self.convert = converter.convert
 
-    def _load_config(self):
-        config = self.sdk.config.getConfig("QQBot_Adapter")
-        if not config:
-            default_config = {
-                "appid": "YOUR_APPID",
-                "secret": "YOUR_CLIENT_SECRET",
-                "sandbox": False,
-                "intents": [1, 30, 25],
+    def _get_active_config(self) -> dict:
+        if self._active_account:
+            return {
+                "appid": self._active_account.appid,
+                "secret": self._active_account.secret,
+                "sandbox": self._active_account.sandbox,
             }
-            try:
-                self.sdk.config.setConfig("QQBot_Adapter", default_config)
-                self.logger.warning("QQBot适配器配置不存在，已自动创建默认配置")
-            except Exception as e:
-                self.logger.error(f"保存默认配置失败: {e}")
-            return default_config
-        return config
+        return {}
+
+    @property
+    def config(self):
+        return self._get_active_config()
+
+    @config.setter
+    def config(self, value):
+        pass
 
     def _get_base_url(self) -> str:
-        if self.config.get("sandbox", False):
+        sandbox = self._active_account.sandbox if self._active_account else False
+        if sandbox:
             return "https://sandbox.api.sgroup.qq.com"
         return "https://api.sgroup.qq.com"
 
     def _get_intents_value(self) -> int:
-        intents = self.config.get("intents", [1, 30, 25])
+        adapter_config = self._config_instance
+        if adapter_config:
+            import json as _json
+            try:
+                intents = _json.loads(adapter_config.intents)
+            except Exception:
+                intents = [1, 30, 25]
+        else:
+            intents = [1, 30, 25]
+
         value = 0
         for intent in intents:
             value |= (1 << intent)
         return value
 
+    def _get_gateway_url(self) -> str:
+        adapter_config = self._config_instance
+        if adapter_config and adapter_config.gateway_url:
+            return adapter_config.gateway_url
+        return "wss://api.sgroup.qq.com/websocket/"
+
     async def _ensure_token(self) -> str:
-        import time as _time
         if self._access_token and _time.time() < self._token_expires - 120:
             return self._access_token
         await self._refresh_token()
         return self._access_token
 
     async def _refresh_token(self):
-        import time as _time
         url = "https://bots.qq.com/app/getAppAccessToken"
-        payload = {"appId": self.appid, "clientSecret": self.secret}
+        payload = {
+            "appId": self._active_account.appid,
+            "clientSecret": self._active_account.secret,
+        }
         try:
-            async with self.session.post(url, json=payload) as resp:
-                data = await resp.json()
-                self._access_token = data.get("access_token", "")
-                expires_in = int(data.get("expires_in", 7200))
-                self._token_expires = _time.time() + expires_in
-                self.logger.debug("Access Token 已获取/刷新")
+            resp = await client.post(url, json=payload)
+            data = await resp.json()
+            self._access_token = data.get("access_token", "")
+            expires_in = int(data.get("expires_in", 7200))
+            self._token_expires = _time.time() + expires_in
+            self.logger.debug("Access Token 已获取/刷新")
         except Exception as e:
             self.logger.error(f"获取 Access Token 失败: {e}")
             raise
 
     async def _upload_media(self, file, target_type: str, target_id: str, file_type: int) -> Optional[str]:
-        url = f"{self._get_base_url()}"
+        url = self._get_base_url()
         if target_type == "user":
             url += f"/v2/users/{target_id}/files"
         elif target_type == "group":
@@ -261,73 +398,60 @@ class QQBotAdapter(sdk.BaseAdapter):
                 return None
 
         try:
-            async with self.session.post(url, json=payload, headers=headers) as resp:
-                data = await resp.json()
-                self.logger.debug(f"上传媒体响应: {data}")
-                file_info = data.get("file_info", "")
-                if not file_info:
-                    self.logger.error(f"上传媒体失败: {data}")
-                    return None
-                return file_info
+            resp = await client.post(url, json=payload, headers=headers)
+            data = await resp.json()
+            self.logger.debug(f"上传媒体响应: {data}")
+            file_info = data.get("file_info", "")
+            if not file_info:
+                self.logger.error(f"上传媒体失败: {data}")
+                return None
+            return file_info
         except Exception as e:
             self.logger.error(f"上传媒体异常: {e}")
             return None
 
-    async def call_api(self, endpoint: str, **params):
+    async def call_api(self, endpoint: str, _account_id: str = None, **params):
         token = await self._ensure_token()
         url = f"{self._get_base_url()}{endpoint}"
         headers = {"Authorization": f"QQBot {token}", "Content-Type": "application/json"}
 
         try:
-            async with self.session.post(url, json=params, headers=headers) as resp:
-                raw_response = await resp.json()
-
-                self.logger.debug(f"QQBot API 请求: {url}")
-                self.logger.debug(f"QQBot API 响应: {raw_response}")
-
-                if not isinstance(raw_response, dict):
-                    return {
-                        "status": "failed",
-                        "retcode": 34000,
-                        "data": None,
-                        "message_id": "",
-                        "message": f"API 返回了意外格式: {type(raw_response)}",
-                        "qqbot_raw": raw_response,
-                    }
-
-                code = raw_response.get("code", 0)
-                success = 200 <= resp.status < 300 and code == 0
-                msg_id = raw_response.get("id", raw_response.get("data", {}).get("id", ""))
-
-                return {
-                    "status": "ok" if success else "failed",
-                    "retcode": 0 if success else code or 34000,
-                    "data": raw_response.get("data", raw_response),
-                    "message_id": str(msg_id) if msg_id else "",
-                    "message": "" if success else raw_response.get("message", "Unknown QQBot API error"),
-                    "qqbot_raw": raw_response,
-                }
+            resp = await client.post(url, json=params, headers=headers)
+            raw_response = await resp.json()
+
+            self.logger.debug(f"QQBot API 请求: {url}")
+            self.logger.debug(f"QQBot API 响应: {raw_response}")
+
+            if not isinstance(raw_response, dict):
+                return self.make_error(
+                    retcode=34000,
+                    message=f"API 返回了意外格式: {type(raw_response)}",
+                    raw=raw_response,
+                )
+
+            code = raw_response.get("code", 0)
+            success = 200 <= resp.status < 300 and code == 0
+            msg_id = raw_response.get("id", raw_response.get("data", {}).get("id", ""))
+
+            if success:
+                return self.make_response(
+                    data=raw_response.get("data", raw_response),
+                    message_id=str(msg_id) if msg_id else "",
+                    raw=raw_response,
+                )
+            else:
+                return self.make_error(
+                    retcode=code or 34000,
+                    message=raw_response.get("message", "Unknown QQBot API error"),
+                    raw=raw_response,
+                )
 
         except asyncio.TimeoutError:
             self.logger.error(f"QQBot API 请求超时: {endpoint}")
-            return {
-                "status": "failed",
-                "retcode": 32000,
-                "data": None,
-                "message_id": "",
-                "message": "请求超时",
-                "qqbot_raw": None,
-            }
+            return self.make_error(retcode=32000, message="请求超时")
         except Exception as e:
             self.logger.error(f"调用 QQBot API 失败: {e}")
-            return {
-                "status": "failed",
-                "retcode": 33000,
-                "data": None,
-                "message_id": "",
-                "message": f"API调用失败: {str(e)}",
-                "qqbot_raw": None,
-            }
+            return self.make_error(retcode=33000, message=f"API调用失败: {str(e)}")
 
     def _store_event_msg_id(self, event: Dict):
         if event.get("type") != "message":
@@ -348,37 +472,31 @@ class QQBotAdapter(sdk.BaseAdapter):
                 self._pending_msg_ids[f"channel:{channel_id}"] = msg_id
 
     async def _on_connect(self):
-        await self.sdk.adapter.emit({
-            "type": "meta",
-            "detail_type": "connect",
-            "platform": "qqbot",
-            "self": {"platform": "qqbot", "user_id": self.bot_id},
-        })
-
+        await self.emit_meta("connect", self.bot_id)
         self._heartbeat_meta_task = asyncio.create_task(self._heartbeat_meta_loop())
 
     async def _heartbeat_meta_loop(self):
         try:
             while True:
                 await asyncio.sleep(30)
-                await self.sdk.adapter.emit({
-                    "type": "meta",
-                    "detail_type": "heartbeat",
-                    "platform": "qqbot",
-                    "self": {"platform": "qqbot", "user_id": self.bot_id},
-                })
+                await self.emit_meta("heartbeat", self.bot_id)
         except asyncio.CancelledError:
             pass
 
     async def start(self):
-        self.session = aiohttp.ClientSession()
+        enabled = self.enabled_accounts
+        if not enabled:
+            self.logger.warning("没有找到启用的账户配置")
+            return
+
+        first_name = next(iter(enabled))
+        self._active_account_name = first_name
+        self._active_account = enabled[first_name]
 
         try:
             await self._ensure_token()
         except Exception as e:
             self.logger.error(f"初始化 Token 失败: {e}")
-            if self.session:
-                await self.session.close()
             raise
 
         self.ws_client = QQBotWebSocket(self)
@@ -388,12 +506,7 @@ class QQBotAdapter(sdk.BaseAdapter):
 
     async def shutdown(self):
         if self.bot_id:
-            await self.sdk.adapter.emit({
-                "type": "meta",
-                "detail_type": "disconnect",
-                "platform": "qqbot",
-                "self": {"platform": "qqbot", "user_id": self.bot_id},
-            })
+            await self.emit_meta("disconnect", self.bot_id)
 
         if self._heartbeat_meta_task:
             self._heartbeat_meta_task.cancel()
@@ -407,7 +520,4 @@ class QQBotAdapter(sdk.BaseAdapter):
             await self.ws_client.close()
             self.ws_client = None
 
-        if self.session:
-            await self.session.close()
-            self.session = None
         self.logger.info("QQBot 适配器已关闭")

{erispulse_qqbotadapter-1.0.0 → erispulse_qqbotadapter-4.0.0}/QQBotAdapter/WebSocket.py

@@ -1,9 +1,11 @@
 import asyncio
 import json
 import time
-import aiohttp
 from typing import Optional
 
+from ErisPulse.Core import client
+from ErisPulse.Core.Bases.websocket import WSMessage
+
 
 class QQBotWebSocket:
     OP_HELLO = 10
@@ -17,8 +19,7 @@ class QQBotWebSocket:
 
     def __init__(self, adapter):
         self.adapter = adapter
-        self.session: Optional[aiohttp.ClientSession] = None
-        self.ws: Optional[aiohttp.ClientWebSocketResponse] = None
+        self.ws = None
         self.heartbeat_interval = 45000
         self.heartbeat_task: Optional[asyncio.Task] = None
         self.listen_task: Optional[asyncio.Task] = None
@@ -28,34 +29,38 @@ class QQBotWebSocket:
         self._token_refresh_task: Optional[asyncio.Task] = None
         self._reconnect_count = 0
         self._max_reconnect = 50
+        self._closing = False
 
     async def connect(self):
-        self.session = aiohttp.ClientSession()
         gateway_url = self.adapter.config.get("gateway_url", "wss://api.sgroup.qq.com/websocket/")
         await self._connect(gateway_url)
 
     async def _connect(self, url: str):
         try:
-            self.ws = await self.session.ws_connect(url)
+            self.ws = await client.ws_connect(url)
             self.adapter.logger.info("WebSocket 已连接到 QQBot 网关")
             self._connected = True
 
-            msg = await self.ws.receive_json()
-            if msg.get("op") == self.OP_HELLO:
-                data = msg.get("d", {})
-                self.heartbeat_interval = data.get("heartbeat_interval", 45000)
+            msg = await self.ws.receive()
+            if msg.type == WSMessage.TEXT:
+                data = json.loads(msg.data)
+                if data.get("op") == self.OP_HELLO:
+                    inner = data.get("d", {})
+                    self.heartbeat_interval = inner.get("heartbeat_interval", 45000)
 
-                if self.session_id and self.seq is not None:
-                    await self._resume()
-                else:
-                    await self._identify()
+                    if self.session_id and self.seq is not None:
+                        await self._resume()
+                    else:
+                        await self._identify()
 
-                self.heartbeat_task = asyncio.create_task(self._heartbeat_loop())
-                self.listen_task = asyncio.create_task(self._listen())
+                    self.heartbeat_task = asyncio.create_task(self._heartbeat_loop())
+                    self.listen_task = asyncio.create_task(self._listen())
 
-                self._reconnect_count = 0
+                    self._reconnect_count = 0
+                else:
+                    self.adapter.logger.error(f"未收到 Hello 消息: {data}")
             else:
-                self.adapter.logger.error(f"未收到 Hello 消息: {msg}")
+                self.adapter.logger.error(f"未收到 Hello 消息: {msg.type}")
 
         except Exception as e:
             self.adapter.logger.error(f"WebSocket 连接失败: {e}")
@@ -108,11 +113,12 @@ class QQBotWebSocket:
 
     async def _listen(self):
         try:
-            async for msg in self.ws:
-                if msg.type == aiohttp.WSMsgType.TEXT:
+            while self._connected:
+                msg = await self.ws.receive()
+                if msg.type == WSMessage.TEXT:
                     data = json.loads(msg.data)
                     await self._handle_message(data)
-                elif msg.type in (aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.ERROR):
+                elif msg.type in (WSMessage.CLOSE, WSMessage.ERROR):
                     self.adapter.logger.warning(f"WebSocket 关闭: {msg.type}")
                     break
         except asyncio.CancelledError:
@@ -121,7 +127,7 @@ class QQBotWebSocket:
             self.adapter.logger.error(f"监听异常: {e}")
         finally:
             self._connected = False
-            if not self.listen_task or not self.listen_task.cancelled():
+            if not self._closing and (not self.listen_task or not self.listen_task.cancelled()):
                 await self._reconnect()
 
     async def _handle_message(self, data: dict):
@@ -138,6 +144,8 @@ class QQBotWebSocket:
                 self.session_id = d.get("session_id") if d else None
                 user = d.get("user", {}) if d else {}
                 self.adapter.bot_id = str(user.get("id", ""))
+                if self.adapter._active_account:
+                    self.adapter._active_account.bot_id = self.adapter.bot_id
                 self.adapter.logger.info(f"QQBot 就绪, bot_id: {self.adapter.bot_id}")
                 await self.adapter._on_connect()
             elif t == "RESUMED":
@@ -147,8 +155,7 @@ class QQBotWebSocket:
                     onebot_event = self.adapter.convert(d, t or "")
                     if onebot_event:
                         self.adapter._store_event_msg_id(onebot_event)
-                        from ErisPulse.Core import logger
-                        logger.debug(f"收到事件: {onebot_event}")
+                        self.adapter.logger.debug(f"收到事件: {onebot_event}")
                         await self.adapter.sdk.adapter.emit(onebot_event)
 
         elif op == self.OP_HEARTBEAT_ACK:
@@ -169,6 +176,9 @@ class QQBotWebSocket:
             self.heartbeat_interval = data_inner.get("heartbeat_interval", 45000)
 
     async def _reconnect(self):
+        if self._closing:
+            return
+
         if self.heartbeat_task:
             self.heartbeat_task.cancel()
             try:
@@ -186,6 +196,9 @@ class QQBotWebSocket:
         self.adapter.logger.warning(f"{wait_time}秒后尝试第 {self._reconnect_count} 次重连")
         await asyncio.sleep(wait_time)
 
+        if self._closing:
+            return
+
         try:
             if self.ws and not self.ws.closed:
                 await self.ws.close()
@@ -210,6 +223,7 @@ class QQBotWebSocket:
             self.adapter.logger.error(f"Token 刷新异常: {e}")
 
     async def close(self):
+        self._closing = True
         self._connected = False
 
         if self._token_refresh_task:
@@ -238,8 +252,5 @@ class QQBotWebSocket:
 
         if self.ws and not self.ws.closed:
             await self.ws.close()
-        if self.session:
-            await self.session.close()
-            self.session = None
 
         self.adapter.logger.info("WebSocket 连接已关闭")

{erispulse_qqbotadapter-1.0.0 → erispulse_qqbotadapter-4.0.0}/pyproject.toml

@@ -1,14 +1,12 @@
 [project]
 name = "ErisPulse-QQBotAdapter"
-version = "1.0.0"
+version = "4.0.0"
 description = "ErisPulse的QQ官方机器人适配模块"
 readme = "README.md"
 requires-python = ">=3.10"
 license = { file = "LICENSE" }
 authors = [ { name = "wsu2059", email = "wsu2059@qq.com" } ]
-dependencies = [
-    "aiohttp>=3.8.0"
-]
+dependencies = []
 
 [project.urls]
 "homepage" = "https://github.com/ErisPulse/ErisPulse-QQBotAdapter"
@@ -19,3 +17,7 @@ qq = "QQBotAdapter:QQBotAdapter"
 
 [tool.setuptools.packages.find]
 include = [ "QQBotAdapter" ]
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"

erispulse_qqbotadapter-1.0.0/ErisPulse_QQBotAdapter.egg-info/requires.txt

@@ -1 +0,0 @@
-aiohttp>=3.8.0