@alemonjs/qq-bot 2.1.31 → 2.1.33

package/lib/sdk/client.webhook.js

@@ -3,7 +3,6 @@ import bodyParser from 'koa-bodyparser';
 import Router from 'koa-router';
 import { WebhookAPI } from './webhook.secret.js';
 import Koa from 'koa';
-import { config } from './config.js';
 import { v4 } from 'uuid';
 import { WebSocketServer, WebSocket } from 'ws';
 
@@ -23,10 +22,7 @@ class QQBotClient extends QQBotAPI {
     #client = [];
     #ws = null;
     constructor(opstion) {
-        super();
-        for (const key in opstion) {
-            config.set(key, opstion[key]);
-        }
+        super(opstion);
     }
     on(key, val) {
         if (!this.#events[key]) {
@@ -37,13 +33,13 @@ class QQBotClient extends QQBotAPI {
     }
     async #setTimeoutBotConfig() {
         const callBack = async () => {
-            const app_id = config.get('app_id');
-            const secret = config.get('secret');
+            const app_id = this.config.get('app_id');
+            const secret = this.config.get('secret');
             if (!app_id || !secret) {
                 return;
             }
             const data = await this.getAuthentication();
-            config.set('access_token', data.access_token);
+            this.config.set('access_token', data.access_token);
             console.info('refresh', data.expires_in, 's');
             setTimeout(() => void callBack(), data.expires_in * 1000);
         };
@@ -51,15 +47,16 @@ class QQBotClient extends QQBotAPI {
     }
     connect() {
         try {
-            const ws = config.get('ws');
+            const ws = this.config.get('ws');
+            this.updateConnectionStatus({ state: 'connecting', transport: ws ? 'proxy' : 'webhook' });
             if (!ws) {
                 void this.#setTimeoutBotConfig();
                 this.#app = new Koa();
                 this.#app.use(bodyParser());
                 const router = new Router();
-                const port = config.get('port');
-                const secret = config.get('secret');
-                const route = config.get('route') ?? '/webhook';
+                const port = this.config.get('port');
+                const secret = this.config.get('secret');
+                const route = this.config.get('route') ?? '/webhook';
                 const cfg = {
                     secret: secret ?? '',
                     port: port ? Number(port) : 17157
@@ -96,7 +93,7 @@ class QQBotClient extends QQBotAPI {
                         for (const event of this.#events[body.t] || []) {
                             event(body.d);
                         }
-                        const accessToken = config.get('access_token');
+                        const accessToken = this.config.get('access_token');
                         for (const client of this.#client) {
                             try {
                                 if (accessToken) {
@@ -114,6 +111,7 @@ class QQBotClient extends QQBotAPI {
                 this.#app.use(router.allowedMethods());
                 const server = this.#app.listen(cfg.port, () => {
                     console.log('Server running at http://localhost:' + cfg.port + route);
+                    this.updateConnectionStatus({ state: 'ready' });
                 });
                 const wss = new WebSocketServer({ server: server });
                 console.log('Server running at ws://localhost:' + cfg.port + '/');
@@ -144,6 +142,7 @@ class QQBotClient extends QQBotAPI {
                     this.#ws = new WebSocket(ws);
                     this.#ws.on('open', () => {
                         this.#count = 0;
+                        this.updateConnectionStatus({ state: 'ready' });
                         console.log('ws connected');
                     });
                     this.#ws.on('message', data => {
@@ -151,7 +150,7 @@ class QQBotClient extends QQBotAPI {
                             const body = normalizeGatewayMessage(JSON.parse(data.toString()));
                             const accessToken = body['access_token'];
                             if (accessToken) {
-                                config.set('access_token', accessToken);
+                                this.config.set('access_token', accessToken);
                             }
                             for (const event of this.#events[body.t] || []) {
                                 event(body.d);
@@ -162,6 +161,7 @@ class QQBotClient extends QQBotAPI {
                         }
                     });
                     this.#ws.on('close', () => {
+                        this.updateConnectionStatus({ state: 'offline' });
                         console.log('ws closed');
                         if (this.#count > 5) {
                             return;

package/lib/sdk/client.websoket.d.ts

@@ -3,7 +3,8 @@ import { QQBotEventMap } from './message.js';
 import { Options } from './typing.js';
 export declare class QQBotClients extends QQBotAPI {
     #private;
-    constructor(opstion: Options);
+    constructor(option: Options);
+    disconnect(): void;
     on<T extends keyof QQBotEventMap>(key: T, val: (event: QQBotEventMap[T]) => any): this;
     connect(gatewayURL?: string): Promise<void>;
 }

package/lib/sdk/client.websoket.js

@@ -1,8 +1,7 @@
 import WebSocket from 'ws';
 import { QQBotAPI } from './api.js';
-import { config } from './config.js';
 import { getIntentsMask } from './intents.js';
-import { Counter } from 'alemonjs/utils';
+import { FileSessionStore } from './session.js';
 
 const normalizeGatewayMessage = (message) => {
     if (!message?.id || !message?.d || typeof message.d !== 'object' || Array.isArray(message.d)) {
@@ -14,41 +13,192 @@ const normalizeGatewayMessage = (message) => {
     return message;
 };
 class QQBotClients extends QQBotAPI {
-    #counter = new Counter(1);
     #isConnected = false;
-    #heartbeat_interval = 30000;
-    #IntervalId = null;
+    #stopped = false;
+    #sessionId = null;
+    #sessionStore;
+    #sessionLoaded = false;
+    #sequence = null;
+    #heartbeatAcknowledged = true;
+    #heartbeatInterval = 30000;
+    #heartbeatTimer = null;
+    #accessTokenTimer = null;
+    #accessTokenTask = null;
+    #reconnectTimer = null;
+    #reconnectAttempts = 0;
     #gatewayUrl = null;
-    constructor(opstion) {
-        super();
-        for (const key in opstion) {
-            config.set(key, opstion[key]);
+    #ws = null;
+    #events = {};
+    constructor(option) {
+        super(option);
+        this.#sessionStore = option.sessionStore || new FileSessionStore();
+    }
+    async #loadSession() {
+        if (this.#sessionLoaded)
+            return;
+        this.#sessionLoaded = true;
+        const botId = String(this.config.get('app_id') || '');
+        const session = botId ? await this.#sessionStore.load(botId) : null;
+        if (session) {
+            this.#sessionId = session.sessionId;
+            this.#sequence = session.sequence;
+        }
+    }
+    #persistSession() {
+        const botId = String(this.config.get('app_id') || '');
+        if (!botId || !this.#sessionId || this.#sequence === null)
+            return;
+        void this.#sessionStore.save({ botId, sessionId: this.#sessionId, sequence: this.#sequence }).catch(err => {
+            console.warn('[ws-qqbot] session persistence failed', err);
+        });
+    }
+    #clearSession() {
+        const botId = String(this.config.get('app_id') || '');
+        this.#sessionId = null;
+        this.#sequence = null;
+        if (botId)
+            void this.#sessionStore.clear(botId).catch(() => undefined);
+    }
+    #clearHeartbeat() {
+        if (this.#heartbeatTimer) {
+            clearInterval(this.#heartbeatTimer);
+            this.#heartbeatTimer = null;
         }
     }
-    async #setTimeoutBotConfig() {
-        const accessToken = async () => {
-            const app_id = config.get('app_id');
-            const secret = config.get('secret');
-            if (!app_id || !secret) {
+    #startHeartbeat(ws) {
+        this.#clearHeartbeat();
+        this.#heartbeatTimer = setInterval(() => {
+            if (this.#ws !== ws || !this.#isConnected || ws.readyState !== WebSocket.OPEN) {
+                this.#clearHeartbeat();
+                return;
+            }
+            if (!this.#heartbeatAcknowledged) {
+                this.#requestReconnect('heartbeat acknowledgement timeout');
                 return;
             }
+            try {
+                this.#heartbeatAcknowledged = false;
+                this.updateConnectionStatus({ heartbeatAcknowledged: false });
+                ws.send(JSON.stringify({
+                    op: 1,
+                    d: null
+                }));
+            }
+            catch (err) {
+                console.error('[ws-qqbot] heartbeat failed', err);
+                this.#requestReconnect('heartbeat failed');
+            }
+        }, this.#heartbeatInterval);
+    }
+    #getReconnectDelay() {
+        const delay = Math.min(1000 * 2 ** Math.min(this.#reconnectAttempts, 5), 30000);
+        const jitter = Math.floor(Math.random() * Math.min(1000, Math.floor(delay / 4)));
+        return delay + jitter;
+    }
+    #scheduleReconnect(reason) {
+        if (this.#stopped || this.#reconnectTimer) {
+            return;
+        }
+        const delay = this.#getReconnectDelay();
+        this.#reconnectAttempts++;
+        this.updateConnectionStatus({
+            state: 'reconnecting',
+            reconnectAttempts: this.#reconnectAttempts,
+            heartbeatAcknowledged: this.#heartbeatAcknowledged,
+            lastError: reason
+        });
+        console.info(`[ws-qqbot] ${reason}; reconnecting in ${delay}ms (attempt ${this.#reconnectAttempts})`);
+        this.#reconnectTimer = setTimeout(() => {
+            this.#reconnectTimer = null;
+            void this.connect();
+        }, delay);
+    }
+    #requestReconnect(reason) {
+        this.#isConnected = false;
+        this.#clearHeartbeat();
+        this.cancelStreams();
+        this.#scheduleReconnect(reason);
+        const ws = this.#ws;
+        if (ws && ws.readyState !== WebSocket.CLOSED && ws.readyState !== WebSocket.CLOSING) {
+            ws.close();
+        }
+    }
+    disconnect() {
+        this.#stopped = true;
+        this.#isConnected = false;
+        this.#clearHeartbeat();
+        if (this.#reconnectTimer) {
+            clearTimeout(this.#reconnectTimer);
+        }
+        if (this.#accessTokenTimer) {
+            clearTimeout(this.#accessTokenTimer);
+        }
+        this.#reconnectTimer = null;
+        this.#accessTokenTimer = null;
+        const ws = this.#ws;
+        this.#ws = null;
+        this.cancelStreams();
+        if (ws && ws.readyState !== WebSocket.CLOSED) {
+            ws.close(1000, 'client stopped');
+        }
+        this.updateConnectionStatus({ state: 'stopped', heartbeatAcknowledged: false });
+    }
+    #scheduleAccessTokenRefresh(delay) {
+        if (this.#accessTokenTimer) {
+            clearTimeout(this.#accessTokenTimer);
+        }
+        this.#accessTokenTimer = setTimeout(() => {
+            this.#accessTokenTimer = null;
+            void this.#startAccessTokenRefresh().catch(() => undefined);
+        }, delay);
+    }
+    async #refreshAccessToken() {
+        const appId = this.config.get('app_id');
+        const secret = this.config.get('secret');
+        if (!appId || !secret) {
+            throw new Error('QQ Bot app_id or secret is missing');
+        }
+        try {
             const data = await this.getAuthentication();
-            config.set('access_token', data.access_token);
-            console.info('refresh', data.expires_in, 's');
-            setTimeout(() => void accessToken(), data.expires_in * 1000);
-        };
-        await accessToken();
+            if (!data?.access_token) {
+                throw new Error('QQ Bot access token is empty');
+            }
+            this.config.set('access_token', data.access_token);
+            const expiresIn = Number(data.expires_in);
+            const refreshIn = Math.max(60000, (Number.isFinite(expiresIn) ? expiresIn * 1000 : 3600000) - 60000);
+            this.#scheduleAccessTokenRefresh(refreshIn);
+            console.info(`[ws-qqbot] access token refreshed; next refresh in ${refreshIn}ms`);
+        }
+        catch (err) {
+            this.#scheduleAccessTokenRefresh(30000);
+            console.error('[ws-qqbot] access token refresh failed; retrying in 30000ms', err);
+            throw err;
+        }
+    }
+    #startAccessTokenRefresh() {
+        if (this.#accessTokenTask === null) {
+            this.#accessTokenTask = this.#refreshAccessToken().finally(() => {
+                this.#accessTokenTask = null;
+            });
+        }
+        return this.#accessTokenTask;
+    }
+    async #ensureAccessToken() {
+        if (this.#accessTokenTimer) {
+            return;
+        }
+        await this.#startAccessTokenRefresh();
     }
     #aut() {
-        const token = config.get('access_token');
-        const intents = config.get('intents');
-        const shard = config.get('shard');
+        const token = this.config.get('access_token');
+        const intents = this.config.get('intents');
+        const shard = this.config.get('shard');
         return {
             op: 2,
             d: {
                 token: `QQBot ${token}`,
                 intents: getIntentsMask(intents),
-                shard: shard,
+                shard,
                 properties: {
                     $os: process.platform,
                     $browser: 'alemonjs',
@@ -57,8 +207,16 @@ class QQBotClients extends QQBotAPI {
             }
         };
     }
-    #ws = null;
-    #events = {};
+    #resume() {
+        return {
+            op: 6,
+            d: {
+                token: `QQBot ${this.config.get('access_token')}`,
+                session_id: this.#sessionId,
+                seq: this.#sequence
+            }
+        };
+    }
     on(key, val) {
         if (!this.#events[key]) {
             this.#events[key] = [];
@@ -66,119 +224,172 @@ class QQBotClients extends QQBotAPI {
         this.#events[key].push(val);
         return this;
     }
+    #emitError(err) {
+        for (const event of this.#events.ERROR || []) {
+            try {
+                event(err);
+            }
+            catch (error) {
+                console.error('[ws-qqbot] error handler failed', error);
+            }
+        }
+    }
+    #handleDispatch(t, d) {
+        for (const event of this.#events[t] || []) {
+            try {
+                event(d);
+            }
+            catch (err) {
+                this.#emitError(err);
+            }
+        }
+    }
     async connect(gatewayURL) {
-        await this.#setTimeoutBotConfig();
+        this.#stopped = false;
+        if (gatewayURL) {
+            this.#gatewayUrl = gatewayURL;
+        }
+        if (this.#ws && this.#ws.readyState !== WebSocket.CLOSED) {
+            return;
+        }
+        await this.#loadSession();
+        try {
+            await this.#ensureAccessToken();
+        }
+        catch {
+            this.#scheduleReconnect('access token unavailable');
+            return;
+        }
         if (!this.#gatewayUrl) {
-            this.#gatewayUrl = gatewayURL ?? (await this.gateway().then(res => res?.url));
+            try {
+                this.#gatewayUrl = await this.gateway().then(res => res?.url);
+            }
+            catch (err) {
+                this.#emitError(err);
+                this.#scheduleReconnect('gateway request failed');
+                return;
+            }
         }
         if (!this.#gatewayUrl) {
+            this.#scheduleReconnect('gateway URL is empty');
             return;
         }
-        const reconnect = () => {
-            if (this.#counter.value >= 5) {
-                console.info('The maximum number of reconnections has been reached, cancel reconnection');
+        let ws;
+        try {
+            ws = new WebSocket(this.#gatewayUrl);
+        }
+        catch (err) {
+            this.#emitError(err);
+            this.#scheduleReconnect('gateway connection creation failed');
+            return;
+        }
+        this.#ws = ws;
+        this.updateConnectionStatus({ state: 'connecting', transport: 'websocket', lastError: undefined });
+        ws.on('open', () => {
+            if (this.#ws === ws) {
+                console.info('[ws-qqbot] open');
+            }
+        });
+        ws.on('message', msg => {
+            if (this.#ws !== ws) {
                 return;
             }
-            setTimeout(() => {
-                console.info('[ws-qqbot] reconnecting...');
-                start();
-                this.#counter.next();
-            }, 5000);
-        };
-        const start = () => {
-            if (this.#gatewayUrl) {
+            try {
+                const message = normalizeGatewayMessage(JSON.parse(msg.toString('utf8')));
+                if (process.env.NTQQ_WS === 'dev') {
+                    console.info('message', message);
+                }
                 const map = {
-                    0: ({ t, d }) => {
-                        if (this.#events[t]) {
-                            try {
-                                for (const event of this.#events[t]) {
-                                    if (typeof event !== 'function') {
-                                        continue;
-                                    }
-                                    event(d);
-                                }
-                            }
-                            catch (err) {
-                                if (this.#events['ERROR']) {
-                                    for (const event of this.#events['ERROR']) {
-                                        if (typeof event !== 'function') {
-                                            continue;
-                                        }
-                                        event(err);
-                                    }
-                                }
-                            }
+                    0: ({ t, d, s }) => {
+                        if (typeof s === 'number') {
+                            this.#sequence = s;
                         }
-                        if (t === 'READY') {
-                            if (this.#IntervalId) {
-                                clearInterval(this.#IntervalId);
-                            }
-                            this.#IntervalId = setInterval(() => {
-                                if (this.#isConnected && this.#ws) {
-                                    this.#ws.send(JSON.stringify({
-                                        op: 1,
-                                        d: null
-                                    }));
-                                }
-                            }, this.#heartbeat_interval);
+                        if (t === 'READY' && d?.session_id) {
+                            this.#sessionId = String(d.session_id);
                         }
-                        if (t === 'RESUMED') {
-                            console.info('[ws-qqbot] restore connection');
-                            this.#counter.reStart();
+                        this.#persistSession();
+                        this.#handleDispatch(t, d);
+                        if (t === 'READY' || t === 'RESUMED') {
+                            this.#reconnectAttempts = 0;
+                            this.updateConnectionStatus({
+                                state: 'ready',
+                                reconnectAttempts: 0,
+                                heartbeatAcknowledged: this.#heartbeatAcknowledged,
+                                sessionId: this.#sessionId ?? undefined,
+                                sequence: this.#sequence ?? undefined,
+                                resumed: t === 'RESUMED'
+                            });
+                            console.info(t === 'READY' ? '[ws-qqbot] ready' : '[ws-qqbot] restored connection');
                         }
                     },
-                    6: ({ d }) => {
-                        console.info('[ws-qqbot] connection attempt', d);
-                    },
                     7: ({ d }) => {
-                        console.info('[ws-qqbot] reconnect', d);
-                        if (this.#IntervalId) {
-                            clearInterval(this.#IntervalId);
-                        }
+                        console.info('[ws-qqbot] gateway requested reconnect', d);
+                        this.#requestReconnect('gateway requested reconnect');
                     },
                     9: ({ d }) => {
-                        console.info('[ws-qqbot] parameter error', d);
+                        console.error('[ws-qqbot] invalid session', d);
+                        this.#clearSession();
+                        this.#requestReconnect('invalid session');
                     },
                     10: ({ d }) => {
                         this.#isConnected = true;
-                        this.#heartbeat_interval = d.heartbeat_interval;
-                        if (this.#ws) {
-                            this.#ws.send(JSON.stringify(this.#aut()));
+                        this.#heartbeatInterval = Number(d?.heartbeat_interval) || 30000;
+                        this.#startHeartbeat(ws);
+                        try {
+                            const resumable = this.#sessionId && this.#sequence !== null;
+                            ws.send(JSON.stringify(resumable ? this.#resume() : this.#aut()));
+                            this.updateConnectionStatus({
+                                state: 'connecting',
+                                heartbeatAcknowledged: true,
+                                sessionId: this.#sessionId ?? undefined,
+                                sequence: this.#sequence ?? undefined,
+                                resumed: Boolean(resumable)
+                            });
+                        }
+                        catch (err) {
+                            console.error('[ws-qqbot] identify failed', err);
+                            this.#emitError(err);
+                            this.#requestReconnect('identify failed');
                         }
                     },
                     11: () => {
-                        console.info('[ws-qqbot] heartbeat transmission');
-                        this.#counter.reStart();
+                        this.#heartbeatAcknowledged = true;
+                        this.updateConnectionStatus({ heartbeatAcknowledged: true });
+                        console.debug('[ws-qqbot] heartbeat acknowledged');
                     },
                     12: ({ d }) => {
                         console.debug('[ws-qqbot] platform data', d);
                     }
                 };
-                this.#ws = new WebSocket(this.#gatewayUrl);
-                this.#ws.on('open', () => {
-                    console.info('[ws-qqbot] open');
-                });
-                this.#ws.on('message', msg => {
-                    const message = normalizeGatewayMessage(JSON.parse(msg.toString('utf8')));
-                    if (process.env.NTQQ_WS === 'dev') {
-                        console.info('message', message);
-                    }
-                    if (map[message.op]) {
-                        map[message.op](message);
-                    }
-                });
-                this.#ws.on('close', err => {
-                    this.#isConnected = false;
-                    if (this.#IntervalId) {
-                        clearInterval(this.#IntervalId);
-                        this.#IntervalId = null;
-                    }
-                    void reconnect();
-                    console.info('[ws-qqbot] close', err);
-                });
+                if (map[message.op]) {
+                    map[message.op](message);
+                }
             }
-        };
-        start();
+            catch (err) {
+                console.error('[ws-qqbot] invalid gateway message', err);
+                this.#emitError(err);
+            }
+        });
+        ws.on('close', (code, reason) => {
+            if (this.#ws !== ws) {
+                return;
+            }
+            this.#ws = null;
+            this.#isConnected = false;
+            this.#clearHeartbeat();
+            this.updateConnectionStatus({ state: 'offline', heartbeatAcknowledged: false });
+            console.info(`[ws-qqbot] close ${code}${reason.length ? `: ${reason.toString('utf8')}` : ''}`);
+            this.#scheduleReconnect('connection closed');
+        });
+        ws.on('error', err => {
+            if (this.#ws !== ws) {
+                return;
+            }
+            console.error('[ws-qqbot] error', err);
+            this.updateConnectionStatus({ state: 'offline', lastError: err.message });
+            this.#emitError(err);
+            this.#requestReconnect('connection error');
+        });
     }
 }
 

package/lib/sdk/config.d.ts

@@ -1 +1,3 @@
-export declare const config: Map<string, any>;
+export declare class QQBotConfig extends Map<string, any> {
+    constructor(value?: Record<string, unknown>);
+}

package/lib/sdk/config.js

@@ -1,3 +1,7 @@
-const config = new Map();
+class QQBotConfig extends Map {
+    constructor(value = {}) {
+        super(Object.entries(value));
+    }
+}
 
-export { config };
+export { QQBotConfig };

package/lib/sdk/instance.js

@@ -1,3 +1,5 @@
+import { logger } from 'alemonjs';
+
 const filterHeaders = (headers = {}) => {
     if (!headers) {
         return headers;

package/lib/sdk/intents.d.ts

@@ -1,3 +1,3 @@
-export declare const AvailableIntentsEventsEnum: readonly ["GUILDS", "GUILD_MEMBERS", "GUILD_MESSAGES", "GUILD_MESSAGE_REACTIONS", "DIRECT_MESSAGE", "INTERACTION", "MESSAGE_AUDIT", "FORUMS_EVENT", "AUDIO_ACTION", "PUBLIC_GUILD_MESSAGES", "GROUP_AND_C2C_EVENT"];
+export declare const AvailableIntentsEventsEnum: readonly ["GUILDS", "GUILD_MEMBERS", "GUILD_MESSAGES", "GUILD_MESSAGE_REACTIONS", "DIRECT_MESSAGE", "GROUP_MEMBER_EVENT", "INTERACTION", "MESSAGE_AUDIT", "FORUMS_EVENT", "AUDIO_ACTION", "PUBLIC_GUILD_MESSAGES", "GROUP_AND_C2C_EVENT"];
 export type IntentsEnum = (typeof AvailableIntentsEventsEnum)[number];
 export declare function getIntentsMask(intents: IntentsEnum[]): number;

package/lib/sdk/intents.js

@@ -4,6 +4,7 @@ const AvailableIntentsEventsEnum = [
     'GUILD_MESSAGES',
     'GUILD_MESSAGE_REACTIONS',
     'DIRECT_MESSAGE',
+    'GROUP_MEMBER_EVENT',
     'INTERACTION',
     'MESSAGE_AUDIT',
     'FORUMS_EVENT',
@@ -17,6 +18,7 @@ const intentsMap = {
     GUILD_MESSAGES: 1 << 9,
     GUILD_MESSAGE_REACTIONS: 1 << 10,
     DIRECT_MESSAGE: 1 << 12,
+    GROUP_MEMBER_EVENT: 1 << 24,
     INTERACTION: 1 << 26,
     MESSAGE_AUDIT: 1 << 27,
     FORUMS_EVENT: 1 << 28,

package/lib/sdk/message.group.d.ts

@@ -14,6 +14,7 @@ import { FRIEND_DEL_TYPE } from '../message/group/FRIEND_DEL';
 import { ERROR_TYPE } from '../message/ERROR';
 import { GROUP_MEMBER_REMOVE } from '../message/group/GROUP_MEMBER_REMOVE';
 import { GROUP_MEMBER_ADD } from '../message/group/GROUP_MEMBER_ADD';
+import { GROUP_JOIN_REQUEST_TYPE } from '../message/group/GROUP_JOIN_REQUEST';
 export type QQBotGroupEventMap = {
     C2C_MESSAGE_CREATE: C2C_MESSAGE_CREATE_TYPE;
     C2C_MSG_REJECT: C2C_MSG_REJECT_TYPE;
@@ -31,4 +32,5 @@ export type QQBotGroupEventMap = {
     ERROR: ERROR_TYPE;
     GROUP_MEMBER_ADD: GROUP_MEMBER_ADD;
     GROUP_MEMBER_REMOVE: GROUP_MEMBER_REMOVE;
+    GROUP_JOIN_REQUEST: GROUP_JOIN_REQUEST_TYPE;
 };