@alemonjs/qq-bot 2.1.31 → 2.1.33

package/lib/sdk/registry.d.ts

@@ -0,0 +1,25 @@
+import { cbpPlatform } from 'alemonjs';
+import { QQBotClients } from './client.websoket.js';
+import type { Options } from './typing.js';
+export declare class QQBotRegistry {
+    #private;
+    constructor(defaultBot?: string, cbp?: ReturnType<typeof cbpPlatform>);
+    add(botId: string, options: Options): QQBotClients;
+    get(botId?: string): QQBotClients;
+    getConnectionStatus(botId?: string): {
+        Platform: string;
+        state: import("./api.js").QQBotConnectionState;
+        bots: {
+            state: import("./api.js").QQBotConnectionState;
+            transport: "websocket" | "webhook" | "proxy" | null;
+            reconnectAttempts: number;
+            heartbeatAcknowledged: boolean;
+            sessionId?: string;
+            sequence?: number;
+            resumed: boolean;
+            lastError?: string;
+            BotId: string;
+        }[];
+    };
+    disconnect(): void;
+}

package/lib/sdk/registry.js

@@ -0,0 +1,116 @@
+import { cbpPlatform, createResult, ResultCode } from 'alemonjs';
+import { getQQBotConfig } from '../config.js';
+import { register } from '../register.js';
+import { QQBotClients } from './client.websoket.js';
+
+class QQBotRegistry {
+    #bots = new Map();
+    #streams = new Map();
+    #defaultBot;
+    #cbp;
+    constructor(defaultBot, cbp) {
+        this.#defaultBot = defaultBot;
+        if (cbp) {
+            this.#cbp = cbp;
+        }
+        else {
+            const config = getQQBotConfig();
+            const port = process.env.port || config.port || 17117;
+            this.#cbp = cbpPlatform(`ws://127.0.0.1:${port}`);
+        }
+        this.#cbp.onactions((data, consume) => void this.#onAction(data, consume));
+        this.#cbp.onapis((data, consume) => void this.#onApi(data, consume));
+    }
+    add(botId, options) {
+        if (!botId)
+            throw new Error('QQ BotId is required');
+        if (this.#bots.has(botId))
+            throw new Error(`Duplicate QQ BotId: ${botId}`);
+        const client = new QQBotClients({ ...options, app_id: botId });
+        client.setStreamLifecycleListener(streamId => this.#streams.delete(streamId));
+        const adapter = register(client, { botId, cbp: this.#cbp, bindActions: false });
+        this.#bots.set(botId, { client, adapter });
+        return client;
+    }
+    get(botId) {
+        return botId ? this.#bots.get(botId)?.client : undefined;
+    }
+    getConnectionStatus(botId) {
+        const bots = [...this.#bots].flatMap(([BotId, entry]) => {
+            if (botId && botId !== BotId)
+                return [];
+            return [{ BotId, ...entry.client.getConnectionStatus() }];
+        });
+        const state = bots.some(item => item.state === 'ready')
+            ? 'ready'
+            : bots.some(item => item.state === 'connecting' || item.state === 'reconnecting')
+                ? 'connecting'
+                : bots[0]?.state || 'idle';
+        return { Platform: 'qq-bot', state, bots };
+    }
+    disconnect() {
+        for (const { client } of this.#bots.values())
+            client.disconnect();
+        this.#streams.clear();
+    }
+    #requestedBotId(data) {
+        const payload = data?.payload || {};
+        return payload.target?.BotId || payload.BotId || payload.event?.BotId || payload.event?.Platform?.BotId;
+    }
+    #select(data) {
+        const requested = this.#requestedBotId(data);
+        if (requested) {
+            const entry = this.#bots.get(String(requested));
+            return entry ? { entry } : { error: `BotId ${requested} is not configured (available: ${[...this.#bots.keys()].join(', ') || 'none'})` };
+        }
+        if (this.#bots.size === 1)
+            return { entry: this.#bots.values().next().value };
+        if (this.#defaultBot)
+            return { entry: this.#bots.get(this.#defaultBot) };
+        return { error: 'BotId is required because multiple QQ bots are active and no default_bot is configured' };
+    }
+    async #onAction(data, consume) {
+        if (data?.action === 'connection.status') {
+            const botId = data?.payload?.BotId;
+            const status = this.getConnectionStatus(botId);
+            if (botId && !status.bots.length) {
+                consume([createResult(ResultCode.FailParams, `BotId ${botId} is not configured`, null)]);
+            }
+            else {
+                consume([createResult(ResultCode.Ok, data.action, status)]);
+            }
+            return;
+        }
+        const { entry, error } = this.#select(data);
+        if (!entry) {
+            consume([createResult(ResultCode.FailParams, error || 'QQ Bot is unavailable', null)]);
+            return;
+        }
+        await entry.adapter.onAction(data, consume);
+    }
+    async #onApi(data, consume) {
+        const params = data?.payload?.params;
+        const key = String(data?.payload?.key || '');
+        const method = key.split('.').at(-1);
+        const streamId = method === 'streamUpdate' || method === 'streamComplete' || method === 'streamCancel' ? params?.[0] : undefined;
+        const requested = (Array.isArray(params) ? params[0]?.BotId : undefined) || (streamId ? this.#streams.get(String(streamId)) : undefined);
+        const { entry, error } = this.#select({ payload: { BotId: requested, event: data?.payload?.event } });
+        if (!entry) {
+            consume([createResult(ResultCode.FailParams, error || 'QQ Bot is unavailable', null)]);
+            return;
+        }
+        await entry.adapter.onApi(data, results => {
+            const result = results.find((item) => item.code === ResultCode.Ok)?.data;
+            if (method === 'streamOpen' && result?.streamId)
+                this.#streams.set(String(result.streamId), requested || this.#botIdFor(entry));
+            if (streamId && (method === 'streamComplete' || method === 'streamCancel'))
+                this.#streams.delete(String(streamId));
+            consume(results);
+        });
+    }
+    #botIdFor(entry) {
+        return [...this.#bots.entries()].find(([, value]) => value === entry)?.[0] || '';
+    }
+}
+
+export { QQBotRegistry };

package/lib/sdk/session.d.ts

@@ -0,0 +1,18 @@
+export type PersistedSession = {
+    botId: string;
+    sessionId: string;
+    sequence: number;
+};
+export interface SessionStore {
+    load(botId: string): Promise<PersistedSession | null>;
+    save(session: PersistedSession): Promise<void>;
+    clear(botId: string): Promise<void>;
+}
+export declare class FileSessionStore implements SessionStore {
+    #private;
+    private readonly root;
+    constructor(root?: string);
+    load(botId: string): Promise<PersistedSession | null>;
+    save(session: PersistedSession): Promise<void>;
+    clear(botId: string): Promise<void>;
+}

package/lib/sdk/session.js

@@ -0,0 +1,56 @@
+import { readFile, mkdir, writeFile, rename, unlink } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { join, dirname } from 'node:path';
+
+class FileSessionStore {
+    root;
+    #queues = new Map();
+    #generations = new Map();
+    constructor(root = join(process.cwd(), '.data', 'qq-bot', 'sessions')) {
+        this.root = root;
+    }
+    #path(botId) {
+        return join(this.root, `${encodeURIComponent(botId)}.json`);
+    }
+    async load(botId) {
+        try {
+            const value = JSON.parse(await readFile(this.#path(botId), 'utf8'));
+            return value?.botId === botId && typeof value.sessionId === 'string' && Number.isFinite(value.sequence) ? value : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async save(session) {
+        const generation = this.#generations.get(session.botId) || 0;
+        await this.#enqueue(session.botId, async () => {
+            if (generation !== (this.#generations.get(session.botId) || 0))
+                return;
+            const path = this.#path(session.botId);
+            const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+            await mkdir(dirname(path), { recursive: true });
+            await writeFile(temp, JSON.stringify(session), 'utf8');
+            await rename(temp, path);
+        });
+    }
+    async clear(botId) {
+        this.#generations.set(botId, (this.#generations.get(botId) || 0) + 1);
+        await this.#enqueue(botId, async () => {
+            await unlink(this.#path(botId)).catch(() => undefined);
+        });
+    }
+    #enqueue(botId, task) {
+        const previous = this.#queues.get(botId) || Promise.resolve();
+        const next = previous.catch(() => undefined).then(task);
+        this.#queues.set(botId, next);
+        void next
+            .finally(() => {
+            if (this.#queues.get(botId) === next)
+                this.#queues.delete(botId);
+        })
+            .catch(() => undefined);
+        return next;
+    }
+}
+
+export { FileSessionStore };

package/lib/sdk/typing.d.ts

@@ -1,5 +1,6 @@
 import { IntentsEnum } from './intents';
-export type MessageType = 0 | 1 | 2 | 3 | 4 | 7;
+import type { SessionStore } from './session.js';
+export type MessageType = 0 | 1 | 2 | 3 | 4 | 6 | 7;
 export type FileType = 1 | 2 | 3 | 4;
 export interface ButtonType {
     id: string;
@@ -54,6 +55,128 @@ export interface ApiRequestData {
     event_id?: any;
     msg_id?: string;
     msg_seq?: number;
+    is_wakeup?: boolean;
+    force_verify_image_resource?: boolean;
+    input_notify?: {
+        input_type: number;
+        input_second: number;
+    };
+}
+export interface VerifyInfo {
+    method: string;
+    verify_message?: string;
+    review_qa_list?: {
+        question: string;
+        answer: string;
+    }[];
+}
+export interface JoinRequest {
+    join_request_id: string;
+    risk_tips?: string;
+    union_openid?: string;
+    member_openid: string;
+    username: string;
+    apply_at: string;
+    apply_source: string;
+    invited_by?: string;
+    bot: boolean;
+    verify_info?: VerifyInfo;
+    auto_approved?: {
+        strategy_id: string;
+    };
+}
+export interface GlobalMuteRule {
+    mode: 'none' | 'always' | 'schedule';
+    schedule_rules?: {
+        task_id: string;
+        start_at: string;
+        end_at: string;
+        enabled: boolean;
+    }[];
+    recurring_rules?: {
+        task_id: string;
+        weekdays: number[];
+        start_time: string;
+        end_time: string;
+        enabled: boolean;
+    }[];
+}
+export interface MemberMuteState {
+    member_openid: string;
+    mute_expire_at: string;
+    username: string;
+    union_openid: string;
+}
+export interface SetMemberMuteState {
+    op: 'add' | 'update' | 'del';
+    member_openid: string;
+    mute_expire_at?: string;
+}
+export interface JoinApprovalStrategy {
+    strategy_id: string;
+    group_openids: string[];
+    group_ids: string[];
+    whitelist_user_count: number;
+    is_enable: 'on' | 'off';
+    expire_at: string;
+    created_at: string;
+    updated_at: string;
+    remark: string;
+}
+export interface GroupAction {
+    op: 'add' | 'del';
+    group_openids?: string[];
+    group_ids?: string[];
+}
+export interface UploadPrepareData {
+    file_type: FileType;
+    file_name: string;
+    file_size: string;
+    md5: string;
+    sha1: string;
+    md5_10m: string;
+}
+export interface UploadPart {
+    index: number;
+    presigned_url: string;
+    block_size: string;
+}
+export interface UploadConfig {
+    concurrency: number;
+    retry_timeout: number;
+    retry_delay: number;
+}
+export interface UploadPrepareResult {
+    upload_id: string;
+    block_size: string;
+    parts: UploadPart[];
+    upload_config: UploadConfig;
+}
+export interface UploadPartFinishData {
+    upload_id: string;
+    part_index: number;
+    block_size: string;
+    md5: string;
+}
+export interface StreamMessageData {
+    input_mode?: 'append' | 'replace';
+    input_state?: 1 | 10;
+    content_type?: 'text' | 'markdown';
+    content_raw?: string;
+    event_id?: string;
+    msg_id?: string;
+    msg_seq?: number;
+    index?: number;
+    stream_msg_id?: string;
+    is_wakeup?: boolean;
+}
+export interface StreamMessageResult {
+    id: string;
+    timestamp: string;
+    ext_info?: {
+        ref_idx?: string;
+    };
+    remain_msg_len?: number;
 }
 export interface Options {
     app_id: string;
@@ -68,4 +191,5 @@ export interface Options {
     gatewayURL?: string;
     base_url_gateway?: string;
     base_url_app_access_token?: string;
+    sessionStore?: SessionStore;
 }

package/lib/sends.d.ts

@@ -5,12 +5,16 @@ export declare const GROUP_AT_MESSAGE_CREATE: (client: Client, event: {
     ChannelId: string;
     MessageId?: string;
     _tag?: string;
-}, val: DataEnums[]) => Promise<ClientAPIMessageResult[]>;
+}, val: DataEnums[], options?: {
+    forceVerifyImageResource?: boolean;
+}) => Promise<ClientAPIMessageResult[]>;
 export declare const C2C_MESSAGE_CREATE: (client: Client, event: {
     UserId: string;
     MessageId?: string;
     _tag?: string;
-}, val: DataEnums[]) => Promise<ClientAPIMessageResult[]>;
+}, val: DataEnums[], options?: {
+    forceVerifyImageResource?: boolean;
+}) => Promise<ClientAPIMessageResult[]>;
 export declare const DIRECT_MESSAGE_CREATE: (client: Client, event: {
     UserId: string;
     MessageId?: string;

package/lib/sends.js

@@ -1,11 +1,31 @@
 import { readFileSync } from 'fs';
-import { createResult, ResultCode } from 'alemonjs';
+import { createResult, ResultCode, logger } from 'alemonjs';
 import axios from 'axios';
 import { dataEnumToText, markdownToText, buttonsToText } from './format.js';
 import { getQQBotConfig } from './config.js';
 
 const MAX_BUTTON_ROWS = 5;
 const MAX_BUTTONS_PER_ROW = 5;
+const BUTTON_STYLE_MAP = {
+    gray: 0,
+    blue: 1,
+    red: 3,
+    'blue-fill': 4
+};
+const resolveButtonStyle = (style) => {
+    if (typeof style === 'number') {
+        return style;
+    }
+    if (typeof style === 'string') {
+        if (BUTTON_STYLE_MAP[style] !== undefined) {
+            return BUTTON_STYLE_MAP[style];
+        }
+        if (style.trim() !== '' && !Number.isNaN(Number(style))) {
+            return Number(style);
+        }
+    }
+    return 0;
+};
 const createButtonsData = (rows, startId = 0) => {
     let id = startId;
     const clippedRows = rows.slice(0, MAX_BUTTON_ROWS);
@@ -18,25 +38,45 @@ const createButtonsData = (rows, startId = 0) => {
                 const typing = options?.type ?? 'command';
                 const typeMap = { command: 2, link: 0, call: 1 };
                 const rowData = options?.rawData ?? {};
+                const data = options?.data;
+                const modal = options?.modal ??
+                    (typeof data === 'object' && data
+                        ? {
+                            content: data.click,
+                            confirmText: data.confirm,
+                            cancelText: data.cancel
+                        }
+                        : undefined);
+                const action = {
+                    type: typeMap[typing],
+                    permission: {
+                        type: typeof options.permission?.type === 'undefined' ? 2 : options?.permission?.type,
+                        specify_user_ids: options?.permission?.userIds,
+                        specify_role_ids: options?.permission?.roleIds
+                    },
+                    unsupport_tips: options?.toolTip ?? '',
+                    data: typeof data === 'string' ? data : '',
+                    at_bot_show_channel_list: options?.atBotShowChannelList ?? false,
+                    enter: options?.autoEnter ?? false,
+                    reply: options?.reply ?? false,
+                    anchor: options?.anchor ?? 0,
+                    click_limit: options?.clickLimit
+                };
+                if (modal) {
+                    action.modal = {
+                        content: modal.content ?? '是否确认操作?',
+                        confirm_text: modal.confirmText ?? '是',
+                        cancel_text: modal.cancelText ?? '否'
+                    };
+                }
                 return {
                     id: String(id),
                     render_data: {
                         label: value,
                         visited_label: value,
-                        style: options.style !== 'blue' ? 0 : 1
-                    },
-                    action: {
-                        type: typeMap[typing],
-                        permission: {
-                            type: typeof options.permission?.type === 'undefined' ? 2 : options?.permission?.type,
-                            specify_user_ids: options?.permission?.userIds,
-                            specify_role_ids: options?.permission?.roleIds
-                        },
-                        unsupport_tips: options?.toolTip ?? '',
-                        data: options?.data ?? '',
-                        at_bot_show_channel_list: false,
-                        enter: options?.autoEnter ?? false
+                        style: resolveButtonStyle(options?.style)
                     },
+                    action,
                     ...rowData
                 };
             })
@@ -188,6 +228,9 @@ const extractContent = (val, mode) => {
         'Image',
         'ImageFile',
         'ImageURL',
+        'Audio',
+        'Video',
+        'Attachment',
         'Markdown',
         'MarkdownOriginal',
         'BT.group',
@@ -232,6 +275,7 @@ const buildMdAndButtonsParams = (val) => {
         return null;
     }
     const params = {};
+    let keyboardExtra;
     for (const item of items) {
         if (item.type === 'ButtonTemplate') {
             if (item?.value) {
@@ -239,6 +283,13 @@ const buildMdAndButtonsParams = (val) => {
             }
         }
         else if (item.type === 'BT.group' && typeof item?.value !== 'string') {
+            const groupOptions = item?.options ?? {};
+            if (groupOptions.smallButton || groupOptions.rawData) {
+                keyboardExtra = {
+                    smallButton: keyboardExtra?.smallButton || groupOptions.smallButton,
+                    rawData: groupOptions.rawData
+                };
+            }
             if (params['keyboard']?.content?.rows) {
                 const existingRows = params['keyboard'].content.rows;
                 const currentId = params['keyboard'].content.nextId ?? existingRows.length;
@@ -274,6 +325,14 @@ const buildMdAndButtonsParams = (val) => {
             }
         }
     }
+    if (keyboardExtra && params['keyboard']?.content) {
+        if (keyboardExtra.smallButton) {
+            params['keyboard'].content.style = { font_size: 'small' };
+        }
+        if (keyboardExtra.rawData) {
+            Object.assign(params['keyboard'].content, keyboardExtra.rawData);
+        }
+    }
     if (params['keyboard']?.content?.nextId !== undefined) {
         delete params['keyboard'].content.nextId;
     }
@@ -298,46 +357,66 @@ const buildArkParams = (val) => {
     }
     return params;
 };
+const MEDIA_FILE_TYPE = {
+    Image: 1,
+    ImageFile: 1,
+    ImageURL: 1,
+    Video: 2,
+    Audio: 3,
+    Attachment: 4
+};
+const filterMedia = (val) => {
+    return val.filter(item => MEDIA_FILE_TYPE[item.type] !== undefined);
+};
 const filterImages = (val) => {
     return val.filter(item => item.type === 'Image' || item.type === 'ImageFile' || item.type === 'ImageURL');
 };
-const resolveRichMediaUrl = async (images, uploadMedia) => {
-    for (const item of images) {
-        let fileData;
-        let fileInfo;
-        if (item.type === 'ImageURL') {
-            fileData = await axios.get(item.value, { responseType: 'arraybuffer' }).then(res => Buffer.from(res.data, 'binary').toString('base64'));
+const resolveFileData = async (item) => {
+    if (item.type === 'ImageURL') {
+        return await axios.get(item.value, { responseType: 'arraybuffer' }).then(res => Buffer.from(res.data, 'binary').toString('base64'));
+    }
+    if (item.type === 'ImageFile') {
+        return readFileSync(item.value, 'base64');
+    }
+    const value = item.value;
+    if (typeof value === 'string') {
+        if (value.startsWith('https://') || value.startsWith('http://')) {
+            return await axios.get(value, { responseType: 'arraybuffer' }).then(res => Buffer.from(res.data, 'binary').toString('base64'));
         }
-        else if (item.type === 'Image') {
-            if (typeof item.value === 'string' && (item.value.startsWith('https://') || item.value.startsWith('http://'))) {
-                fileData = await axios.get(item.value, { responseType: 'arraybuffer' }).then(res => Buffer.from(res.data, 'binary').toString('base64'));
-            }
-            else if (typeof item.value === 'string' && item.value.startsWith('file://')) {
-                const localFilePath = item.value.replace('file://', '');
-                fileData = readFileSync(localFilePath, 'base64');
-            }
-            else if (typeof item.value === 'string' && item.value.startsWith('base64://')) {
-                fileData = item.value.replace('base64://', '');
-            }
-            else if (Buffer.isBuffer(item.value)) {
-                fileData = item.value.toString('base64');
-            }
-            else if (typeof item.value === 'string') {
-                fileData = item.value;
-            }
+        if (value.startsWith('buffer://')) {
+            return value.replace('buffer://', '');
         }
-        else if (item.type === 'ImageFile') {
-            fileData = readFileSync(item.value, 'base64');
+        if (value.startsWith('file://')) {
+            return readFileSync(value.replace('file://', ''), 'base64');
         }
-        if (fileData) {
-            fileInfo = await uploadMedia({ file_type: 1, file_data: fileData }).then(res => res?.file_info);
+        if (value.startsWith('base64://')) {
+            return value.replace('base64://', '');
         }
-        if (fileInfo) {
-            return fileInfo;
+        return value;
+    }
+    if (Buffer.isBuffer(value)) {
+        return value.toString('base64');
+    }
+    return undefined;
+};
+const resolveMediaUrl = async (media, uploadMedia) => {
+    for (const item of media) {
+        const fileData = await resolveFileData(item);
+        if (fileData) {
+            const fileInfo = await uploadMedia({ file_type: MEDIA_FILE_TYPE[item.type] ?? 1, file_data: fileData }).then(res => res?.file_info);
+            if (fileInfo) {
+                return fileInfo;
+            }
         }
     }
     return undefined;
 };
+const stripMediaPlaceholders = (text) => text
+    .replace(/\[附件[^\]]*\]/g, '')
+    .replace(/\[音频\]/g, '')
+    .replace(/\[视频\]/g, '')
+    .replace(/\n{2,}/g, '\n')
+    .trim();
 const flattenMdToText = (content, val) => {
     const mdItems = val.filter(item => item.type === 'Markdown');
     const btnItems = val.filter(item => item.type === 'BT.group');
@@ -357,19 +436,19 @@ const flattenMdToText = (content, val) => {
         .join('\n')
         .replace(/^[^\S\n\r]+|[^\S\n\r]+$/g, '');
 };
-const sendOpenApiMessage = async (content, val, baseParams, uploadMedia, sendMessage, label) => {
+const sendOpenApiMessage = async (content, val, baseParams, uploadMedia, sendMessage, label, options) => {
     const config = getQQBotConfig();
     const mdToText = config.markdownToText === true;
-    const images = filterImages(val);
-    if (images.length > 0) {
-        const url = await resolveRichMediaUrl(images, uploadMedia);
-        if (!url) {
-            return [createResult(ResultCode.Fail, '图片上传失败', null)];
+    const media = filterMedia(val);
+    if (media.length > 0) {
+        const fileInfo = await resolveMediaUrl(media, uploadMedia);
+        if (!fileInfo) {
+            return [createResult(ResultCode.Fail, '媒体上传失败', null)];
         }
-        const imgContent = flattenMdToText(content, val);
+        const mediaContent = stripMediaPlaceholders(flattenMdToText(content, val));
         const res = await sendMessage({
-            content: imgContent,
-            media: { file_info: url },
+            content: mediaContent,
+            media: { file_info: fileInfo },
             msg_type: 7,
             ...baseParams
         });
@@ -392,7 +471,7 @@ const sendOpenApiMessage = async (content, val, baseParams, uploadMedia, sendMes
         if (mdParams.markdown?.content && content) {
             mdParams.markdown.content = content + '\n' + mdParams.markdown.content;
         }
-        const res = await sendMessage({ content, msg_type: 2, ...mdParams, ...baseParams });
+        const res = await sendMessage({ content, msg_type: 2, ...mdParams, ...baseParams, force_verify_image_resource: options?.forceVerifyImageResource });
         return [createResult(ResultCode.Ok, label, { id: res.id })];
     }
     const arkParams = buildArkParams(val);
@@ -473,21 +552,21 @@ const sendGuildMessage = async (content, val, baseParams, sendMessage, label) =>
     }
     return [];
 };
-const GROUP_AT_MESSAGE_CREATE = async (client, event, val) => {
+const GROUP_AT_MESSAGE_CREATE = async (client, event, val, options) => {
     const baseParams = buildBaseParams(event._tag, event.MessageId, 'INTERACTION_CREATE_GROUP');
     const content = extractContent(val, 'group');
     try {
-        return await sendOpenApiMessage(content, val, baseParams, data => client.postRichMediaByGroup(event.ChannelId, data), data => client.groupOpenMessages(event.ChannelId, data), 'client.groupOpenMessages');
+        return await sendOpenApiMessage(content, val, baseParams, data => client.postRichMediaByGroup(event.ChannelId, data), data => client.groupOpenMessages(event.ChannelId, data), 'client.groupOpenMessages', options);
     }
     catch (err) {
         return [createResult(ResultCode.Fail, err?.response?.data ?? err?.message ?? err, null)];
     }
 };
-const C2C_MESSAGE_CREATE = async (client, event, val) => {
+const C2C_MESSAGE_CREATE = async (client, event, val, options) => {
     const baseParams = buildBaseParams(event._tag, event.MessageId, 'INTERACTION_CREATE_C2C');
     const content = extractContent(val, 'group');
     try {
-        return await sendOpenApiMessage(content, val, baseParams, data => client.postRichMediaByUser(event.UserId, data), data => client.usersOpenMessages(event.UserId, data), 'client.usersOpenMessages');
+        return await sendOpenApiMessage(content, val, baseParams, data => client.postRichMediaByUser(event.UserId, data), data => client.usersOpenMessages(event.UserId, data), 'client.usersOpenMessages', options);
     }
     catch (err) {
         return [createResult(ResultCode.Fail, err?.response?.data ?? err?.message ?? err, null)];