@agentunion/fastaun 0.4.9 → 0.4.11

package/dist/client/delivery.js

@@ -3,6 +3,7 @@ import { normalizeGroupId } from '../group-id.js';
 import { isJsonObject } from '../types.js';
 const PUSHED_SEQS_LIMIT = 50_000;
 const PENDING_ORDERED_LIMIT = 50_000;
+const GROUP_RECALL_SEEN_LIMIT = 10_000;
 function isPromiseLike(value) {
     return Boolean(value && typeof value.then === 'function');
 }
@@ -51,11 +52,47 @@ export class MessageDeliveryEngine {
                 queue.delete(oldSeq);
         }
     }
+    isGroupEventNamespace(ns) {
+        return ns.startsWith('group_event:');
+    }
+    async publishOrderedQueueItem(ns, event, seq, payload, source, pullResponse = false) {
+        const client = this.runtime.client;
+        if (event === 'group.changed' && this.isGroupEventNamespace(ns)) {
+            await this.publishOrderedGroupChanged(payload, source);
+            return;
+        }
+        if (pullResponse) {
+            const published = client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload, source));
+            if (isPromiseLike(published))
+                await published;
+        }
+        else {
+            const published = client._publishAppEvent(event, payload, source);
+            if (isPromiseLike(published))
+                await published;
+        }
+    }
+    async publishOrderedGroupChanged(payload, source = 'ordered') {
+        const client = this.runtime.client;
+        if (isJsonObject(payload)) {
+            const eventPayload = payload;
+            client._groupState?.handleGroupChangedV2Membership?.(eventPayload);
+            if (eventPayload.action === 'dissolved') {
+                const groupId = normalizeGroupId(String(eventPayload.group_id ?? '')) || String(eventPayload.group_id ?? '').trim();
+                if (groupId)
+                    client._cleanupDissolvedGroup?.(groupId);
+            }
+        }
+        const published = client._publishAppEvent('group.changed', payload, source);
+        if (isPromiseLike(published))
+            await published;
+    }
     isInstanceScopedMessageEvent(event) {
         return event === 'message.received'
             || event === 'message.recalled'
             || event === 'message.undecryptable'
             || event === 'group.message_created'
+            || event === 'group.message_recalled'
             || event === 'group.message_undecryptable';
     }
     attachCurrentInstanceContext(payload) {
@@ -135,6 +172,148 @@ export class MessageDeliveryEngine {
             return { event: 'message.recalled', payload: recall };
         return { event: 'message.received', payload: message };
     }
+    recallEventFromGroupMessage(message) {
+        if (!isJsonObject(message))
+            return null;
+        const msg = message;
+        const rawPayload = msg.payload;
+        const payload = isJsonObject(rawPayload) ? rawPayload : {};
+        const msgType = String(msg.type ?? msg.kind ?? msg.message_type ?? '').trim();
+        const payloadType = String(payload.type ?? payload.kind ?? '').trim();
+        if (msgType !== 'group.message_recalled' && payloadType !== 'group.message_recalled')
+            return null;
+        const event = { ...payload };
+        const rawIds = event.message_ids;
+        let messageIds = Array.isArray(rawIds)
+            ? rawIds.map((item) => String(item ?? '').trim()).filter(Boolean)
+            : [];
+        if (messageIds.length === 0) {
+            for (const key of ['recalled_message_id', 'target_message_id', 'original_message_id']) {
+                const value = String(event[key] ?? '').trim();
+                if (value) {
+                    messageIds = [value];
+                    break;
+                }
+            }
+        }
+        event.type = 'group.message_recalled';
+        event.kind = 'group.message_recalled';
+        event.message_ids = messageIds;
+        if (!('group_id' in event))
+            event.group_id = msg.group_id ?? '';
+        if (!('timestamp' in event))
+            event.timestamp = msg.timestamp ?? msg.t_server ?? event.recalled_at ?? 0;
+        if ('seq' in msg)
+            event.seq = msg.seq;
+        if ('message_id' in msg && !('tombstone_message_id' in event))
+            event.tombstone_message_id = msg.message_id;
+        return event;
+    }
+    groupRecallDedupKey(groupId, payload) {
+        // 群撤回去重键：group_id + 排序后的 message_ids。
+        // 一条消息只能被撤回一次（服务端 group_message_recalls uk_recall_msg_id 唯一约束），
+        // (group_id, sorted message_ids) 已能唯一标识一次撤回。
+        // 去重键不含 recalled_at：占位/通知 tombstone（pull，事务内时间）与在线 push（事务后重取时间）
+        // 三条通道对同一次撤回可能携带不同来源的时间戳，纳入 recalled_at 会使去重失效、回调多次。
+        // group_id 归一化一次，使去重键与来源无关（pull 用 normalizeGroupId，push 可能是原始值）。
+        const normalizedGroupId = normalizeGroupId(groupId) || String(groupId ?? '').trim();
+        const ids = payload.message_ids;
+        const idPart = Array.isArray(ids)
+            ? ids.map((i) => String(i ?? '').trim()).filter(Boolean).sort().join(',')
+            : String(ids ?? '');
+        return `${normalizedGroupId}|${idPart}`;
+    }
+    async publishGroupRecallTombstone(groupId, seq, message) {
+        const client = this.runtime.client;
+        const eventPayload = this.recallEventFromGroupMessage(message);
+        if (!eventPayload)
+            return false;
+        const dedupKey = this.groupRecallDedupKey(groupId, eventPayload);
+        let seen = client._groupRecallSeen;
+        if (!seen) {
+            seen = new Map();
+            client._groupRecallSeen = seen;
+        }
+        if (seen.has(dedupKey)) {
+            client._clientLog.debug(`group.message_recalled dedup suppressed: group=${groupId} seq=${String(seq)} key=${dedupKey}`);
+            return false;
+        }
+        seen.set(dedupKey, Date.now());
+        if (seen.size > GROUP_RECALL_SEEN_LIMIT) {
+            const drop = [...seen.entries()].sort((a, b) => a[1] - b[1]).slice(0, seen.size - GROUP_RECALL_SEEN_LIMIT);
+            for (const [oldKey] of drop)
+                seen.delete(oldKey);
+        }
+        await client._publishAppEvent('group.message_recalled', eventPayload, 'group-recall');
+        client._clientLog.debug(`group.message_recalled published: group=${groupId} seq=${String(seq)} ids=${JSON.stringify(eventPayload.message_ids)}`);
+        return true;
+    }
+    async onRawGroupMessageRecalled(data) {
+        // 在线 push 是实时通道，与 pull 兜底的双 tombstone 互补。push 携带的 seq 是通知
+        // tombstone 的 notice_seq；必须像普通群消息 push 一样推进 seqTracker + markPublished +
+        // auto-ack，否则该 seq 在本地 contiguous 序列留洞，后续 pull/reconnect 会重复拉到并
+        // 重复处理。publishGroupRecallTombstone 内部再按 (group_id, message_ids) 去重，
+        // 确保应用层只回调一次。
+        const client = this.runtime.client;
+        if (!isJsonObject(data))
+            return;
+        const src = data;
+        const groupId = String(src.group_id ?? '').trim();
+        // push 事件 data 本身是 recall payload；包成 recallEventFromGroupMessage 可识别的形状。
+        const wrapped = { ...src };
+        if (!('type' in wrapped))
+            wrapped.type = 'group.message_recalled';
+        if (!('payload' in wrapped)) {
+            wrapped.payload = {
+                type: 'group.message_recalled',
+                message_ids: src.message_ids ?? [],
+                target_message_seqs: src.target_message_seqs ?? [],
+                sender_aid: src.sender_aid ?? '',
+                recalled_by: src.recalled_by ?? '',
+                recalled_at: src.recalled_at ?? src.timestamp ?? 0,
+                reason: src.reason ?? '',
+                group_id: groupId,
+            };
+        }
+        const seq = src.seq;
+        const seqNum = Number(seq);
+        // 无 group_id 或无可用 seq 时无法推进 contiguous 序列，仅做去重发布兜底。
+        // TS/JS 为单线程事件循环，无需 Python 侧的 ns lock 串行保护。
+        if (!groupId || seq === undefined || seq === null || !Number.isFinite(seqNum) || !Number.isInteger(seqNum)) {
+            await this.publishGroupRecallTombstone(groupId, seq, wrapped);
+            return;
+        }
+        const ns = `group:${groupId}`;
+        if (seqNum > 0) {
+            client._seqTracker.updateMaxSeen(ns, seqNum);
+            if (client._seqTracker.getContiguousSeq(ns) === seqNum) {
+                // 已覆盖（pull 先到并推进过），仍走去重发布兜底，不重复推进 seq。
+                await this.publishGroupRecallTombstone(groupId, seq, wrapped);
+                return;
+            }
+            client._repairPushContiguousBound(ns, seqNum, true, '_raw.group.message_recalled');
+        }
+        // 该 notice_seq 已由 pull 路径处理过（已发布或挂起待发布）时，去重发布兜底后返回。
+        const pushed = client._pushedSeqs.get(ns);
+        const pending = client._pendingOrderedMsgs.get(ns);
+        if (pushed?.has(seqNum) || pending?.has(seqNum)) {
+            await this.publishGroupRecallTombstone(groupId, seq, wrapped);
+            return;
+        }
+        const contigBefore = client._seqTracker.getContiguousSeq(ns);
+        client._seqTracker.onMessageSeq(ns, seqNum);
+        await this.publishGroupRecallTombstone(groupId, seq, wrapped);
+        this.markPublishedSeq(ns, seqNum);
+        client._markOrderedSeqDelivered?.(ns, seqNum);
+        const contig = client._seqTracker.getContiguousSeq(ns);
+        if (contig > 0) {
+            const ackSeq = this.clampAckSeq('group.ack_messages', 'msg_seq', ns, contig);
+            client._withBackgroundRpc(() => client._ackGroupV2(groupId, ackSeq))
+                .catch((e) => { client._clientLog.debug(`group recall auto-ack failed: group=${groupId} ${formatDeliveryError(e)}`); });
+        }
+        if (contig !== contigBefore)
+            this.saveSeqTrackerState();
+    }
     publishAppEvent(event, payload, source = 'direct') {
         const client = this.runtime.client;
         if ((event === 'message.received' || event === 'group.message_created') && isJsonObject(payload)) {
@@ -370,6 +549,21 @@ export class MessageDeliveryEngine {
             if (seq > 0)
                 client._seqTracker.updateMaxSeen(ns, seq);
             const contigBefore = client._seqTracker.getContiguousSeq(ns);
+            // 群撤回 tombstone（占位 / 通知）：归一化为 group.message_recalled，仍占 seq 推进 contiguous/ack。
+            if (!encryptedPush && this.recallEventFromGroupMessage(msg)) {
+                const published = await this.publishOrderedGroupRecall(ns, seq, msg);
+                const contigAfter = client._seqTracker.getContiguousSeq(ns);
+                const contig = client._seqTracker.getContiguousSeq(ns);
+                if (contig > 0) {
+                    const ackSeq = this.clampAckSeq('group.ack_messages', 'msg_seq', ns, contig);
+                    client._withBackgroundRpc(() => client._ackGroupV2(groupId, ackSeq))
+                        .catch((e) => { client._clientLog.debug(`group recall auto-ack failed: group=${groupId} ${formatDeliveryError(e)}`); });
+                }
+                if (contigAfter !== contigBefore)
+                    this.saveSeqTrackerState();
+                void published;
+                return;
+            }
             const published = encryptedPush
                 ? await client._publishEncryptedPushMessage('group.message_created', 'group.message_undecryptable', ns, seq, msg, true)
                 : await this.publishOrderedMessage('group.message_created', ns, seq, msg);
@@ -553,11 +747,14 @@ export class MessageDeliveryEngine {
                     }
                 }
                 const eventSeqs = [];
+                let hasDissolvedEvent = false;
                 for (const evt of eventObjects) {
                     const eventSeq = Number(evt.event_seq ?? 0);
                     if (Number.isFinite(eventSeq) && eventSeq > 0)
                         eventSeqs.push(eventSeq);
                     evt._from_gap_fill = true;
+                    if (evt.action === 'dissolved')
+                        hasDissolvedEvent = true;
                     const et = String(evt.event_type ?? '');
                     if (et !== 'group.message_created') {
                         const cs = evt.client_signature;
@@ -569,19 +766,19 @@ export class MessageDeliveryEngine {
                                 evt._verified = await client._verifyEventSignatureAsync(evt, cs);
                             }
                         }
-                        await client._dispatcher.publish('group.changed', evt);
-                    }
-                    if (Number.isFinite(eventSeq) && eventSeq > 0) {
-                        client._markPulledSeqDelivered(ns, eventSeq);
+                        if (Number.isFinite(eventSeq) && eventSeq > 0 && !client._pushedSeqs.get(ns)?.has(eventSeq)) {
+                            this.enqueueOrderedMessage(ns, 'group.changed', eventSeq, evt);
+                        }
                     }
                     filled += 1;
                 }
-                const contig = client._seqTracker.getContiguousSeq(ns);
-                if (contig !== pageContigBefore) {
+                const ackContig = client._seqTracker.getContiguousSeq(ns);
+                await this.drainOrderedMessages(ns);
+                if (ackContig !== pageContigBefore && !hasDissolvedEvent) {
                     this.saveSeqTrackerState();
                 }
-                if (eventObjects.length > 0 && contig > 0 && contig !== pageContigBefore) {
-                    const ackSeq = this.clampAckSeq('group.ack_events', 'event_seq', ns, contig);
+                if (eventObjects.length > 0 && ackContig > 0 && ackContig !== pageContigBefore) {
+                    const ackSeq = this.clampAckSeq('group.ack_events', 'event_seq', ns, ackContig);
                     client._transport.call('group.ack_events', {
                         group_id: groupId,
                         event_seq: ackSeq,
@@ -612,29 +809,37 @@ export class MessageDeliveryEngine {
             }
         }
     }
-    handleGroupChangedEventSeq(data, groupId) {
+    async handleGroupChangedEventSeq(data, groupId) {
         const client = this.runtime.client;
         let needPull = false;
         const rawEventSeq = data.event_seq;
-        if (rawEventSeq != null && groupId) {
-            const es = Number(rawEventSeq);
-            if (Number.isFinite(es) && es > 0) {
-                needPull = client._seqTracker.onMessageSeq(`group_event:${groupId}`, es);
-            }
-            this.saveSeqTrackerState();
-            const ns = `group_event:${groupId}`;
-            const contig = client._seqTracker.getContiguousSeq(ns);
-            if (contig > 0) {
-                const ackSeq = this.clampAckSeq('group.ack_events', 'event_seq', ns, contig);
-                client._transport.call('group.ack_events', {
-                    group_id: groupId,
-                    event_seq: ackSeq,
-                    device_id: client._deviceId,
-                    slot_id: client._slotId,
-                }, undefined, undefined, true).catch((e) => {
-                    client._clientLog.debug(`group event push auto-ack failed: group=${groupId} ${formatDeliveryError(e)}`);
-                });
-            }
+        const eventSeq = Number(rawEventSeq);
+        if (!groupId || !Number.isFinite(eventSeq) || !Number.isInteger(eventSeq) || eventSeq <= 0) {
+            await this.publishOrderedGroupChanged(data, 'legacy');
+            return;
+        }
+        const ns = `group_event:${groupId}`;
+        const contigBefore = client._seqTracker.getContiguousSeq(ns);
+        if (eventSeq <= contigBefore || client._pushedSeqs.get(ns)?.has(eventSeq)) {
+            client._clientLog.debug(`group.changed skipped duplicate/stale: group=${groupId}, event_seq=${eventSeq}, contiguous=${contigBefore}`);
+            return;
+        }
+        this.enqueueOrderedMessage(ns, 'group.changed', eventSeq, data);
+        needPull = client._seqTracker.onMessageSeq(ns, eventSeq);
+        const ackContig = client._seqTracker.getContiguousSeq(ns);
+        await this.drainOrderedMessages(ns);
+        if (ackContig > 0 && ackContig !== contigBefore) {
+            if (data.action !== 'dissolved')
+                this.saveSeqTrackerState();
+            const ackSeq = this.clampAckSeq('group.ack_events', 'event_seq', ns, ackContig);
+            client._transport.call('group.ack_events', {
+                group_id: groupId,
+                event_seq: ackSeq,
+                device_id: client._deviceId,
+                slot_id: client._slotId,
+            }, undefined, undefined, true).catch((e) => {
+                client._clientLog.debug(`group event push auto-ack failed: group=${groupId} ${formatDeliveryError(e)}`);
+            });
         }
         if (needPull && groupId && !data._from_gap_fill) {
             this.fillGroupEventGap(groupId).catch((exc) => {
@@ -1046,16 +1251,7 @@ export class MessageDeliveryEngine {
                 client._markOrderedSeqDelivered(ns, seq);
                 continue;
             }
-            if (pullResponse) {
-                const published = client._withPullResponseProcessing(ns, () => client._publishAppEvent(item.event, item.payload, 'ordered-drain'));
-                if (isPromiseLike(published))
-                    await published;
-            }
-            else {
-                const published = client._publishAppEvent(item.event, item.payload, 'ordered-drain');
-                if (isPromiseLike(published))
-                    await published;
-            }
+            await this.publishOrderedQueueItem(ns, item.event, seq, item.payload, 'ordered-drain', pullResponse);
             this.markPublishedSeq(ns, seq);
             client._markOrderedSeqDelivered(ns, seq);
             client._clientLog.debug(`publish ordered drain delivered: ns=${ns}, seq=${seq}, event=${item.event}`);
@@ -1068,9 +1264,7 @@ export class MessageDeliveryEngine {
         const seqNum = Number(seq);
         if (!Number.isFinite(seqNum) || !Number.isInteger(seqNum) || seqNum <= 0) {
             client._clientLog.debug(`publish ordered direct(no-seq): event=${event}, ns=${ns || '<none>'}, seq=${String(seq)}`);
-            const published = client._publishAppEvent(event, payload, 'ordered');
-            if (isPromiseLike(published))
-                await published;
+            await this.publishOrderedQueueItem(ns, event, seqNum, payload, 'ordered');
             return true;
         }
         if (client._pushedSeqs.get(ns)?.has(seqNum)) {
@@ -1104,15 +1298,32 @@ export class MessageDeliveryEngine {
         queue?.delete(seqNum);
         if (queue && queue.size === 0)
             client._pendingOrderedMsgs.delete(ns);
-        const published = client._publishAppEvent(event, payload, 'ordered');
-        if (isPromiseLike(published))
-            await published;
+        await this.publishOrderedQueueItem(ns, event, seqNum, payload, 'ordered');
         this.markPublishedSeq(ns, seqNum);
         client._markOrderedSeqDelivered(ns, seqNum);
         client._clientLog.debug(`publish ordered delivered: event=${event}, ns=${ns}, seq=${seqNum}`);
         await this.drainOrderedMessages(ns);
         return true;
     }
+    async publishOrderedGroupRecall(ns, seq, message) {
+        const client = this.runtime.client;
+        const seqNum = Number(seq);
+        if (!Number.isFinite(seqNum) || !Number.isInteger(seqNum) || seqNum <= 0) {
+            await this.publishGroupRecallTombstone(ns.replace(/^group:/, ''), seq, message);
+            return true;
+        }
+        // 撤回 tombstone 也占 seq：推进 contiguous 并标记已发布，确保 ack 正常推进、不留空洞。
+        if (client._pushedSeqs.get(ns)?.has(seqNum)) {
+            await this.publishGroupRecallTombstone(ns.replace(/^group:/, ''), seq, message);
+            return false;
+        }
+        client._seqTracker.onMessageSeq(ns, seqNum);
+        await this.publishGroupRecallTombstone(ns.replace(/^group:/, ''), seq, message);
+        this.markPublishedSeq(ns, seqNum);
+        client._markOrderedSeqDelivered?.(ns, seqNum);
+        await this.drainOrderedMessages(ns);
+        return true;
+    }
     async publishPulledMessage(event, ns, seq, payload) {
         const client = this.runtime.client;
         const seqNum = Number(seq);