Improve fix: only suppress card change events for forward messages

Changed the condition to specifically check for forward message elements (multiForwardMsgElement or arkElement) before suppressing empty card name changes. This ensures legitimate card name clearing (setting to empty) still works correctly while preventing false positives from forward messages.

Co-authored-by: sj817 <74231782+sj817@users.noreply.github.com>

README.md

@@ -13,6 +13,15 @@ _Modern protocol-side framework implemented based on NTQQ._
 
 ---
 
+## New Feature
+在 v4.8.115+ 版本开始
+
+1. NapCatQQ 支持 [Stream Api](https://napneko.github.io/develop/file)
+2. NapCatQQ 推荐 message_id/user_id/group_id 均使用字符串类型
+
+- [1] 解决 Docker/跨设备/大文件 的多媒体上下传问题
+- [2] 采用字符串可以解决扩展到int64的问题，同时也可以解决部分语言（如JavaScript）对大整数支持不佳的问题，增加极少成本。
+
 ## Welcome
 + NapCatQQ is a modern implementation of the Bot protocol based on NTQQ.
   - NapCatQQ 是现代化的基于 NTQQ 的 Bot 协议端实现
@@ -33,6 +42,7 @@ _Modern protocol-side framework implemented based on NTQQ._
 
 **首次使用**请务必查看如下文档看使用教程
 
+> 项目非盈利，对接问题/基础问题/下层框架问题 请自行搜索解决，本项目社区不提供此类解答。
 ## Link
 
 | Docs | [![Github.IO](https://img.shields.io/badge/docs%20on-Github.IO-orange)](https://napneko.github.io/) | [![Cloudflare.Worker](https://img.shields.io/badge/docs%20on-Cloudflare.Worker-black)](https://doc.napneko.icu/) | [![Cloudflare.HKServer](https://img.shields.io/badge/docs%20on-Cloudflare.HKServer-informational)](https://napcat.napneko.icu/) |
@@ -41,12 +51,17 @@ _Modern protocol-side framework implemented based on NTQQ._
 | Docs | [![Cloudflare.Pages](https://img.shields.io/badge/docs%20on-Cloudflare.Pages-blue)](https://napneko.pages.dev/) | [![Server.Other](https://img.shields.io/badge/docs%20on-Server.Other-green)](https://napcat.cyou/) | [![NapCat.Wiki](https://img.shields.io/badge/docs%20on-NapCat.Wiki-red)](https://www.napcat.wiki) |
 |:-:|:-:|:-:|:-:|
 
-| QQ Group | [![QQ Group#4](https://img.shields.io/badge/QQ%20Group%234-Join-blue)](https://qm.qq.com/q/CMmPbGw0jA) | [![QQ Group#3](https://img.shields.io/badge/QQ%20Group%233-Join-blue)](https://qm.qq.com/q/8zJMLjqy2Y) | [![QQ Group#2](https://img.shields.io/badge/QQ%20Group%232-Join-blue)](https://qm.qq.com/q/HaRcfrHpUk) | [![QQ Group#1](https://img.shields.io/badge/QQ%20Group%231-Join-blue)](https://qm.qq.com/q/I6LU87a0Yq) |
+| QQ Group | [![QQ Group#4](https://img.shields.io/badge/QQ%20Group%234-Join-blue)](https://qm.qq.com/q/CMmPbGw0jA) | [![QQ Group#3](https://img.shields.io/badge/QQ%20Group%233-Join-blue)](https://qm.qq.com/q/8zJMLjqy2Y) | [![QQ Group#2](https://img.shields.io/badge/QQ%20Group%232-Join-blue)](https://qm.qq.com/q/CMmPbGw0jA) | [![QQ Group#1](https://img.shields.io/badge/QQ%20Group%231-Join-blue)](https://qm.qq.com/q/I6LU87a0Yq) |
 |:-:|:-:|:-:|:-:|:-:|
 
 | Telegram | [![Telegram](https://img.shields.io/badge/Telegram-napcatqq-blue)](https://t.me/napcatqq) |
 |:-:|:-:|
 
+| DeepWiki | [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/NapNeko/NapCatQQ) |
+|:-:|:-:|
+
+> 请不要在其余社区提及本项目(包括其余协议端/相关应用端项目)引发争论，如有建议到达官方交流群讨论或PR。
+
 ## Thanks
 
 + [Lagrange](https://github.com/LagrangeDev/Lagrange.Core) 对本项目的大力支持 参考部分代码 已获授权

manifest.json

@@ -4,7 +4,7 @@
   "name": "NapCatQQ",
   "slug": "NapCat.Framework",
   "description": "高性能的 OneBot 11 协议实现",
-  "version": "4.8.111",
+  "version": "4.8.116",
   "icon": "./logo.png",
   "authors": [
     {

package.json

@@ -2,7 +2,7 @@
   "name": "napcat",
   "private": true,
   "type": "module",
-  "version": "4.8.111",
+  "version": "4.8.116",
   "scripts": {
     "build:universal": "npm run build:webui && vite build --mode universal || exit 1",
     "build:framework": "npm run build:webui && vite build --mode framework || exit 1",

src/common/version.ts

@@ -1 +1 @@
-export const napCatVersion = '4.8.111';
+export const napCatVersion = '4.8.116';

src/onebot/action/OneBotAction.ts

@@ -4,9 +4,10 @@ import { NapCatCore } from '@/core';
 import { NapCatOneBot11Adapter, OB11Return } from '@/onebot';
 import { NetworkAdapterConfig } from '../config/config';
 import { TSchema } from '@sinclair/typebox';
+import { StreamPacket, StreamPacketBasic, StreamStatus } from './stream/StreamBasic';
 
 export class OB11Response {
-    private static createResponse<T>(data: T, status: string, retcode: number, message: string = '', echo: unknown = null): OB11Return<T> {
+    private static createResponse<T>(data: T, status: string, retcode: number, message: string = '', echo: unknown = null, useStream: boolean = false): OB11Return<T> {
         return {
             status,
             retcode,
@@ -14,28 +15,32 @@ export class OB11Response {
             message,
             wording: message,
             echo,
+            stream: useStream ? 'stream-action' : 'normal-action'
         };
     }
 
-    static res<T>(data: T, status: string, retcode: number, message: string = ''): OB11Return<T> {
-        return this.createResponse(data, status, retcode, message);
+    static res<T>(data: T, status: string, retcode: number, message: string = '', echo: unknown = null, useStream: boolean = false): OB11Return<T> {
+        return this.createResponse(data, status, retcode, message, echo, useStream);
     }
 
-    static ok<T>(data: T, echo: unknown = null): OB11Return<T> {
-        return this.createResponse(data, 'ok', 0, '', echo);
+    static ok<T>(data: T, echo: unknown = null, useStream: boolean = false): OB11Return<T> {
+        return this.createResponse(data, 'ok', 0, '', echo, useStream);
     }
 
-    static error(err: string, retcode: number, echo: unknown = null): OB11Return<null> {
-        return this.createResponse(null, 'failed', retcode, err, echo);
+    static error(err: string, retcode: number, echo: unknown = null, useStream: boolean = false): OB11Return<null | StreamPacketBasic> {
+        return this.createResponse(useStream ? { type: StreamStatus.Error, data_type: 'error' } : null, 'failed', retcode, err, echo, useStream);
     }
 }
-
+export abstract class OneBotRequestToolkit {
+    abstract send<T>(packet: StreamPacket<T>): Promise<void>;
+}
 export abstract class OneBotAction<PayloadType, ReturnDataType> {
     actionName: typeof ActionName[keyof typeof ActionName] = ActionName.Unknown;
     core: NapCatCore;
     private validate?: ValidateFunction<unknown> = undefined;
     payloadSchema?: TSchema = undefined;
     obContext: NapCatOneBot11Adapter;
+    useStream: boolean = false;
 
     constructor(obContext: NapCatOneBot11Adapter, core: NapCatCore) {
         this.obContext = obContext;
@@ -57,33 +62,33 @@ export abstract class OneBotAction<PayloadType, ReturnDataType> {
         return { valid: true };
     }
 
-    public async handle(payload: PayloadType, adaptername: string, config: NetworkAdapterConfig): Promise<OB11Return<ReturnDataType | null>> {
+    public async handle(payload: PayloadType, adaptername: string, config: NetworkAdapterConfig, req: OneBotRequestToolkit = { send: async () => { } }, echo?: string): Promise<OB11Return<ReturnDataType | StreamPacketBasic | null>> {
         const result = await this.check(payload);
         if (!result.valid) {
             return OB11Response.error(result.message, 400);
         }
         try {
-            const resData = await this._handle(payload, adaptername, config);
-            return OB11Response.ok(resData);
+            const resData = await this._handle(payload, adaptername, config, req);
+            return OB11Response.ok(resData, echo, this.useStream);
         } catch (e: unknown) {
             this.core.context.logger.logError('发生错误', e);
-            return OB11Response.error((e as Error).message.toString() || (e as Error)?.stack?.toString() || '未知错误，可能操作超时', 200);
+            return OB11Response.error((e as Error).message.toString() || (e as Error)?.stack?.toString() || '未知错误，可能操作超时', 200, echo, this.useStream);
         }
     }
 
-    public async websocketHandle(payload: PayloadType, echo: unknown, adaptername: string, config: NetworkAdapterConfig): Promise<OB11Return<ReturnDataType | null>> {
+    public async websocketHandle(payload: PayloadType, echo: unknown, adaptername: string, config: NetworkAdapterConfig, req: OneBotRequestToolkit = { send: async () => { } }): Promise<OB11Return<ReturnDataType | StreamPacketBasic | null>> {
         const result = await this.check(payload);
         if (!result.valid) {
-            return OB11Response.error(result.message, 1400, echo);
+            return OB11Response.error(result.message, 1400, echo, this.useStream);
         }
         try {
-            const resData = await this._handle(payload, adaptername, config);
-            return OB11Response.ok(resData, echo);
+            const resData = await this._handle(payload, adaptername, config, req);
+            return OB11Response.ok(resData, echo, this.useStream);
         } catch (e: unknown) {
             this.core.context.logger.logError('发生错误', e);
-            return OB11Response.error(((e as Error).message.toString() || (e as Error).stack?.toString()) ?? 'Error', 1200, echo);
+            return OB11Response.error(((e as Error).message.toString() || (e as Error).stack?.toString()) ?? 'Error', 1200, echo, this.useStream);
         }
     }
 
-    abstract _handle(payload: PayloadType, adaptername: string, config: NetworkAdapterConfig): Promise<ReturnDataType>;
+    abstract _handle(payload: PayloadType, adaptername: string, config: NetworkAdapterConfig, req: OneBotRequestToolkit): Promise<ReturnDataType>;
 }

src/onebot/action/file/GetFile.ts

@@ -41,12 +41,12 @@ export class GetFileBase extends OneBotAction<GetFilePayload, GetFileResponse> {
             let url = '';
             if (mixElement?.picElement && rawMessage) {
                 const tempData =
-                    await this.obContext.apis.MsgApi.rawToOb11Converters.picElement?.(mixElement?.picElement, rawMessage, mixElement, { parseMultMsg: false }) as OB11MessageImage | undefined;
+                    await this.obContext.apis.MsgApi.rawToOb11Converters.picElement?.(mixElement?.picElement, rawMessage, mixElement, { parseMultMsg: false, disableGetUrl: false, quick_reply: true }) as OB11MessageImage | undefined;
                 url = tempData?.data.url ?? '';
             }
             if (mixElement?.videoElement && rawMessage) {
                 const tempData =
-                    await this.obContext.apis.MsgApi.rawToOb11Converters.videoElement?.(mixElement?.videoElement, rawMessage, mixElement, { parseMultMsg: false }) as OB11MessageVideo | undefined;
+                    await this.obContext.apis.MsgApi.rawToOb11Converters.videoElement?.(mixElement?.videoElement, rawMessage, mixElement, { parseMultMsg: false, disableGetUrl: false, quick_reply: true }) as OB11MessageVideo | undefined;
                 url = tempData?.data.url ?? '';
             }
             const res: GetFileResponse = {

src/onebot/action/index.ts

@@ -130,10 +130,18 @@ import { DoGroupAlbumComment } from './extends/DoGroupAlbumComment';
 import { GetGroupAlbumMediaList } from './extends/GetGroupAlbumMediaList';
 import { SetGroupAlbumMediaLike } from './extends/SetGroupAlbumMediaLike';
 import { DelGroupAlbumMedia } from './extends/DelGroupAlbumMedia';
+import { CleanStreamTempFile } from './stream/CleanStreamTempFile';
+import { DownloadFileStream } from './stream/DownloadFileStream';
+import { TestDownloadStream } from './stream/TestStreamDownload';
+import { UploadFileStream } from './stream/UploadFileStream';
 
 export function createActionMap(obContext: NapCatOneBot11Adapter, core: NapCatCore) {
 
     const actionHandlers = [
+        new CleanStreamTempFile(obContext, core),
+        new DownloadFileStream(obContext, core),
+        new TestDownloadStream(obContext, core),
+        new UploadFileStream(obContext, core),
         new DelGroupAlbumMedia(obContext, core),
         new SetGroupAlbumMediaLike(obContext, core),
         new DoGroupAlbumComment(obContext, core),

src/onebot/action/router.ts

@@ -10,6 +10,14 @@ export interface InvalidCheckResult {
 }
 
 export const ActionName = {
+    // 所有 Normal Stream Api 表示并未流传输 表示与流传输有关
+    CleanStreamTempFile: 'clean_stream_temp_file',
+
+    // 所有 Upload/Download Stream Api 应当 _stream 结尾
+     TestDownloadStream: 'test_download_stream',
+    UploadFileStream: 'upload_file_stream',
+    DownloadFileStream: 'download_file_stream',
+
     DelGroupAlbumMedia: 'del_group_album_media',
     SetGroupAlbumMediaLike: 'set_group_album_media_like',
     DoGroupAlbumComment: 'do_group_album_comment',

src/onebot/action/stream/CleanStreamTempFile.ts

@@ -0,0 +1,33 @@
+import { ActionName } from '@/onebot/action/router';
+import { OneBotAction } from '@/onebot/action/OneBotAction';
+import { join } from 'node:path';
+import { readdir, unlink } from 'node:fs/promises';
+
+export class CleanStreamTempFile extends OneBotAction<void, void> {
+    override actionName = ActionName.CleanStreamTempFile;
+
+    async _handle(_payload: void): Promise<void> {
+        try {
+            // 获取临时文件夹路径
+            const tempPath = this.core.NapCatTempPath;
+
+            // 读取文件夹中的所有文件
+            const files = await readdir(tempPath);
+
+            // 删除每个文件
+            const deletePromises = files.map(async (file) => {
+                const filePath = join(tempPath, file);
+                try {
+                    await unlink(filePath);
+                    this.core.context.logger.log(`已删除文件: ${filePath}`);
+                } catch (err: unknown) {
+                    this.core.context.logger.log(`删除文件 ${filePath} 失败: ${(err as Error).message}`);
+
+                }
+            });
+            await Promise.all(deletePromises);
+        } catch (err: unknown) {
+            this.core.context.logger.log(`清理流临时文件失败: ${(err as Error).message}`);
+        }
+    }
+}

src/onebot/action/stream/DownloadFileStream.ts

@@ -0,0 +1,133 @@
+import { ActionName } from '@/onebot/action/router';
+import { OneBotAction, OneBotRequestToolkit } from '@/onebot/action/OneBotAction';
+import { Static, Type } from '@sinclair/typebox';
+import { NetworkAdapterConfig } from '@/onebot/config/config';
+import { StreamPacket, StreamStatus } from './StreamBasic';
+import fs from 'fs';
+import { FileNapCatOneBotUUID } from '@/common/file-uuid';
+const SchemaData = Type.Object({
+    file: Type.Optional(Type.String()),
+    file_id: Type.Optional(Type.String()),
+    chunk_size: Type.Optional(Type.Number({ default: 64 * 1024 })) // 默认64KB分块
+});
+
+type Payload = Static<typeof SchemaData>;
+
+// 下载结果类型
+interface DownloadResult {
+    // 文件信息
+    file_name?: string;
+    file_size?: number;
+    chunk_size?: number;
+
+    // 分片数据
+    index?: number;
+    data?: string;
+    size?: number;
+    progress?: number;
+    base64_size?: number;
+
+    // 完成信息
+    total_chunks?: number;
+    total_bytes?: number;
+    message?: string;
+    data_type?: 'file_info' | 'file_chunk' | 'file_complete';
+}
+
+export class DownloadFileStream extends OneBotAction<Payload, StreamPacket<DownloadResult>> {
+    override actionName = ActionName.DownloadFileStream;
+    override payloadSchema = SchemaData;
+    override useStream = true;
+
+    async _handle(payload: Payload, _adaptername: string, _config: NetworkAdapterConfig, req: OneBotRequestToolkit): Promise<StreamPacket<DownloadResult>> {
+        try {
+            payload.file ||= payload.file_id || '';
+            const chunkSize = payload.chunk_size || 64 * 1024;
+            let downloadPath = '';
+            let fileName = '';
+            let fileSize = 0;
+
+            //接收消息标记模式
+            const contextMsgFile = FileNapCatOneBotUUID.decode(payload.file);
+            if (contextMsgFile && contextMsgFile.msgId && contextMsgFile.elementId) {
+                const { peer, msgId, elementId } = contextMsgFile;
+                downloadPath = await this.core.apis.FileApi.downloadMedia(msgId, peer.chatType, peer.peerUid, elementId, '', '');
+                const rawMessage = (await this.core.apis.MsgApi.getMsgsByMsgId(peer, [msgId]))?.msgList
+                    .find(msg => msg.msgId === msgId);
+                const mixElement = rawMessage?.elements.find(e => e.elementId === elementId);
+                const mixElementInner = mixElement?.videoElement ?? mixElement?.fileElement ?? mixElement?.pttElement ?? mixElement?.picElement;
+                if (!mixElementInner) throw new Error('element not found');
+                fileSize = parseInt(mixElementInner.fileSize?.toString() ?? '0');
+                fileName = mixElementInner.fileName ?? '';
+            }
+            //群文件模式
+            else if (FileNapCatOneBotUUID.decodeModelId(payload.file)) {
+                const contextModelIdFile = FileNapCatOneBotUUID.decodeModelId(payload.file);
+                if (contextModelIdFile && contextModelIdFile.modelId) {
+                    const { peer, modelId } = contextModelIdFile;
+                    downloadPath = await this.core.apis.FileApi.downloadFileForModelId(peer, modelId, '');
+                }
+            }
+            //搜索名字模式
+            else {
+                const searchResult = (await this.core.apis.FileApi.searchForFile([payload.file]));
+                if (searchResult) {
+                    downloadPath = await this.core.apis.FileApi.downloadFileById(searchResult.id, parseInt(searchResult.fileSize));
+                    fileSize = parseInt(searchResult.fileSize);
+                    fileName = searchResult.fileName;
+                }
+            }
+
+            if (!downloadPath) {
+                throw new Error('file not found');
+            }
+
+            // 获取文件大小
+            const stats = await fs.promises.stat(downloadPath);
+            const totalSize = fileSize || stats.size;
+
+            // 发送文件信息
+            await req.send({
+                type: StreamStatus.Stream,
+                data_type: 'file_info',
+                file_name: fileName,
+                file_size: totalSize,
+                chunk_size: chunkSize
+            });
+
+            // 创建读取流并分块发送
+            const readStream = fs.createReadStream(downloadPath, { highWaterMark: chunkSize });
+            let chunkIndex = 0;
+            let bytesRead = 0;
+
+            for await (const chunk of readStream) {
+                const base64Chunk = chunk.toString('base64');
+                bytesRead += chunk.length;
+
+               await req.send({
+                    type: StreamStatus.Stream,
+                    data_type: 'file_chunk',
+                    index: chunkIndex,
+                    data: base64Chunk,
+                    size: chunk.length,
+                    progress: Math.round((bytesRead / totalSize) * 100),
+                    base64_size: base64Chunk.length
+                });
+
+                chunkIndex++;
+            }
+
+            // 返回完成状态
+            return {
+                type: StreamStatus.Response,
+                data_type: 'file_complete',
+                total_chunks: chunkIndex,
+                total_bytes: bytesRead,
+                message: 'Download completed'
+            };
+
+        } catch (error) {
+            throw new Error(`Download failed: ${(error as Error).message}`);
+        }
+    }
+}

src/onebot/action/stream/Readme.txt

@@ -0,0 +1,3 @@
+# Stream-Api
+
+## 流式接口

src/onebot/action/stream/StreamBasic.ts

@@ -0,0 +1,16 @@
+import { OneBotAction, OneBotRequestToolkit } from "../OneBotAction";
+import { NetworkAdapterConfig } from "@/onebot/config/config";
+export type StreamPacketBasic =   {
+    type: StreamStatus;
+    data_type?: string;
+};
+export type StreamPacket<T> = T & StreamPacketBasic;
+export enum StreamStatus {
+    Stream = 'stream', // 分片流数据包
+    Response = 'response', // 流最终响应
+    Reset = 'reset', // 重置流
+    Error = 'error' // 流错误
+}
+export abstract class BasicStream<T, R> extends OneBotAction<T, StreamPacket<R>> {
+    abstract override _handle(_payload: T, _adaptername: string, _config: NetworkAdapterConfig, req: OneBotRequestToolkit): Promise<StreamPacket<R>>;
+}

src/onebot/action/stream/TestStreamDownload.ts

@@ -0,0 +1,32 @@
+import { ActionName } from '@/onebot/action/router';
+import { OneBotAction, OneBotRequestToolkit } from '@/onebot/action/OneBotAction';
+import { Static, Type } from '@sinclair/typebox';
+import { NetworkAdapterConfig } from '@/onebot/config/config';
+import { StreamPacket, StreamStatus } from './StreamBasic';
+
+const SchemaData = Type.Object({
+    error: Type.Optional(Type.Boolean({ default: false }))
+});
+
+type Payload = Static<typeof SchemaData>;
+
+export class TestDownloadStream extends OneBotAction<Payload, StreamPacket<{ data: string }>> {
+    override actionName = ActionName.TestDownloadStream;
+    override payloadSchema = SchemaData;
+    override useStream = true;
+
+    async _handle(_payload: Payload, _adaptername: string, _config: NetworkAdapterConfig, req: OneBotRequestToolkit) {
+        for (let i = 0; i < 10; i++) {
+            await req.send({ type: StreamStatus.Stream, data: `Index-> ${i + 1}`, data_type: 'data_chunk' });
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        if( _payload.error ){
+            throw new Error('This is a test error');
+        }
+        return {
+            type: StreamStatus.Response,
+            data_type: 'data_complete',
+            data: 'Stream transmission complete'
+        };
+    }
+}

src/onebot/action/stream/UploadFileStream.ts

@@ -0,0 +1,346 @@
+import { ActionName } from '@/onebot/action/router';
+import { OneBotAction } from '@/onebot/action/OneBotAction';
+import { Static, Type } from '@sinclair/typebox';
+import { NetworkAdapterConfig } from '@/onebot/config/config';
+import { StreamPacket, StreamStatus } from './StreamBasic';
+import fs from 'fs';
+import { join as joinPath } from 'node:path';
+import { randomUUID } from 'crypto';
+import { createHash } from 'crypto';
+import { unlink } from 'node:fs';
+
+// 简化配置
+const CONFIG = {
+    TIMEOUT: 10 * 60 * 1000,           // 10分钟超时
+    MEMORY_THRESHOLD: 10 * 1024 * 1024, // 10MB，超过使用磁盘
+    MEMORY_LIMIT: 100 * 1024 * 1024     // 100MB内存总限制
+} as const;
+
+const SchemaData = Type.Object({
+    stream_id: Type.String(),
+    chunk_data: Type.Optional(Type.String()),
+    chunk_index: Type.Optional(Type.Number()),
+    total_chunks: Type.Optional(Type.Number()),
+    file_size: Type.Optional(Type.Number()),
+    expected_sha256: Type.Optional(Type.String()),
+    is_complete: Type.Optional(Type.Boolean()),
+    filename: Type.Optional(Type.String()),
+    reset: Type.Optional(Type.Boolean()),
+    verify_only: Type.Optional(Type.Boolean()),
+    file_retention: Type.Number({ default: 5 * 60 * 1000 }) // 默认5分钟 回收 不设置或0为不回收
+});
+
+type Payload = Static<typeof SchemaData>;
+
+// 简化流状态接口
+interface StreamState {
+    id: string;
+    filename: string;
+    totalChunks: number;
+    receivedChunks: number;
+    missingChunks: Set<number>;
+
+    // 可选属性
+    fileSize?: number;
+    expectedSha256?: string;
+
+    // 存储策略
+    useMemory: boolean;
+    memoryChunks?: Map<number, Buffer>;
+    tempDir?: string;
+    finalPath?: string;
+    fileRetention?: number;
+
+    // 管理
+    createdAt: number;
+    timeoutId: NodeJS.Timeout;
+}
+
+interface StreamResult {
+    stream_id: string;
+    status: 'file_created' | 'chunk_received' | 'file_complete';
+    received_chunks: number;
+    total_chunks: number;
+    file_path?: string;
+    file_size?: number;
+    sha256?: string;
+}
+
+export class UploadFileStream extends OneBotAction<Payload, StreamPacket<StreamResult>> {
+    override actionName = ActionName.UploadFileStream;
+    override payloadSchema = SchemaData;
+    override useStream = true;
+
+    private static streams = new Map<string, StreamState>();
+    private static memoryUsage = 0;
+
+    async _handle(payload: Payload, _adaptername: string, _config: NetworkAdapterConfig): Promise<StreamPacket<StreamResult>> {
+        const { stream_id, reset, verify_only } = payload;
+
+        if (reset) {
+            this.cleanupStream(stream_id);
+            throw new Error('Stream reset completed');
+        }
+
+        if (verify_only) {
+            const stream = UploadFileStream.streams.get(stream_id);
+            if (!stream) throw new Error('Stream not found');
+            return this.getStreamStatus(stream);
+        }
+
+        const stream = this.getOrCreateStream(payload);
+
+        if (payload.chunk_data && payload.chunk_index !== undefined) {
+            return await this.processChunk(stream, payload.chunk_data, payload.chunk_index);
+        }
+
+        if (payload.is_complete || stream.receivedChunks === stream.totalChunks) {
+            return await this.completeStream(stream);
+        }
+
+        return this.getStreamStatus(stream);
+    }
+
+
+
+    private getOrCreateStream(payload: Payload): StreamState {
+        let stream = UploadFileStream.streams.get(payload.stream_id);
+
+        if (!stream) {
+            if (!payload.total_chunks) {
+                throw new Error('total_chunks required for new stream');
+            }
+            stream = this.createStream(payload);
+        }
+
+        return stream;
+    }
+
+    private createStream(payload: Payload): StreamState {
+        const { stream_id, total_chunks, file_size, filename, expected_sha256 } = payload;
+
+        const useMemory = this.shouldUseMemory(file_size);
+        if (useMemory && file_size && (UploadFileStream.memoryUsage + file_size) > CONFIG.MEMORY_LIMIT) {
+            throw new Error('Memory limit exceeded');
+        }
+
+        const stream: StreamState = {
+            id: stream_id,
+            filename: filename || `upload_${randomUUID()}`,
+            totalChunks: total_chunks!,
+            receivedChunks: 0,
+            missingChunks: new Set(Array.from({ length: total_chunks! }, (_, i) => i)),
+            fileSize: file_size,
+            expectedSha256: expected_sha256,
+            useMemory,
+            createdAt: Date.now(),
+            timeoutId: this.setupTimeout(stream_id),
+            fileRetention: payload.file_retention
+        };
+        try {
+            if (useMemory) {
+                stream.memoryChunks = new Map();
+                if (file_size) UploadFileStream.memoryUsage += file_size;
+            } else {
+                this.setupDiskStorage(stream);
+            }
+
+            UploadFileStream.streams.set(stream_id, stream);
+            return stream;
+        } catch (error) {
+            // 如果设置存储失败，清理已创建的资源
+            clearTimeout(stream.timeoutId);
+            if (stream.tempDir && fs.existsSync(stream.tempDir)) {
+                try {
+                    fs.rmSync(stream.tempDir, { recursive: true, force: true });
+                } catch (cleanupError) {
+                    console.error(`Failed to cleanup temp dir during creation error:`, cleanupError);
+                }
+            }
+            throw error;
+        }
+    }
+
+    private shouldUseMemory(fileSize?: number): boolean {
+        return fileSize !== undefined && fileSize <= CONFIG.MEMORY_THRESHOLD;
+    }
+
+    private setupDiskStorage(stream: StreamState): void {
+        const tempDir = joinPath(this.core.NapCatTempPath, `upload_${stream.id}`);
+        const finalPath = joinPath(this.core.NapCatTempPath, stream.filename);
+
+        fs.mkdirSync(tempDir, { recursive: true });
+
+        stream.tempDir = tempDir;
+        stream.finalPath = finalPath;
+    }
+
+    private setupTimeout(streamId: string): NodeJS.Timeout {
+        return setTimeout(() => {
+            console.log(`Stream ${streamId} timeout`);
+            this.cleanupStream(streamId);
+        }, CONFIG.TIMEOUT);
+    }
+
+    private async processChunk(stream: StreamState, chunkData: string, chunkIndex: number): Promise<StreamPacket<StreamResult>> {
+        // 验证索引
+        if (chunkIndex < 0 || chunkIndex >= stream.totalChunks) {
+            throw new Error(`Invalid chunk index: ${chunkIndex}`);
+        }
+
+        // 检查重复
+        if (!stream.missingChunks.has(chunkIndex)) {
+            return this.getStreamStatus(stream);
+        }
+
+        const buffer = Buffer.from(chunkData, 'base64');
+
+        // 存储分片
+        if (stream.useMemory) {
+            stream.memoryChunks!.set(chunkIndex, buffer);
+        } else {
+            const chunkPath = joinPath(stream.tempDir!, `${chunkIndex}.chunk`);
+            await fs.promises.writeFile(chunkPath, buffer);
+        }
+
+        // 更新状态
+        stream.missingChunks.delete(chunkIndex);
+        stream.receivedChunks++;
+        this.refreshTimeout(stream);
+
+        return {
+            type: StreamStatus.Stream,
+            stream_id: stream.id,
+            status: 'chunk_received',
+            received_chunks: stream.receivedChunks,
+            total_chunks: stream.totalChunks
+        };
+    }
+
+    private refreshTimeout(stream: StreamState): void {
+        clearTimeout(stream.timeoutId);
+        stream.timeoutId = this.setupTimeout(stream.id);
+    }
+
+    private getStreamStatus(stream: StreamState): StreamPacket<StreamResult> {
+        return {
+            type: StreamStatus.Stream,
+            stream_id: stream.id,
+            status: 'file_created',
+            received_chunks: stream.receivedChunks,
+            total_chunks: stream.totalChunks
+        };
+    }
+
+    private async completeStream(stream: StreamState): Promise<StreamPacket<StreamResult>> {
+        // 合并分片
+        const finalBuffer = stream.useMemory ?
+            await this.mergeMemoryChunks(stream) :
+            await this.mergeDiskChunks(stream);
+
+        // 验证SHA256
+        const sha256 = this.validateSha256(stream, finalBuffer);
+
+        // 保存文件
+        const finalPath = stream.finalPath || joinPath(this.core.NapCatTempPath, stream.filename);
+        await fs.promises.writeFile(finalPath, finalBuffer);
+
+        // 清理资源但保留文件
+        this.cleanupStream(stream.id, false);
+        if (stream.fileRetention && stream.fileRetention > 0) {
+            setTimeout(() => {
+                unlink(finalPath, err => {
+                    if (err) this.core.context.logger.logError(`Failed to delete retained file ${finalPath}:`, err);
+                });
+            }, stream.fileRetention);
+        }
+        return {
+            type: StreamStatus.Response,
+            stream_id: stream.id,
+            status: 'file_complete',
+            received_chunks: stream.receivedChunks,
+            total_chunks: stream.totalChunks,
+            file_path: finalPath,
+            file_size: finalBuffer.length,
+            sha256
+        };
+    }
+
+    private async mergeMemoryChunks(stream: StreamState): Promise<Buffer> {
+        const chunks: Buffer[] = [];
+        for (let i = 0; i < stream.totalChunks; i++) {
+            const chunk = stream.memoryChunks!.get(i);
+            if (!chunk) throw new Error(`Missing memory chunk ${i}`);
+            chunks.push(chunk);
+        }
+        return Buffer.concat(chunks);
+    }
+
+    private async mergeDiskChunks(stream: StreamState): Promise<Buffer> {
+        const chunks: Buffer[] = [];
+        for (let i = 0; i < stream.totalChunks; i++) {
+            const chunkPath = joinPath(stream.tempDir!, `${i}.chunk`);
+            if (!fs.existsSync(chunkPath)) throw new Error(`Missing chunk file ${i}`);
+            chunks.push(await fs.promises.readFile(chunkPath));
+        }
+        return Buffer.concat(chunks);
+    }
+
+    private validateSha256(stream: StreamState, buffer: Buffer): string | undefined {
+        if (!stream.expectedSha256) return undefined;
+
+        const actualSha256 = createHash('sha256').update(buffer).digest('hex');
+        if (actualSha256 !== stream.expectedSha256) {
+            throw new Error(`SHA256 mismatch. Expected: ${stream.expectedSha256}, Got: ${actualSha256}`);
+        }
+        return actualSha256;
+    }
+
+    private cleanupStream(streamId: string, deleteFinalFile = true): void {
+        const stream = UploadFileStream.streams.get(streamId);
+        if (!stream) return;
+
+        try {
+            // 清理超时
+            clearTimeout(stream.timeoutId);
+
+            // 清理内存
+            if (stream.useMemory) {
+                if (stream.fileSize) {
+                    UploadFileStream.memoryUsage = Math.max(0, UploadFileStream.memoryUsage - stream.fileSize);
+                }
+                stream.memoryChunks?.clear();
+            }
+
+            // 清理临时文件夹及其所有内容
+            if (stream.tempDir) {
+                try {
+                    if (fs.existsSync(stream.tempDir)) {
+                        fs.rmSync(stream.tempDir, { recursive: true, force: true });
+                        console.log(`Cleaned up temp directory: ${stream.tempDir}`);
+                    }
+                } catch (error) {
+                    console.error(`Failed to cleanup temp directory ${stream.tempDir}:`, error);
+                }
+            }
+
+            // 删除最终文件（如果需要）
+            if (deleteFinalFile && stream.finalPath) {
+                try {
+                    if (fs.existsSync(stream.finalPath)) {
+                        fs.unlinkSync(stream.finalPath);
+                        console.log(`Deleted final file: ${stream.finalPath}`);
+                    }
+                } catch (error) {
+                    console.error(`Failed to delete final file ${stream.finalPath}:`, error);
+                }
+            }
+
+        } catch (error) {
+            console.error(`Cleanup error for stream ${streamId}:`, error);
+        } finally {
+            UploadFileStream.streams.delete(streamId);
+            console.log(`Stream ${streamId} cleaned up`);
+        }
+    }
+}

src/onebot/action/stream/test_upload_stream.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+NapCat OneBot WebSocket 文件流上传测试脚本
+用于测试 UploadFileStream 接口的一次性分片上传功能
+"""
+
+import asyncio
+import json
+import base64
+import hashlib
+import os
+import uuid
+from typing import List, Optional
+import websockets
+import argparse
+from pathlib import Path
+
+class OneBotUploadTester:
+    def __init__(self, ws_url: str = "ws://localhost:3001", access_token: Optional[str] = None):
+        self.ws_url = ws_url
+        self.access_token = access_token
+        self.websocket = None
+        
+    async def connect(self):
+        """连接到 OneBot WebSocket"""
+        headers = {}
+        if self.access_token:
+            headers["Authorization"] = f"Bearer {self.access_token}"
+            
+        print(f"连接到 {self.ws_url}")
+        self.websocket = await websockets.connect(self.ws_url, additional_headers=headers)
+        print("WebSocket 连接成功")
+        
+    async def disconnect(self):
+        """断开 WebSocket 连接"""
+        if self.websocket:
+            await self.websocket.close()
+            print("WebSocket 连接已断开")
+            
+    def calculate_file_chunks(self, file_path: str, chunk_size: int = 64) -> tuple[List[bytes], str, int]:
+        """
+        计算文件分片和 SHA256
+        
+        Args:
+            file_path: 文件路径
+            chunk_size: 分片大小（默认64KB）
+            
+        Returns:
+            (chunks, sha256_hash, total_size)
+        """
+        chunks = []
+        hasher = hashlib.sha256()
+        total_size = 0
+        
+        with open(file_path, 'rb') as f:
+            while True:
+                chunk = f.read(chunk_size)
+                if not chunk:
+                    break
+                chunks.append(chunk)
+                hasher.update(chunk)
+                total_size += len(chunk)
+                
+        sha256_hash = hasher.hexdigest()
+        print(f"文件分析完成:")
+        print(f"  - 文件大小: {total_size} 字节")
+        print(f"  - 分片数量: {len(chunks)}")
+        print(f"  - SHA256: {sha256_hash}")
+        
+        return chunks, sha256_hash, total_size
+    
+    async def send_action(self, action: str, params: dict, echo: str = None) -> dict:
+        """发送 OneBot 动作请求"""
+        if not echo:
+            echo = str(uuid.uuid4())
+            
+        message = {
+            "action": action,
+            "params": params,
+            "echo": echo
+        }
+        
+        print(f"发送请求: {action}")
+        await self.websocket.send(json.dumps(message))
+        
+        # 等待响应
+        while True:
+            response = await self.websocket.recv()
+            data = json.loads(response)
+            
+            # 检查是否是我们的响应
+            if data.get("echo") == echo:
+                return data
+            else:
+                # 可能是其他消息，继续等待
+                print(f"收到其他消息: {data}")
+                continue
+    
+    async def upload_file_stream_batch(self, file_path: str, chunk_size: int = 64 ) -> str:
+        """
+        一次性批量上传文件流
+        
+        Args:
+            file_path: 要上传的文件路径
+            chunk_size: 分片大小
+            
+        Returns:
+            上传完成后的文件路径
+        """
+        file_path = Path(file_path)
+        if not file_path.exists():
+            raise FileNotFoundError(f"文件不存在: {file_path}")
+            
+        # 分析文件
+        chunks, sha256_hash, total_size = self.calculate_file_chunks(str(file_path), chunk_size)
+        stream_id = str(uuid.uuid4())
+        
+        print(f"\n开始上传文件: {file_path.name}")
+        print(f"流ID: {stream_id}")
+        
+        # 一次性发送所有分片
+        total_chunks = len(chunks)
+        
+        for chunk_index, chunk_data in enumerate(chunks):
+            # 将分片数据编码为 base64
+            chunk_base64 = base64.b64encode(chunk_data).decode('utf-8')
+            
+            # 构建参数
+            params = {
+                "stream_id": stream_id,
+                "chunk_data": chunk_base64,
+                "chunk_index": chunk_index,
+                "total_chunks": total_chunks,
+                "file_size": total_size,
+                "expected_sha256": sha256_hash,
+                "filename": file_path.name,
+                "file_retention": 30 * 1000
+            }
+            
+            # 发送分片
+            response = await self.send_action("upload_file_stream", params)
+            
+            if response.get("status") != "ok":
+                raise Exception(f"上传分片 {chunk_index} 失败: {response}")
+                
+            # 解析流响应
+            stream_data = response.get("data", {})
+            print(f"分片 {chunk_index + 1}/{total_chunks} 上传成功 "
+                  f"(接收: {stream_data.get('received_chunks', 0)}/{stream_data.get('total_chunks', 0)})")
+        
+        # 发送完成信号
+        print(f"\n所有分片发送完成，请求文件合并...")
+        complete_params = {
+            "stream_id": stream_id,
+            "is_complete": True
+        }
+        
+        response = await self.send_action("upload_file_stream", complete_params)
+        
+        if response.get("status") != "ok":
+            raise Exception(f"文件合并失败: {response}")
+            
+        result = response.get("data", {})
+        
+        if result.get("status") == "file_complete":
+            print(f"✅ 文件上传成功!")
+            print(f"  - 文件路径: {result.get('file_path')}")
+            print(f"  - 文件大小: {result.get('file_size')} 字节")
+            print(f"  - SHA256: {result.get('sha256')}")
+            return result.get('file_path')
+        else:
+            raise Exception(f"文件状态异常: {result}")
+    
+    async def test_upload(self, file_path: str, chunk_size: int = 64 ):
+        """测试文件上传"""
+        try:
+            await self.connect()
+            
+            # 执行上传
+            uploaded_path = await self.upload_file_stream_batch(file_path, chunk_size)
+            
+            print(f"\n🎉 测试完成! 上传后的文件路径: {uploaded_path}")
+            
+        except Exception as e:
+            print(f"❌ 测试失败: {e}")
+            raise
+        finally:
+            await self.disconnect()
+
+def create_test_file(file_path: str, size_mb: float = 1):
+    """创建测试文件"""
+    size_bytes = int(size_mb * 1024 * 1024)
+    
+    with open(file_path, 'wb') as f:
+        # 写入一些有意义的测试数据
+        test_data = b"NapCat Upload Test Data - " * 100
+        written = 0
+        while written < size_bytes:
+            write_size = min(len(test_data), size_bytes - written)
+            f.write(test_data[:write_size])
+            written += write_size
+    
+    print(f"创建测试文件: {file_path} ({size_mb}MB)")
+
+async def main():
+    parser = argparse.ArgumentParser(description="NapCat OneBot 文件流上传测试")
+    parser.add_argument("--url", default="ws://localhost:3001", help="WebSocket URL")
+    parser.add_argument("--token", help="访问令牌")
+    parser.add_argument("--file", help="要上传的文件路径")
+    parser.add_argument("--chunk-size", type=int, default=64*1024, help="分片大小(字节)")
+    parser.add_argument("--create-test", type=float, help="创建测试文件(MB)")
+    
+    args = parser.parse_args()
+    
+    # 创建测试文件
+    if args.create_test:
+        test_file = "test_upload_file.bin"
+        create_test_file(test_file, args.create_test)
+        if not args.file:
+            args.file = test_file
+    
+    if not args.file:
+        print("请指定要上传的文件路径，或使用 --create-test 创建测试文件")
+        return
+    
+    # 创建测试器并运行
+    tester = OneBotUploadTester(args.url, args.token)
+    await tester.test_upload(args.file, args.chunk_size)
+
+if __name__ == "__main__":
+    # 安装依赖提示
+    try:
+        import websockets
+    except ImportError:
+        print("请先安装依赖: pip install websockets")
+        exit(1)
+    
+    asyncio.run(main())

src/onebot/api/group.ts

@@ -116,6 +116,17 @@ export class OneBotGroupApi {
             const member = await this.core.apis.GroupApi.getGroupMember(msg.peerUid, msg.senderUin);
             if (member && member.cardName !== msg.sendMemberName) {
                 const newCardName = msg.sendMemberName ?? '';
+                // 防止误触：如果消息包含转发元素且新名片为空，不触发事件（转发消息的sendMemberName不可靠）
+                const hasForwardElement = msg.elements.some(e => e.multiForwardMsgElement || e.arkElement);
+                if (newCardName === '' && member.cardName !== '' && hasForwardElement) {
+                    this.core.context.logger.logDebug('忽略转发消息的不可靠群名片变更事件', { 
+                        peerUid: msg.peerUid, 
+                        senderUin: msg.senderUin, 
+                        oldCard: member.cardName, 
+                        newCard: newCardName 
+                    });
+                    return undefined;
+                }
                 const event = new OB11GroupCardEvent(this.core, parseInt(msg.peerUid), parseInt(msg.senderUin), newCardName, member.cardName);
                 member.cardName = newCardName;
                 return event;

src/onebot/api/msg.ts

@@ -1124,10 +1124,13 @@ export class OneBotMsgApi {
             if (ignoreTypes.includes(sendMsg.type)) {
                 continue;
             }
-            const converter = this.ob11ToRawConverters[sendMsg.type] as (
+            const converter = this.ob11ToRawConverters[sendMsg.type] as ((
                 sendMsg: Extract<OB11MessageData, { type: OB11MessageData['type'] }>,
                 context: SendMessageContext,
-            ) => Promise<SendMessageElement | undefined>;
+            ) => Promise<SendMessageElement | undefined>) | undefined;
+            if (converter == undefined) {
+                throw new Error('未知的消息类型：' + sendMsg.type);
+            }
             const callResult = converter(
                 sendMsg,
                 { peer, deleteAfterSentFiles },

src/onebot/network/adapter.ts

@@ -23,7 +23,7 @@ export abstract class IOB11NetworkAdapter<CT extends NetworkAdapterConfig> {
         this.logger = core.context.logger;
     }
 
-    abstract onEvent<T extends OB11EmitEventContent>(event: T): void;
+    abstract onEvent<T extends OB11EmitEventContent>(event: T): Promise<void>;
 
     abstract open(): void | Promise<void>;
 

src/onebot/network/http-client.ts

@@ -16,7 +16,7 @@ export class OB11HttpClientAdapter extends IOB11NetworkAdapter<HttpClientConfig>
         super(name, config, core, obContext, actions);
     }
 
-    onEvent<T extends OB11EmitEventContent>(event: T) {
+    async onEvent<T extends OB11EmitEventContent>(event: T) {
         this.emitEventAsync(event).catch(e => this.logger.logError('[OneBot] [Http Client] 新消息事件HTTP上报返回快速操作失败', e));
     }
 

src/onebot/network/http-server-sse.ts

@@ -9,7 +9,7 @@ export class OB11HttpSSEServerAdapter extends OB11HttpServerAdapter {
         if (req.path === '/_events') {
             this.createSseSupport(req, res);
         } else {
-            super.httpApiRequest(req, res);
+            super.httpApiRequest(req, res, true);
         }
     }
 
@@ -23,11 +23,22 @@ export class OB11HttpSSEServerAdapter extends OB11HttpServerAdapter {
         req.on('close', () => {
             this.sseClients = this.sseClients.filter((client) => client !== res);
         });
+
     }
 
-    override onEvent<T extends OB11EmitEventContent>(event: T) {
+    override async onEvent<T extends OB11EmitEventContent>(event: T) {
+        let promises: Promise<void>[] = [];
         this.sseClients.forEach((res) => {
-            res.write(`data: ${JSON.stringify(event)}\n\n`);
+            promises.push(new Promise<void>((resolve, reject) => {
+                res.write(`data: ${JSON.stringify(event)}\n\n`, (err) => {
+                    if (err) {
+                        reject(err);
+                    } else {
+                        resolve();
+                    }
+                });
+            }));
         });
+        await Promise.allSettled(promises);
     }
 }

src/onebot/network/http-server.ts

@@ -20,7 +20,7 @@ export class OB11HttpServerAdapter extends IOB11NetworkAdapter<HttpServerConfig>
     }
 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    override onEvent<T extends OB11EmitEventContent>(_event: T) {
+    override async onEvent<T extends OB11EmitEventContent>(_event: T) {
         // http server is passive, no need to emit event
     }
 
@@ -104,7 +104,7 @@ export class OB11HttpServerAdapter extends IOB11NetworkAdapter<HttpServerConfig>
         }
     }
 
-    async httpApiRequest(req: Request, res: Response) {
+    async httpApiRequest(req: Request, res: Response, request_sse: boolean = false) {
         let payload = req.body;
         if (req.method == 'get') {
             payload = req.query;
@@ -117,17 +117,35 @@ export class OB11HttpServerAdapter extends IOB11NetworkAdapter<HttpServerConfig>
             return res.json(hello);
         }
         const actionName = req.path.split('/')[1];
+        const payload_echo = payload['echo'];
+        const real_echo = payload_echo ?? Math.random().toString(36).substring(2, 15);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const action = this.actions.get(actionName as any);
         if (action) {
+            const useStream = action.useStream;
             try {
-                const result = await action.handle(payload, this.name, this.config);
+                const result = await action.handle(payload, this.name, this.config, {
+                    send: request_sse ? async (data: object) => {
+                        await this.onEvent({ ...OB11Response.ok(data, real_echo, true) } as unknown as OB11EmitEventContent);
+                    } : async (data: object) => {
+                        let newPromise = new Promise<void>((resolve, _reject) => {
+                            res.write(JSON.stringify({ ...OB11Response.ok(data, real_echo, true) }) + "\r\n\r\n", () => {
+                                resolve();
+                            });
+                        });
+                        return newPromise;
+                    }
+                }, real_echo);
+                if (useStream) {
+                    res.write(JSON.stringify({ ...result }) + "\r\n\r\n");
+                    return res.end();
+                };
                 return res.json(result);
             } catch (error: unknown) {
-                return res.json(OB11Response.error((error as Error)?.stack?.toString() || (error as Error)?.message || 'Error Handle', 200));
+                return res.json(OB11Response.error((error as Error)?.stack?.toString() || (error as Error)?.message || 'Error Handle', 200, real_echo));
             }
         } else {
-            return res.json(OB11Response.error('不支持的Api ' + actionName, 200));
+            return res.json(OB11Response.error('不支持的Api ' + actionName, 200, real_echo));
         }
     }
 

src/onebot/network/index.ts

@@ -20,9 +20,9 @@ export class OB11NetworkManager {
     }
 
     async emitEvent(event: OB11EmitEventContent) {
-        return Promise.all(Array.from(this.adapters.values()).map(adapter => {
+        return Promise.all(Array.from(this.adapters.values()).map(async adapter => {
             if (adapter.isEnable) {
-                return adapter.onEvent(event);
+                return await adapter.onEvent(event);
             }
         }));
     }
@@ -32,19 +32,19 @@ export class OB11NetworkManager {
     }
 
     async emitEventByName(names: string[], event: OB11EmitEventContent) {
-        return Promise.all(names.map(name => {
+        return Promise.all(names.map(async name => {
             const adapter = this.adapters.get(name);
             if (adapter && adapter.isEnable) {
-                return adapter.onEvent(event);
+                return await adapter.onEvent(event);
             }
         }));
     }
 
     async emitEventByNames(map: Map<string, OB11EmitEventContent>) {
-        return Promise.all(Array.from(map.entries()).map(([name, event]) => {
+        return Promise.all(Array.from(map.entries()).map(async ([name, event]) => {
             const adapter = this.adapters.get(name);
             if (adapter && adapter.isEnable) {
-                return adapter.onEvent(event);
+                return await adapter.onEvent(event);
             }
         }));
     }

src/onebot/network/plugin-manger.ts

@@ -251,14 +251,20 @@ export class OB11PluginMangerAdapter extends IOB11NetworkAdapter<PluginConfig> {
         this.logger.log(`[Plugin Adapter] Unloaded plugin: ${pluginName}`);
     }
 
-    onEvent<T extends OB11EmitEventContent>(event: T) {
+    async onEvent<T extends OB11EmitEventContent>(event: T) {
         if (!this.isEnable) {
             return;
         }
 
         // 遍历所有已加载的插件，调用它们的事件处理方法
-        for (const [, plugin] of this.loadedPlugins) {
-            this.callPluginEventHandler(plugin, event);
+        try {
+            await Promise.allSettled(
+                Array.from(this.loadedPlugins.values()).map((plugin) =>
+                    this.callPluginEventHandler(plugin, event)
+                )
+            );
+        } catch (error) {
+            this.logger.logError('[Plugin Adapter] Error handling event:', error);
         }
     }
 

src/onebot/network/plugin.ts

@@ -251,7 +251,7 @@ export class OB11PluginAdapter extends IOB11NetworkAdapter<PluginConfig> {
         this.logger.log(`[Plugin Adapter] Unloaded plugin: ${pluginName}`);
     }
 
-    onEvent<T extends OB11EmitEventContent>(event: T) {
+    async onEvent<T extends OB11EmitEventContent>(event: T) {
         if (!this.isEnable) {
             return;
         }

src/onebot/network/websocket-client.ts

@@ -19,7 +19,7 @@ export class OB11WebSocketClientAdapter extends IOB11NetworkAdapter<WebsocketCli
         super(name, config, core, obContext, actions);
     }
 
-    onEvent<T extends OB11EmitEventContent>(event: T) {
+    async onEvent<T extends OB11EmitEventContent>(event: T) {
         if (this.connection && this.connection.readyState === WebSocket.OPEN) {
             this.connection.send(JSON.stringify(event));
         }
@@ -62,10 +62,15 @@ export class OB11WebSocketClientAdapter extends IOB11NetworkAdapter<WebsocketCli
         }
     }
 
-    private checkStateAndReply<T>(data: T) {
-        if (this.connection && this.connection.readyState === WebSocket.OPEN) {
-            this.connection.send(JSON.stringify(data));
-        }
+    private async checkStateAndReply<T>(data: T) {
+        return new Promise<void>((resolve, reject) => {
+            if (this.connection && this.connection.readyState === WebSocket.OPEN) {
+                this.connection.send(JSON.stringify(data));
+                resolve();
+            } else {
+                reject(new Error('WebSocket is not open'));
+            }
+        });
     }
 
     private async tryConnect() {
@@ -92,7 +97,7 @@ export class OB11WebSocketClientAdapter extends IOB11NetworkAdapter<WebsocketCli
             });
             this.connection.on('open', () => {
                 try {
-                    this.connectEvent(this.core);
+                    this.connectEvent(this.core).catch(e => this.logger.logError('[OneBot] [WebSocket Client] 发送连接生命周期失败', e));
                 } catch (e) {
                     this.logger.logError('[OneBot] [WebSocket Client] 发送连接生命周期失败', e);
                 }
@@ -123,9 +128,9 @@ export class OB11WebSocketClientAdapter extends IOB11NetworkAdapter<WebsocketCli
         }
     }
 
-    connectEvent(core: NapCatCore) {
+    async connectEvent(core: NapCatCore) {
         try {
-            this.checkStateAndReply<unknown>(new OB11LifeCycleEvent(core, LifeCycleSubType.CONNECT));
+            await this.checkStateAndReply<unknown>(new OB11LifeCycleEvent(core, LifeCycleSubType.CONNECT));
         } catch (e) {
             this.logger.logError('[OneBot] [WebSocket Client] 发送生命周期失败', e);
         }
@@ -140,7 +145,7 @@ export class OB11WebSocketClientAdapter extends IOB11NetworkAdapter<WebsocketCli
             echo = receiveData.echo;
             this.logger.logDebug('[OneBot] [WebSocket Client] 收到正向Websocket消息', receiveData);
         } catch {
-            this.checkStateAndReply<unknown>(OB11Response.error('json解析失败,请检查数据格式', 1400, echo));
+            await this.checkStateAndReply<unknown>(OB11Response.error('json解析失败,请检查数据格式', 1400, echo));
             return;
         }
         receiveData.params = (receiveData?.params) ? receiveData.params : {};// 兼容类型验证
@@ -148,11 +153,15 @@ export class OB11WebSocketClientAdapter extends IOB11NetworkAdapter<WebsocketCli
         const action = this.actions.get(receiveData.action as any);
         if (!action) {
             this.logger.logError('[OneBot] [WebSocket Client] 发生错误', '不支持的Api ' + receiveData.action);
-            this.checkStateAndReply<unknown>(OB11Response.error('不支持的Api ' + receiveData.action, 1404, echo));
+            await this.checkStateAndReply<unknown>(OB11Response.error('不支持的Api ' + receiveData.action, 1404, echo));
             return;
         }
-        const retdata = await action.websocketHandle(receiveData.params, echo ?? '', this.name, this.config);
-        this.checkStateAndReply<unknown>({ ...retdata });
+        const retdata = await action.websocketHandle(receiveData.params, echo ?? '', this.name, this.config, {
+            send: async (data: object) => {
+                await this.checkStateAndReply<unknown>({ ...OB11Response.ok(data, echo ?? '', true) });
+            }
+        });
+        await this.checkStateAndReply<unknown>({ ...retdata });
     }
     async reload(newConfig: WebsocketClientConfig) {
         const wasEnabled = this.isEnable;

src/onebot/network/websocket-server.ts

@@ -83,17 +83,25 @@ export class OB11WebSocketServerAdapter extends IOB11NetworkAdapter<WebsocketSer
     }
     connectEvent(core: NapCatCore, wsClient: WebSocket) {
         try {
-            this.checkStateAndReply<unknown>(new OB11LifeCycleEvent(core, LifeCycleSubType.CONNECT), wsClient);
+            this.checkStateAndReply<unknown>(new OB11LifeCycleEvent(core, LifeCycleSubType.CONNECT), wsClient).catch(e => this.logger.logError('[OneBot] [WebSocket Server] 发送生命周期失败', e));
         } catch (e) {
             this.logger.logError('[OneBot] [WebSocket Server] 发送生命周期失败', e);
         }
     }
 
-    onEvent<T extends OB11EmitEventContent>(event: T) {
+    async onEvent<T extends OB11EmitEventContent>(event: T) {
         this.wsClientsMutex.runExclusive(async () => {
-            this.wsClientWithEvent.forEach((wsClient) => {
-                wsClient.send(JSON.stringify(event));
+            let promises = this.wsClientWithEvent.map((wsClient) => {
+                return new Promise<void>((resolve, reject) => {
+                    if (wsClient.readyState === WebSocket.OPEN) {
+                        wsClient.send(JSON.stringify(event));
+                        resolve();
+                    } else {
+                        reject(new Error('WebSocket is not open'));
+                    }
+                });
             });
+            await Promise.allSettled(promises);
         });
     }
 
@@ -160,10 +168,15 @@ export class OB11WebSocketServerAdapter extends IOB11NetworkAdapter<WebsocketSer
         return false;
     }
 
-    private checkStateAndReply<T>(data: T, wsClient: WebSocket) {
-        if (wsClient.readyState === WebSocket.OPEN) {
-            wsClient.send(JSON.stringify(data));
-        }
+    private async checkStateAndReply<T>(data: T, wsClient: WebSocket) {
+        return await new Promise<void>((resolve, reject) => {
+            if (wsClient.readyState === WebSocket.OPEN) {
+                wsClient.send(JSON.stringify(data));
+                resolve();
+            } else {
+                reject(new Error('WebSocket is not open'));
+            }
+        });
     }
 
     private async handleMessage(wsClient: WebSocket, message: RawData) {
@@ -175,7 +188,7 @@ export class OB11WebSocketServerAdapter extends IOB11NetworkAdapter<WebsocketSer
             echo = receiveData.echo;
             //this.logger.logDebug('收到正向Websocket消息', receiveData);
         } catch {
-            this.checkStateAndReply<unknown>(OB11Response.error('json解析失败,请检查数据格式', 1400, echo), wsClient);
+            await this.checkStateAndReply<unknown>(OB11Response.error('json解析失败,请检查数据格式', 1400, echo), wsClient);
             return;
         }
         receiveData.params = (receiveData?.params) ? receiveData.params : {};//兼容类型验证 不然类型校验爆炸
@@ -183,11 +196,15 @@ export class OB11WebSocketServerAdapter extends IOB11NetworkAdapter<WebsocketSer
         const action = this.actions.get(receiveData.action as any);
         if (!action) {
             this.logger.logError('[OneBot] [WebSocket Client] 发生错误', '不支持的API ' + receiveData.action);
-            this.checkStateAndReply<unknown>(OB11Response.error('不支持的API ' + receiveData.action, 1404, echo), wsClient);
+            await this.checkStateAndReply<unknown>(OB11Response.error('不支持的API ' + receiveData.action, 1404, echo), wsClient);
             return;
         }
-        const retdata = await action.websocketHandle(receiveData.params, echo ?? '', this.name, this.config);
-        this.checkStateAndReply<unknown>({ ...retdata }, wsClient);
+        const retdata = await action.websocketHandle(receiveData.params, echo ?? '', this.name, this.config, {
+            send: async (data: object) => {
+                await this.checkStateAndReply<unknown>({ ...OB11Response.ok(data, echo ?? '', true) }, wsClient);
+            }
+        });
+        await this.checkStateAndReply<unknown>({ ...retdata }, wsClient);
     }
 
     async reload(newConfig: WebsocketServerConfig) {

src/onebot/types/message.ts

@@ -46,6 +46,7 @@ export interface OB11Return<DataType> {
     message: string;
     echo?: unknown; // ws调用api才有此字段
     wording?: string;  // go-cqhttp字段，错误信息
+    stream?: 'stream-action' | 'normal-action' ; // 流式返回标记
 }
 
 // 消息数据类型枚举

src/webui/src/helper/config.ts

@@ -7,14 +7,14 @@ import { resolve } from 'node:path';
 
 import { deepMerge } from '../utils/object';
 import { themeType } from '../types/theme';
-import { getRandomToken, getDefaultHost } from '../utils/url'
+import { getRandomToken } from '../utils/url'
 
 // 限制尝试端口的次数，避免死循环
 // 定义配置的类型
 const WebUiConfigSchema = Type.Object({
-    host: Type.String({ default: getDefaultHost() }),
+    host: Type.String({ default: '0.0.0.0' }),
     port: Type.Number({ default: 6099 }),
-    token: Type.String({ default: getRandomToken(8) }),
+    token: Type.String({ default: getRandomToken(12) }),
     loginRate: Type.Number({ default: 10 }),
     autoLoginAccount: Type.String({ default: '' }),
     theme: themeType,
@@ -64,7 +64,7 @@ export class WebUiConfigWrapper {
 
     async GetWebUIConfig(): Promise<WebUiConfigType> {
         if (this.WebUiConfigData) {
-           return this.WebUiConfigData
+            return this.WebUiConfigData
         }
 
         try {
@@ -76,7 +76,7 @@ export class WebUiConfigWrapper {
                 ...parsedConfig,
                 // 首次读取内存中是没有token的，需要进行一层兜底
                 token: getInitialWebUiToken() || parsedConfig.token,
-            };           
+            };
             return this.WebUiConfigData;
         } catch (e) {
             console.log('读取配置文件失败', e);
@@ -123,7 +123,7 @@ export class WebUiConfigWrapper {
         // 使用内存中缓存的token进行验证，确保强兼容性
         const cachedToken = getInitialWebUiToken();
         const tokenToCheck = cachedToken || (await this.GetWebUIConfig()).token;
-        
+
         if (tokenToCheck !== oldToken) {
             throw new Error('旧 token 不匹配');
         }