acp-ts 1.2.0 → 1.2.1

package/dist/agentcp.d.ts

@@ -99,7 +99,7 @@ declare class AgentCP implements IAgentCP {
      * 处理批量推送消息：排序、存储、ACK 最后一条。
      * 返回排序后的消息列表，供上层使用（如推送给浏览器）。
      */
-    processAndAckBatch(groupId: string, batch: GroupMessageBatch): GroupMessage[];
+    processAndAckBatch(groupId: string, batch: GroupMessageBatch): Promise<GroupMessage[]>;
     /**
      * 异步 ACK 消息（不阻塞调用方）
      */
@@ -158,11 +158,11 @@ declare class AgentCP implements IAgentCP {
     /**
      * 添加群消息到本地存储
      */
-    addGroupMessageToStore(groupId: string, msg: GroupMessage): void;
+    addGroupMessageToStore(groupId: string, msg: GroupMessage): Promise<void>;
     /**
      * 批量添加群消息到本地存储
      */
-    addGroupMessagesToStore(groupId: string, msgs: GroupMessage[]): void;
+    addGroupMessagesToStore(groupId: string, msgs: GroupMessage[]): Promise<void>;
     /**
      * 获取本地存储中群组的最新消息ID（用于增量拉取）
      */

package/dist/agentcp.js

@@ -445,7 +445,9 @@ class AgentCP {
             },
             onGroupMessageBatch: (groupId, batch) => {
                 console.log(`[Group][DefaultHandler] onGroupMessageBatch: group=${groupId} count=${batch.count} range=[${batch.start_msg_id}, ${batch.latest_msg_id}]`);
-                this.processAndAckBatch(groupId, batch);
+                this.processAndAckBatch(groupId, batch).catch(e => {
+                    console.error(`[Group][DefaultHandler] processAndAckBatch failed: group=${groupId}`, e);
+                });
             },
             onGroupEvent(groupId, evt) {
                 console.log(`[Group][DefaultHandler] onGroupEvent: group=${groupId} event=${evt.event_type}`);
@@ -456,9 +458,9 @@ class AgentCP {
      * 处理批量推送消息：排序、存储、ACK 最后一条。
      * 返回排序后的消息列表，供上层使用（如推送给浏览器）。
      */
-    processAndAckBatch(groupId, batch) {
+    async processAndAckBatch(groupId, batch) {
         const sorted = [...batch.messages].sort((a, b) => a.msg_id - b.msg_id);
-        this.addGroupMessagesToStore(groupId, sorted);
+        await this.addGroupMessagesToStore(groupId, sorted);
         // ACK batch 中最后一条消息
         if (sorted.length > 0) {
             const lastMsgId = sorted[sorted.length - 1].msg_id;
@@ -561,6 +563,17 @@ class AgentCP {
                 this.groupMessageStore.getOrCreateGroup(membership.group_id, this._groupTargetAid, name);
             }
         }
+        // 清理本地有但服务端已不存在的群组
+        if (this.groupMessageStore) {
+            const serverGroupIds = new Set(result.groups.map(g => g.group_id));
+            const localGroups = this.groupMessageStore.getGroupList();
+            for (const local of localGroups) {
+                if (!serverGroupIds.has(local.groupId)) {
+                    await this.groupMessageStore.deleteGroup(local.groupId);
+                    console.log(`[Group] syncGroupList: 清理本地已退出群组 ${local.groupId}`);
+                }
+            }
+        }
         return groups;
     }
     /**
@@ -605,18 +618,18 @@ class AgentCP {
     /**
      * 添加群消息到本地存储
      */
-    addGroupMessageToStore(groupId, msg) {
+    async addGroupMessageToStore(groupId, msg) {
         if (!this.groupMessageStore)
             return;
-        this.groupMessageStore.addMessage(groupId, msg);
+        await this.groupMessageStore.addMessage(groupId, msg);
     }
     /**
      * 批量添加群消息到本地存储
      */
-    addGroupMessagesToStore(groupId, msgs) {
+    async addGroupMessagesToStore(groupId, msgs) {
         if (!this.groupMessageStore)
             return;
-        this.groupMessageStore.addMessages(groupId, msgs);
+        await this.groupMessageStore.addMessages(groupId, msgs);
     }
     /**
      * 获取本地存储中群组的最新消息ID（用于增量拉取）
@@ -659,7 +672,7 @@ class AgentCP {
                         metadata: (_f = m.metadata) !== null && _f !== void 0 ? _f : null,
                     });
                 });
-                this.addGroupMessagesToStore(groupId, msgs);
+                await this.addGroupMessagesToStore(groupId, msgs);
                 // ACK 这批消息中的最后一条
                 const lastMsgId = msgs[msgs.length - 1].msg_id;
                 await this.groupOps.ackMessages(this._groupTargetAid, groupId, lastMsgId);

package/dist/group/client.js

@@ -160,7 +160,9 @@ class ACPGroupClient {
         this._pendingReqs.clear();
         if (this._cursorStore != null) {
             try {
-                this._cursorStore.close();
+                this._cursorStore.close().catch(e => {
+                    console.error("[ACPGroupClient] cursor store close error:", e);
+                });
             }
             catch (e) {
                 console.error("[ACPGroupClient] cursor store close error:", e);

package/dist/group/cursor_store.d.ts

@@ -10,8 +10,8 @@ export interface CursorStore {
     saveEventCursor(groupId: string, eventCursor: number): void;
     loadCursor(groupId: string): [number, number];
     removeCursor(groupId: string): void;
-    flush(): void;
-    close(): void;
+    flush(): Promise<void>;
+    close(): Promise<void>;
 }
 /**
  * In-memory + JSON file cursor store.
@@ -24,13 +24,18 @@ export declare class LocalCursorStore implements CursorStore {
     private _cursors;
     private _filePath;
     private _dirty;
+    private _flushTimer;
+    private _flushPromise;
+    private _loaded;
     constructor(filePath?: string);
+    init(): Promise<void>;
     saveMsgCursor(groupId: string, msgCursor: number): void;
     saveEventCursor(groupId: string, eventCursor: number): void;
     loadCursor(groupId: string): [number, number];
     removeCursor(groupId: string): void;
-    flush(): void;
-    close(): void;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+    private _flushDebounced;
     private _write;
     private _load;
 }

package/dist/group/cursor_store.js

@@ -17,9 +17,15 @@ class LocalCursorStore {
     constructor(filePath = "") {
         this._cursors = {};
         this._dirty = false;
+        this._flushTimer = null;
+        this._flushPromise = null;
+        this._loaded = false;
         this._filePath = filePath;
-        if (filePath && websocket_1.isNodeEnvironment) {
-            this._load();
+    }
+    async init() {
+        if (this._filePath && websocket_1.isNodeEnvironment && !this._loaded) {
+            await this._load();
+            this._loaded = true;
         }
     }
     saveMsgCursor(groupId, msgCursor) {
@@ -29,6 +35,7 @@ class LocalCursorStore {
         if (msgCursor > this._cursors[groupId].msg_cursor) {
             this._cursors[groupId].msg_cursor = msgCursor;
             this._dirty = true;
+            this._flushDebounced();
         }
     }
     saveEventCursor(groupId, eventCursor) {
@@ -38,6 +45,7 @@ class LocalCursorStore {
         if (eventCursor > this._cursors[groupId].event_cursor) {
             this._cursors[groupId].event_cursor = eventCursor;
             this._dirty = true;
+            this._flushDebounced();
         }
     }
     loadCursor(groupId) {
@@ -51,37 +59,58 @@ class LocalCursorStore {
         if (groupId in this._cursors) {
             delete this._cursors[groupId];
             this._dirty = true;
+            this._flushDebounced();
         }
     }
-    flush() {
+    async flush() {
         if (!this._filePath || !websocket_1.isNodeEnvironment) {
             return;
         }
         if (!this._dirty) {
             return;
         }
-        this._write();
+        await this._write();
+    }
+    async close() {
+        if (this._flushTimer) {
+            clearTimeout(this._flushTimer);
+            this._flushTimer = null;
+        }
+        await this.flush();
     }
-    close() {
-        this.flush();
+    _flushDebounced() {
+        if (this._flushTimer)
+            return;
+        this._flushTimer = setTimeout(async () => {
+            this._flushTimer = null;
+            try {
+                await this.flush();
+            }
+            catch (e) {
+                console.error('[CursorStore] debounced flush failed:', e);
+            }
+        }, 500);
     }
-    _write() {
+    async _write() {
         try {
             const fs = require('fs');
-            fs.writeFileSync(this._filePath, JSON.stringify(this._cursors, null, 2), 'utf-8');
+            const content = JSON.stringify(this._cursors, null, 2);
+            const tmpPath = this._filePath + '.tmp';
+            await fs.promises.writeFile(tmpPath, content, 'utf-8');
+            await fs.promises.rename(tmpPath, this._filePath);
             this._dirty = false;
         }
         catch (e) {
             console.error(`[CursorStore] write to ${this._filePath} failed:`, e);
         }
     }
-    _load() {
+    async _load() {
         try {
             const fs = require('fs');
             if (!fs.existsSync(this._filePath)) {
                 return;
             }
-            const content = fs.readFileSync(this._filePath, 'utf-8');
+            const content = await fs.promises.readFile(this._filePath, 'utf-8');
             if (content) {
                 this._cursors = JSON.parse(content);
             }

package/dist/group/message_store.d.ts

@@ -27,6 +27,7 @@ export declare class GroupMessageStore {
     private maxEventsPerGroup;
     private groups;
     private _indexDirty;
+    private _flushIndexPromise;
     constructor(options: {
         persistMessages: boolean;
         basePath: string;
@@ -45,16 +46,16 @@ export declare class GroupMessageStore {
     getGroupList(): GroupRecord[];
     getGroup(groupId: string): GroupRecord | null;
     deleteGroup(groupId: string): Promise<boolean>;
-    addMessage(groupId: string, msg: GroupMessage): void;
-    addMessages(groupId: string, msgs: GroupMessage[]): void;
+    addMessage(groupId: string, msg: GroupMessage): Promise<void>;
+    addMessages(groupId: string, msgs: GroupMessage[]): Promise<void>;
     getMessages(groupId: string, options?: {
         afterMsgId?: number;
         beforeMsgId?: number;
         limit?: number;
     }): GroupMessage[];
     getLatestMessages(groupId: string, limit?: number): GroupMessage[];
-    addEvent(groupId: string, evt: GroupEvent): void;
-    addEvents(groupId: string, evts: GroupEvent[]): void;
+    addEvent(groupId: string, evt: GroupEvent): Promise<void>;
+    addEvents(groupId: string, evts: GroupEvent[]): Promise<void>;
     getEvents(groupId: string, options?: {
         afterEventId?: number;
         limit?: number;
@@ -63,7 +64,7 @@ export declare class GroupMessageStore {
     private writeJsonl;
     private flushMessages;
     private flushEvents;
-    private flushIndexAsync;
+    private flushIndexQueued;
     flushIndex(): Promise<void>;
     flush(ownerAid: string): Promise<void>;
     flushAll(): Promise<void>;

package/dist/group/message_store.js

@@ -17,6 +17,7 @@ class GroupMessageStore {
         this.ownerAid = '';
         this.groups = new Map();
         this._indexDirty = false;
+        this._flushIndexPromise = null;
         this.persistMessages = options.persistMessages;
         this.basePath = options.basePath;
         this.maxMessagesPerGroup = (_a = options.maxMessagesPerGroup) !== null && _a !== void 0 ? _a : 5000;
@@ -43,12 +44,12 @@ class GroupMessageStore {
         const path = require('path');
         return path.join(this.getGroupDir(aid, groupId), 'events.jsonl');
     }
-    ensureDir(dir) {
+    async ensureDir(dir) {
         if (!websocket_1.isNodeEnvironment)
             return;
         const fs = require('fs');
         if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
+            await fs.promises.mkdir(dir, { recursive: true });
         }
     }
     // ---- load ----
@@ -63,13 +64,13 @@ class GroupMessageStore {
         if (!fs.existsSync(indexPath))
             return;
         try {
-            const raw = fs.readFileSync(indexPath, 'utf-8');
+            const raw = await fs.promises.readFile(indexPath, 'utf-8');
             const records = JSON.parse(raw);
             if (!Array.isArray(records))
                 return;
             for (const r of records) {
-                const messages = this.readJsonl(this.getMessagesPath(ownerAid, r.groupId));
-                const events = this.readJsonl(this.getEventsPath(ownerAid, r.groupId));
+                const messages = await this.readJsonl(this.getMessagesPath(ownerAid, r.groupId));
+                const events = await this.readJsonl(this.getEventsPath(ownerAid, r.groupId));
                 this.groups.set(r.groupId, { record: r, messages, events });
             }
         }
@@ -77,27 +78,31 @@ class GroupMessageStore {
             console.error('[GroupMessageStore] 加载索引失败:', e);
         }
     }
-    readJsonl(filePath) {
+    async readJsonl(filePath) {
         if (!websocket_1.isNodeEnvironment)
             return [];
         const fs = require('fs');
         if (!fs.existsSync(filePath))
             return [];
         try {
-            const raw = fs.readFileSync(filePath, 'utf-8');
+            const raw = await fs.promises.readFile(filePath, 'utf-8');
             const items = [];
-            for (const line of raw.split('\n')) {
-                const l = line.trim();
+            const lines = raw.split('\n');
+            for (let i = 0; i < lines.length; i++) {
+                const l = lines[i].trim();
                 if (!l)
                     continue;
                 try {
                     items.push(JSON.parse(l));
                 }
-                catch (_a) { }
+                catch (lineErr) {
+                    console.warn(`[GroupMessageStore] JSONL 解析失败 (${filePath} 行${i + 1}): ${l.substring(0, 80)}`, lineErr);
+                }
             }
             return items;
         }
-        catch (_b) {
+        catch (e) {
+            console.warn(`[GroupMessageStore] 读取 JSONL 文件失败 (${filePath}):`, e);
             return [];
         }
     }
@@ -114,7 +119,7 @@ class GroupMessageStore {
             data = { record, messages: [], events: [] };
             this.groups.set(groupId, data);
             this._indexDirty = true;
-            this.flushIndexAsync();
+            this.flushIndexQueued();
         }
         return data.record;
     }
@@ -149,11 +154,10 @@ class GroupMessageStore {
         return true;
     }
     // ---- message storage ----
-    addMessage(groupId, msg) {
+    async addMessage(groupId, msg) {
         const data = this.groups.get(groupId);
         if (!data)
             return;
-        // dedup: skip if msg_id already seen
         if (msg.msg_id <= data.record.lastMsgId)
             return;
         data.messages.push(msg);
@@ -161,28 +165,32 @@ class GroupMessageStore {
         data.record.messageCount = data.messages.length;
         data.record.lastMessageAt = msg.timestamp || Date.now();
         this._indexDirty = true;
-        // truncate if over limit
         if (data.messages.length > this.maxMessagesPerGroup) {
             const excess = data.messages.length - this.maxMessagesPerGroup;
             data.messages.splice(0, excess);
             data.record.messageCount = data.messages.length;
-            this.flushMessages(groupId);
+            await this.flushMessages(groupId);
         }
         else {
-            this.appendJsonl(this.getMessagesPath(this.ownerAid, groupId), msg);
+            await this.appendJsonl(this.getMessagesPath(this.ownerAid, groupId), msg);
         }
-        this.flushIndexAsync();
+        this.flushIndexQueued();
     }
-    addMessages(groupId, msgs) {
+    async addMessages(groupId, msgs) {
         const data = this.groups.get(groupId);
         if (!data)
             return;
+        const sorted = [...msgs].sort((a, b) => a.msg_id - b.msg_id);
+        const existingIds = new Set(data.messages.map(m => m.msg_id));
         let added = 0;
-        for (const msg of msgs) {
-            if (msg.msg_id <= data.record.lastMsgId)
+        for (const msg of sorted) {
+            if (existingIds.has(msg.msg_id))
                 continue;
             data.messages.push(msg);
-            data.record.lastMsgId = msg.msg_id;
+            existingIds.add(msg.msg_id);
+            if (msg.msg_id > data.record.lastMsgId) {
+                data.record.lastMsgId = msg.msg_id;
+            }
             data.record.lastMessageAt = msg.timestamp || Date.now();
             added++;
         }
@@ -194,12 +202,9 @@ class GroupMessageStore {
             const excess = data.messages.length - this.maxMessagesPerGroup;
             data.messages.splice(0, excess);
             data.record.messageCount = data.messages.length;
-            this.flushMessages(groupId);
-        }
-        else {
-            this.flushMessages(groupId);
         }
-        this.flushIndexAsync();
+        await this.flushMessages(groupId);
+        this.flushIndexQueued();
     }
     getMessages(groupId, options) {
         const data = this.groups.get(groupId);
@@ -224,7 +229,7 @@ class GroupMessageStore {
         return data.messages.slice(-limit);
     }
     // ---- event storage ----
-    addEvent(groupId, evt) {
+    async addEvent(groupId, evt) {
         const data = this.groups.get(groupId);
         if (!data)
             return;
@@ -238,14 +243,14 @@ class GroupMessageStore {
             const excess = data.events.length - this.maxEventsPerGroup;
             data.events.splice(0, excess);
             data.record.eventCount = data.events.length;
-            this.flushEvents(groupId);
+            await this.flushEvents(groupId);
         }
         else {
-            this.appendJsonl(this.getEventsPath(this.ownerAid, groupId), evt);
+            await this.appendJsonl(this.getEventsPath(this.ownerAid, groupId), evt);
         }
-        this.flushIndexAsync();
+        this.flushIndexQueued();
     }
-    addEvents(groupId, evts) {
+    async addEvents(groupId, evts) {
         const data = this.groups.get(groupId);
         if (!data)
             return;
@@ -266,8 +271,8 @@ class GroupMessageStore {
             data.events.splice(0, excess);
             data.record.eventCount = data.events.length;
         }
-        this.flushEvents(groupId);
-        this.flushIndexAsync();
+        await this.flushEvents(groupId);
+        this.flushIndexQueued();
     }
     getEvents(groupId, options) {
         const data = this.groups.get(groupId);
@@ -283,47 +288,54 @@ class GroupMessageStore {
         return result;
     }
     // ---- persistence ----
-    appendJsonl(filePath, item) {
+    async appendJsonl(filePath, item) {
         if (!this.persistMessages || !websocket_1.isNodeEnvironment || !this.ownerAid)
             return;
         const fs = require('fs');
         const path = require('path');
-        this.ensureDir(path.dirname(filePath));
+        await this.ensureDir(path.dirname(filePath));
         try {
-            fs.appendFileSync(filePath, JSON.stringify(item) + '\n');
+            await fs.promises.appendFile(filePath, JSON.stringify(item) + '\n');
         }
         catch (e) {
             console.error(`[GroupMessageStore] 追加写入失败 (${filePath}):`, e);
         }
     }
-    writeJsonl(filePath, items) {
+    async writeJsonl(filePath, items) {
         if (!this.persistMessages || !websocket_1.isNodeEnvironment || !this.ownerAid)
             return;
         const fs = require('fs');
         const path = require('path');
-        this.ensureDir(path.dirname(filePath));
+        await this.ensureDir(path.dirname(filePath));
         try {
             const lines = items.map(i => JSON.stringify(i)).join('\n');
-            fs.writeFileSync(filePath, lines ? lines + '\n' : '');
+            const content = lines ? lines + '\n' : '';
+            const tmpPath = filePath + '.tmp';
+            await fs.promises.writeFile(tmpPath, content);
+            await fs.promises.rename(tmpPath, filePath);
         }
         catch (e) {
             console.error(`[GroupMessageStore] 全量写入失败 (${filePath}):`, e);
         }
     }
-    flushMessages(groupId) {
+    async flushMessages(groupId) {
         const data = this.groups.get(groupId);
         if (!data || !this.ownerAid)
             return;
-        this.writeJsonl(this.getMessagesPath(this.ownerAid, groupId), data.messages);
+        await this.writeJsonl(this.getMessagesPath(this.ownerAid, groupId), data.messages);
     }
-    flushEvents(groupId) {
+    async flushEvents(groupId) {
         const data = this.groups.get(groupId);
         if (!data || !this.ownerAid)
             return;
-        this.writeJsonl(this.getEventsPath(this.ownerAid, groupId), data.events);
+        await this.writeJsonl(this.getEventsPath(this.ownerAid, groupId), data.events);
     }
-    flushIndexAsync() {
-        this.flushIndex().catch(() => { });
+    flushIndexQueued() {
+        var _a;
+        const prev = (_a = this._flushIndexPromise) !== null && _a !== void 0 ? _a : Promise.resolve();
+        this._flushIndexPromise = prev.then(() => this.flushIndex()).catch(e => {
+            console.error('[GroupMessageStore] 索引刷盘失败:', e);
+        });
     }
     async flushIndex() {
         if (!this.persistMessages || !websocket_1.isNodeEnvironment || !this.ownerAid)
@@ -332,11 +344,14 @@ class GroupMessageStore {
             return;
         const fs = require('fs');
         const dir = this.getGroupsDir(this.ownerAid);
-        this.ensureDir(dir);
+        await this.ensureDir(dir);
         const records = Array.from(this.groups.values())
             .map(d => d.record);
         try {
-            fs.writeFileSync(this.getIndexPath(this.ownerAid), JSON.stringify(records, null, 2));
+            const indexPath = this.getIndexPath(this.ownerAid);
+            const tmpPath = indexPath + '.tmp';
+            await fs.promises.writeFile(tmpPath, JSON.stringify(records, null, 2));
+            await fs.promises.rename(tmpPath, indexPath);
             this._indexDirty = false;
         }
         catch (e) {
@@ -348,9 +363,9 @@ class GroupMessageStore {
             return;
         this.ownerAid = ownerAid;
         await this.flushIndex();
-        for (const [groupId, data] of this.groups) {
-            this.flushMessages(groupId);
-            this.flushEvents(groupId);
+        for (const [groupId] of this.groups) {
+            await this.flushMessages(groupId);
+            await this.flushEvents(groupId);
         }
     }
     async flushAll() {

package/dist/interfaces.d.ts

@@ -175,11 +175,11 @@ interface IAgentCP {
     /**
      * 添加群消息到本地存储
      */
-    addGroupMessageToStore(groupId: string, msg: GroupMessage): void;
+    addGroupMessageToStore(groupId: string, msg: GroupMessage): Promise<void>;
     /**
      * 批量添加群消息到本地存储
      */
-    addGroupMessagesToStore(groupId: string, msgs: GroupMessage[]): void;
+    addGroupMessagesToStore(groupId: string, msgs: GroupMessage[]): Promise<void>;
     /**
      * 获取本地存储中群组的最新消息ID
      */

package/dist/server.js

@@ -135,11 +135,27 @@ async function doEnsureOnline(aid) {
             instance.agentWS.acceptInviteFromHeartbeat(invite.sessionId, invite.inviterAgentId, invite.inviteCode);
         }
     });
-    // 心跳重连成功后，自动触发 WebSocket 重连
+    // 心跳重连成功后，自动触发 WebSocket 重连 + 群组重新注册
     hb.onReconnect(() => {
         if (instance.agentWS) {
             console.log('[Server] 心跳重连成功，触发 WebSocket 重连...');
-            instance.agentWS.reconnect().catch((err) => {
+            instance.agentWS.reconnect().then(async () => {
+                // WebSocket 重连成功后，重新注册所有在线群组
+                // 断线期间 group.ap 会将在线状态过期，必须重新 register_online 才能收到推送
+                const onlineGroups = instance.agentCP.getOnlineGroups();
+                if (onlineGroups.length > 0) {
+                    console.log(`[Server] WebSocket 重连成功，重新注册 ${onlineGroups.length} 个在线群组...`);
+                    for (const groupId of onlineGroups) {
+                        try {
+                            await instance.agentCP.joinGroupSession(groupId);
+                            console.log(`[Server] 群组重新注册成功: ${groupId}`);
+                        }
+                        catch (e) {
+                            console.warn(`[Server] 群组重新注册失败: ${groupId}`, e.message || e);
+                        }
+                    }
+                }
+            }).catch((err) => {
                 console.error('[Server] WebSocket 重连失败:', err);
             });
         }
@@ -327,16 +343,19 @@ async function ensureGroupClient(instance) {
         },
         onGroupMessageBatch(groupId, batch) {
             console.log(`[Group] onGroupMessageBatch: group=${groupId} count=${batch.count} range=[${batch.start_msg_id}, ${batch.latest_msg_id}]`);
-            // 存储 + ACK（统一由 agentcp 处理）
-            const sorted = instance.agentCP.processAndAckBatch(groupId, batch);
-            // 推送消息列表给浏览器
-            broadcastToBrowser({
-                type: 'group_message_batch',
-                group_id: groupId,
-                messages: sorted,
-                count: batch.count,
-                start_msg_id: batch.start_msg_id,
-                latest_msg_id: batch.latest_msg_id,
+            // 存储 + ACK（统一由 agentcp 处理），注意 processAndAckBatch 是 async
+            instance.agentCP.processAndAckBatch(groupId, batch).then((sorted) => {
+                // 推送消息列表给浏览器
+                broadcastToBrowser({
+                    type: 'group_message_batch',
+                    group_id: groupId,
+                    messages: sorted,
+                    count: batch.count,
+                    start_msg_id: batch.start_msg_id,
+                    latest_msg_id: batch.latest_msg_id,
+                });
+            }).catch((e) => {
+                console.error(`[Group] processAndAckBatch failed: group=${groupId}`, e);
             });
         },
         onGroupEvent(groupId, evt) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "acp-ts",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "基于 ACP智能体通信协议 的智能体通信库，提供智能体身份管理和实时通信功能",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",