acp-ts 1.2.5 → 1.2.7

package/dist/agentcp.d.ts

@@ -177,6 +177,19 @@ declare class AgentCP implements IAgentCP {
      * @param limit 每次拉取数量上限，0 表示使用服务端默认值
      */
     pullAndStoreGroupMessages(groupId: string, afterMsgId?: number, limit?: number): Promise<GroupMessage[]>;
+    /**
+     * 将群组加入在线列表（不发送网络请求）。
+     */
+    addOnlineGroup(groupId: string): void;
+    /**
+     * 确保群组心跳定时器已启动（公开方法）。
+     */
+    ensureGroupHeartbeat(): void;
+    /**
+     * 向 group.ap 发送一次 register_online，告知当前客户端在线。
+     * 不带群组 ID，只需在启动或重连时调用一次。
+     */
+    groupRegisterOnline(): Promise<void>;
     /**
      * 加入群组会话（完整生命周期）：
      * 1. register_online → 告知 group.ap 在线

package/dist/agentcp.js

@@ -701,6 +701,29 @@ class AgentCP {
     // ============================================================
     // Group Session Lifecycle (register_online / pull / heartbeat / unregister)
     // ============================================================
+    /**
+     * 将群组加入在线列表（不发送网络请求）。
+     */
+    addOnlineGroup(groupId) {
+        this._onlineGroups.add(groupId);
+    }
+    /**
+     * 确保群组心跳定时器已启动（公开方法）。
+     */
+    ensureGroupHeartbeat() {
+        this._ensureHeartbeat();
+    }
+    /**
+     * 向 group.ap 发送一次 register_online，告知当前客户端在线。
+     * 不带群组 ID，只需在启动或重连时调用一次。
+     */
+    async groupRegisterOnline() {
+        if (!this.groupOps || !this._groupTargetAid) {
+            throw new Error('群组客户端未初始化，请先调用 initGroupClient');
+        }
+        await this.groupOps.registerOnline(this._groupTargetAid);
+        utils_1.logger.log(`[Group] registerOnline: 已通知 group.ap 在线`);
+    }
     /**
      * 加入群组会话（完整生命周期）：
      * 1. register_online → 告知 group.ap 在线
@@ -711,11 +734,13 @@ class AgentCP {
         if (!this.groupOps || !this._groupTargetAid) {
             throw new Error('群组客户端未初始化，请先调用 initGroupClient');
         }
-        // Step 1: register_online（仅通知 group.ap 在线，不再返回游标）
-        await this.groupOps.registerOnline(this._groupTargetAid);
+        // 如果还没有在线群组，说明是首次加入，需要先 registerOnline
+        if (this._onlineGroups.size === 0) {
+            await this.groupOps.registerOnline(this._groupTargetAid);
+        }
         this._onlineGroups.add(groupId);
         utils_1.logger.log(`[Group] joinGroupSession: group=${groupId}`);
-        // Step 2: 冷启动同步 — 拉取历史消息对齐，再进入批推送接收
+        // 冷启动同步 — 拉取历史消息对齐，再进入批推送接收
         try {
             const lastMsgId = this.getGroupLastMsgId(groupId);
             await this.pullAndStoreGroupMessages(groupId, lastMsgId, 50);
@@ -723,7 +748,7 @@ class AgentCP {
         catch (e) {
             utils_1.logger.warn(`[Group] cold-start sync failed: group=${groupId}`, e.message || e);
         }
-        // Step 3: 启动心跳定时器（首次加入群组时启动）
+        // 启动心跳定时器（首次加入群组时启动）
         this._ensureHeartbeat();
     }
     /**

package/dist/agentmd.d.ts

@@ -17,7 +17,7 @@ export interface AgentMdOptions {
 }
 /**
  * 从 AID 中提取显示名称
- * 例如: "alice.aid.show" -> "alice"
+ * 例如: "alice.agentcp.io" -> "alice"
  */
 export declare function extractDisplayName(aid: string): string;
 /**

package/dist/agentmd.js

@@ -7,10 +7,10 @@ exports.extractDisplayName = extractDisplayName;
 exports.generateAgentMd = generateAgentMd;
 /**
  * 从 AID 中提取显示名称
- * 例如: "alice.aid.show" -> "alice"
+ * 例如: "alice.agentcp.io" -> "alice"
  */
 function extractDisplayName(aid) {
-    const suffixes = ['.agentcp.io', '.aid.show', '.agentid.pub'];
+    const suffixes = ['.agentcp.io', '.agentid.pub'];
     for (const suffix of suffixes) {
         if (aid.endsWith(suffix)) {
             return aid.slice(0, -suffix.length);

package/dist/server.js

@@ -151,25 +151,27 @@ async function doEnsureOnline(aid) {
             instance.agentWS.acceptInviteFromHeartbeat(invite.sessionId, invite.inviterAgentId, invite.inviteCode);
         }
     });
-    // 心跳重连成功后，自动触发 WebSocket 重连 + 群组重新注册
+    // 心跳重连成功后，自动触发 WebSocket 重连 + 重新注册上线
     hb.onReconnect(() => {
         if (instance.agentWS) {
             utils_1.logger.log('[Server] 心跳重连成功，触发 WebSocket 重连...');
             instance.agentWS.reconnect().then(async () => {
-                // WebSocket 重连成功后，重新注册所有在线群组
-                // 断线期间 group.ap 会将在线状态过期，必须重新 register_online 才能收到推送
                 const onlineGroups = instance.agentCP.getOnlineGroups();
                 if (onlineGroups.length > 0) {
-                    utils_1.logger.log(`[Server] WebSocket 重连成功，重新注册 ${onlineGroups.length} 个在线群组...`);
-                    for (const groupId of onlineGroups) {
+                    await instance.agentCP.groupRegisterOnline();
+                    utils_1.logger.log(`[Server] WebSocket 重连成功，已重新注册上线，在线群组: ${onlineGroups.length}`);
+                    // 后台异步拉取断线期间可能漏掉的消息
+                    Promise.all(onlineGroups.map(async (groupId) => {
                         try {
-                            await instance.agentCP.joinGroupSession(groupId);
-                            utils_1.logger.log(`[Server] 群组重新注册成功: ${groupId}`);
+                            const lastMsgId = instance.agentCP.getGroupLastMsgId(groupId);
+                            await instance.agentCP.pullAndStoreGroupMessages(groupId, lastMsgId, 50);
                         }
                         catch (e) {
-                            utils_1.logger.warn(`[Server] 群组重新注册失败: ${groupId}`, e.message || e);
+                            utils_1.logger.warn(`[Server] reconnect sync failed: ${groupId}`, e.message || e);
                         }
-                    }
+                    })).then(() => {
+                        utils_1.logger.log(`[Server] 重连后台消息同步完成`);
+                    });
                 }
             }).catch((err) => {
                 utils_1.logger.error('[Server] WebSocket 重连失败:', err);
@@ -184,19 +186,22 @@ async function doEnsureOnline(aid) {
             instance.connectionConfig = newConnConfig;
             utils_1.logger.log('[Server] 重新鉴权成功，使用新 signature 重连 WebSocket...');
             await instance.agentWS.reconnect(newConnConfig.messageServer, newConnConfig.messageSignature);
-            // 重连成功后重新注册所有在线群组
             const onlineGroups = instance.agentCP.getOnlineGroups();
             if (onlineGroups.length > 0) {
-                utils_1.logger.log(`[Server] 重新鉴权重连成功，重新注册 ${onlineGroups.length} 个在线群组...`);
-                for (const groupId of onlineGroups) {
+                await instance.agentCP.groupRegisterOnline();
+                utils_1.logger.log(`[Server] 重新鉴权重连成功，已重新注册上线，在线群组: ${onlineGroups.length}`);
+                // 后台异步拉取断线期间可能漏掉的消息
+                Promise.all(onlineGroups.map(async (groupId) => {
                     try {
-                        await instance.agentCP.joinGroupSession(groupId);
-                        utils_1.logger.log(`[Server] 群组重新注册成功: ${groupId}`);
+                        const lastMsgId = instance.agentCP.getGroupLastMsgId(groupId);
+                        await instance.agentCP.pullAndStoreGroupMessages(groupId, lastMsgId, 50);
                     }
                     catch (e) {
-                        utils_1.logger.warn(`[Server] 群组重新注册失败: ${groupId}`, e.message || e);
+                        utils_1.logger.warn(`[Server] reconnect sync failed: ${groupId}`, e.message || e);
                     }
-                }
+                })).then(() => {
+                    utils_1.logger.log(`[Server] 重连后台消息同步完成`);
+                });
             }
         }
         catch (err) {
@@ -284,12 +289,33 @@ async function doEnsureOnline(aid) {
     return instance;
 }
 // 确保群组客户端已初始化
+// 群组客户端初始化锁，防止并发请求重复初始化
+const groupInitPromises = new Map();
 async function ensureGroupClient(instance) {
     if (instance.groupInitialized && instance.agentCP.groupClient)
         return;
     if (!instance.agentWS)
         throw new Error('WebSocket 未连接');
     const aid = instance.aid;
+    // 如果已有初始化在进行中，等待它完成
+    const existing = groupInitPromises.get(aid);
+    if (existing) {
+        await existing;
+        return;
+    }
+    const initPromise = doInitGroupClient(instance);
+    groupInitPromises.set(aid, initPromise);
+    try {
+        await initPromise;
+    }
+    finally {
+        groupInitPromises.delete(aid);
+    }
+}
+async function doInitGroupClient(instance) {
+    if (!instance.agentWS)
+        throw new Error('WebSocket 未连接');
+    const aid = instance.aid;
     // 计算 group target AID: group.{issuer}
     const parts = aid.split('.', 1);
     const issuer = aid.substring(parts[0].length + 1) || aid;
@@ -350,7 +376,7 @@ async function ensureGroupClient(instance) {
         },
         onJoinApproved(groupId, groupAddress) {
             utils_1.logger.log(`[Group] onJoinApproved: group=${groupId} address=${groupAddress}`);
-            // 审核通过：获取群信息、添加本地存储、注册到 Home AP
+            // 审核通过：获取群信息、添加本地存储、注册在线，完成后再通知浏览器
             (async () => {
                 try {
                     if (!instance.agentCP.groupOps) {
@@ -370,12 +396,13 @@ async function ensureGroupClient(instance) {
                 catch (e) {
                     utils_1.logger.error(`[Group] onJoinApproved processing failed: group=${groupId}`, e.message);
                 }
+                // 本地存储就绪后再通知浏览器刷新群列表
+                broadcastToBrowser({
+                    type: 'join_approved',
+                    group_id: groupId,
+                    group_address: groupAddress,
+                });
             })();
-            broadcastToBrowser({
-                type: 'join_approved',
-                group_id: groupId,
-                group_address: groupAddress,
-            });
         },
         onJoinRejected(groupId, reason) {
             utils_1.logger.log(`[Group] onJoinRejected: group=${groupId} reason=${reason}`);
@@ -432,15 +459,27 @@ async function ensureGroupClient(instance) {
             utils_1.logger.warn('[Group] syncGroupList error:', e.message);
         }
     }
-    // 为所有已加入群组注册上线（register_online + 拉取未读 + 启动心跳）
+    // 注册上线 + 将群组加入在线列表（不阻塞）
     const groups = instance.agentCP.getLocalGroupList();
-    for (const group of groups) {
-        try {
-            await instance.agentCP.joinGroupSession(group.group_id);
-        }
-        catch (e) {
-            utils_1.logger.warn(`[Group] joinGroupSession failed: ${group.group_id}`, e.message);
-        }
+    if (groups.length > 0) {
+        await instance.agentCP.groupRegisterOnline();
+        for (const group of groups) {
+            instance.agentCP.addOnlineGroup(group.group_id);
+        }
+        instance.agentCP.ensureGroupHeartbeat();
+        utils_1.logger.log(`[Group] 已注册上线，在线群组: ${groups.length}`);
+        // 后台异步拉取历史消息，不阻塞启动流程
+        Promise.all(groups.map(async (group) => {
+            try {
+                const lastMsgId = instance.agentCP.getGroupLastMsgId(group.group_id);
+                await instance.agentCP.pullAndStoreGroupMessages(group.group_id, lastMsgId, 50);
+            }
+            catch (e) {
+                utils_1.logger.warn(`[Group] background sync failed: ${group.group_id}`, e.message);
+            }
+        })).then(() => {
+            utils_1.logger.log(`[Group] 后台消息同步完成，共 ${groups.length} 个群组`);
+        });
     }
     instance.groupInitialized = true;
     instance.groupSessionId = groupSessionId;
@@ -769,7 +808,7 @@ const indexHtml = `<!DOCTYPE html>
         function updateApSelect() {
             var sel = document.getElementById('apSelect');
             if (sel && sel.options.length === 0) {
-                const options = ['agentcp.io', 'aid.show', 'agentid.pub'];
+                const options = ['agentcp.io', 'agentid.pub'];
                 options.forEach(function(op) {
                     var opt = document.createElement('option');
                     opt.value = op;
@@ -870,6 +909,7 @@ const indexHtml = `<!DOCTYPE html>
                 var data = await res.json();
                 if (data.success) {
                     showStatus(aid + ' 已上线，正在进入聊天...', 'success');
+                    sessionStorage.setItem('chatEntry','1');
                     window.location.href = '/chat';
                 } else {
                     showStatus(data.error || '上线失败', 'error');
@@ -881,7 +921,7 @@ const indexHtml = `<!DOCTYPE html>
             }
         }
 
-        function enterChat(aid) { window.location.href = '/chat'; }
+        function enterChat(aid) { sessionStorage.setItem('chatEntry','1'); window.location.href = '/chat'; }
 
         async function goOffline(aid) {
             try {
@@ -1194,6 +1234,7 @@ const chatHtml = `<!DOCTYPE html>
             <div class="group-info-bar" id="groupInfoBar" style="display:none;">
                 <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"></path><circle cx="9" cy="7" r="4"></circle><path d="M23 21v-2a4 4 0 0 0-3-3.87"></path><path d="M16 3.13a4 4 0 0 1 0 7.75"></path></svg>
                 <span id="groupInfoText">群组</span>
+                <span id="groupMemberStats" style="font-size:11px;color:var(--t2);margin-left:4px;"></span>
                 <span class="copy-link" id="groupInviteBtn" onclick="generateInviteLink()" title="生成邀请链接" style="display:none;">生成邀请链接</span>
                 <span class="copy-link" id="groupCopyLinkBtn" onclick="copyGroupLink()" title="复制群链接" style="display:none;">复制群链接</span>
                 <span class="copy-link" onclick="showGroupMembers()" title="查看成员">成员</span>
@@ -1384,14 +1425,39 @@ const chatHtml = `<!DOCTYPE html>
             if (type === 'human') return '/assets/human.png';
             return '/assets/agent.png';
         }
-        async function fetchAgentInfo(aid) {
-            if (agentInfoCache[aid]) return agentInfoCache[aid];
-            try {
-                var r = await fetch('/api/agent-info?aid=' + encodeURIComponent(aid));
-                var d = await r.json();
-                if (d.type || d.name) { agentInfoCache[aid] = d; }
-                return d;
-            } catch(e) { return { type:'', name:'', description:'', tags:[] }; }
+        // 批量 agent info 请求：攒批 50ms 后合并发送一次
+        var _agentInfoBatchQueue=[];
+        var _agentInfoBatchTimer=null;
+        function _flushAgentInfoBatch(){
+            _agentInfoBatchTimer=null;
+            var queue=_agentInfoBatchQueue;
+            _agentInfoBatchQueue=[];
+            var aids=queue.map(function(q){ return q.aid; });
+            fetch('/api/agent-info-batch',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({aids:aids})})
+                .then(function(r){ return r.json(); })
+                .then(function(d){
+                    if(d.success&&d.data){
+                        queue.forEach(function(q){
+                            var info=d.data[q.aid]||{type:'',name:'',description:'',tags:[]};
+                            if(info.type||info.name) agentInfoCache[q.aid]=info;
+                            q.resolve(info);
+                        });
+                    } else {
+                        var empty={type:'',name:'',description:'',tags:[]};
+                        queue.forEach(function(q){ q.resolve(empty); });
+                    }
+                })
+                .catch(function(){
+                    var empty={type:'',name:'',description:'',tags:[]};
+                    queue.forEach(function(q){ q.resolve(empty); });
+                });
+        }
+        function fetchAgentInfo(aid){
+            if(agentInfoCache[aid]) return Promise.resolve(agentInfoCache[aid]);
+            return new Promise(function(resolve){
+                _agentInfoBatchQueue.push({aid:aid,resolve:resolve});
+                if(!_agentInfoBatchTimer) _agentInfoBatchTimer=setTimeout(_flushAgentInfoBatch,50);
+            });
         }
         async function deleteSession(e, sessionId){
             e.stopPropagation();
@@ -1429,6 +1495,9 @@ const chatHtml = `<!DOCTYPE html>
         function hideNewMsgTip(){ if(D.newMsgTip) D.newMsgTip.style.display='none'; }
 
         async function init(){
+            // 刷新页面时强制回到身份管理页面
+            if(!sessionStorage.getItem('chatEntry')){ window.location.href='/'; return; }
+            sessionStorage.removeItem('chatEntry');
             initDom();
             // 配置 marked：支持换行、GFM
             if(typeof marked!=='undefined'&&marked.setOptions){
@@ -1994,6 +2063,7 @@ const chatHtml = `<!DOCTYPE html>
             D.title.textContent=name;
             D.groupInfoBar.style.display='flex';
             D.groupInfoText.textContent=name;
+            $('groupMemberStats').textContent='';
             D.input.disabled=false;
             D.input.placeholder='输入群消息...';
             D.input.focus();
@@ -2009,7 +2079,7 @@ const chatHtml = `<!DOCTYPE html>
                 gmsg.textContent='选择群组...';
                 await fetch('/api/group/select',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({groupId:groupId,aid:S.aid})});
             } catch(e){}
-            // 获取群信息判断是否为创建者
+            // 获取群信息判断是否为创建者，同时获取成员统计
             try {
                 gmsg.textContent='获取群信息...';
                 var r=await fetch('/api/group/info?groupId='+encodeURIComponent(groupId)+'&aid='+encodeURIComponent(S.aid));
@@ -2022,6 +2092,14 @@ const chatHtml = `<!DOCTYPE html>
                 } else {
                     $('groupCopyLinkBtn').style.display='';
                 }
+                // 展示成员统计
+                if(d.member_stats){
+                    var ms=d.member_stats;
+                    var parts=[ms.total+'人'];
+                    if(ms.human) parts.push(ms.human+'人类');
+                    if(ms.agent) parts.push(ms.agent+'Agent');
+                    $('groupMemberStats').textContent='('+parts.join(' / ')+')';
+                }
             } catch(e){
                 // 获取失败时默认显示复制群链接
                 $('groupCopyLinkBtn').style.display='';
@@ -2234,16 +2312,33 @@ const chatHtml = `<!DOCTYPE html>
             } else {
                 D.msgs.scrollTop=prevScrollTop;
             }
-            // 异步加载未缓存的 agent info，加载完成后重新渲染以更新头像
+            // 异步加载未缓存的 agent info，加载完成后局部更新头像和名字
             var unique=needFetch.filter(function(v,i,a){ return a.indexOf(v)===i; });
-            unique.forEach(function(aid){
-                fetchAgentInfo(aid).then(function(){
-                    if(S.tab!=='group') return;
-                    _lastGroupMsgSig='';
-                    _lastGroupMsgs._forceRender=true;
-                    renderGroupMsgs(_lastGroupMsgs);
+            if(unique.length){
+                fetchAgentInfo(unique[0]); // 触发批量请求（攒批机制会合并）
+                unique.forEach(function(aid){
+                    fetchAgentInfo(aid).then(function(info){
+                        if(!info||S.tab!=='group') return;
+                        // 局部更新 DOM：找到该 sender 的所有消息，更新头像和名字
+                        var avatars=D.msgs.querySelectorAll('.msg-avatar[title="'+escH(aid)+'"]');
+                        var newSrc=getAvatarSrc(info.type);
+                        var displayName=(info.name)||aid;
+                        avatars.forEach(function(img){
+                            img.src=newSrc;
+                            img.title=displayName;
+                            // 更新同一消息里的名字
+                            var msgEl=img.closest('.message');
+                            if(msgEl){
+                                var meta=msgEl.querySelector('.msg-meta');
+                                if(meta&&!msgEl.classList.contains('sent')){
+                                    var timeStr=meta.textContent.split(' · ')[1]||'';
+                                    meta.textContent=displayName+' · '+timeStr;
+                                }
+                            }
+                        });
+                    });
                 });
-            });
+            }
         }
 
         // Group modals
@@ -2738,6 +2833,31 @@ async function handleRequest(req, res) {
         sendJson(res, info);
         return;
     }
+    // 批量获取 agent info，优先读本地缓存，未缓存的后台预热
+    if (pathname === '/api/agent-info-batch' && method === 'POST') {
+        try {
+            const body = await parseBody(req);
+            const aids = body.aids || [];
+            const result = {};
+            const empty = { type: '', name: '', description: '', tags: [] };
+            for (const aid of aids) {
+                const cached = agentInfoCache.get(aid);
+                if (cached && Date.now() - cached.cachedAt < AGENT_INFO_CACHE_TTL) {
+                    result[aid] = { type: cached.type, name: cached.name, description: cached.description, tags: cached.tags || [] };
+                }
+                else {
+                    result[aid] = cached ? { type: cached.type, name: cached.name, description: cached.description, tags: cached.tags || [] } : empty;
+                    // 后台异步拉取，下次请求就有了
+                    getAgentInfo(aid).catch(() => { });
+                }
+            }
+            sendJson(res, { success: true, data: result });
+        }
+        catch (e) {
+            sendJson(res, { success: false, error: e.message });
+        }
+        return;
+    }
     // 获取远程 agent.md 原始内容
     if (pathname === '/api/agent-md-raw' && method === 'GET') {
         const aid = parsedUrl.query.aid;
@@ -3201,15 +3321,13 @@ async function handleRequest(req, res) {
             }
             const instance = await ensureOnline(aid);
             await ensureGroupClient(instance);
-            // 首次访问时从服务端同步群组列表
-            if (!instance.groupListSynced) {
-                try {
-                    await instance.agentCP.syncGroupList();
-                    instance.groupListSynced = true;
-                }
-                catch (syncErr) {
-                    utils_1.logger.warn('[Group] syncGroupList error:', syncErr.message);
-                }
+            // 每次都从服务端同步群组列表，确保审核通过等变更及时反映
+            try {
+                await instance.agentCP.syncGroupList();
+                instance.groupListSynced = true;
+            }
+            catch (syncErr) {
+                utils_1.logger.warn('[Group] syncGroupList error:', syncErr.message);
             }
             const groups = instance.agentCP.getLocalGroupList();
             sendJson(res, { success: true, groups, activeGroupId: instance.activeGroupId });
@@ -3250,8 +3368,33 @@ async function handleRequest(req, res) {
             }
             const instance = await ensureOnline(aid);
             await ensureGroupClient(instance);
-            const info = await instance.agentCP.groupOps.getGroupInfo(instance.groupTargetAid, groupId);
-            sendJson(res, Object.assign({ success: true }, info));
+            const [info, membersResult] = await Promise.all([
+                instance.agentCP.groupOps.getGroupInfo(instance.groupTargetAid, groupId),
+                instance.agentCP.groupOps.getMembers(instance.groupTargetAid, groupId).catch(() => ({ members: [] })),
+            ]);
+            // 只用本地缓存统计成员类型，不发远程请求，不阻塞响应
+            let humanCount = 0, agentCount = 0;
+            const members = membersResult.members || [];
+            for (const m of members) {
+                const memberAid = m.agent_id || '';
+                if (!memberAid)
+                    continue;
+                const cached = agentInfoCache.get(memberAid);
+                if (cached) {
+                    if (cached.type === 'human')
+                        humanCount++;
+                    else if (cached.type === 'agent')
+                        agentCount++;
+                }
+            }
+            sendJson(res, Object.assign(Object.assign({ success: true }, info), { member_stats: { total: members.length, human: humanCount, agent: agentCount } }));
+            // 后台异步预热未缓存的 agent info，下次请求就有了
+            for (const m of members) {
+                const memberAid = m.agent_id || '';
+                if (memberAid && !agentInfoCache.has(memberAid)) {
+                    getAgentInfo(memberAid).catch(() => { });
+                }
+            }
         }
         catch (e) {
             sendJson(res, { success: false, error: e.message });
@@ -3284,6 +3427,7 @@ async function handleRequest(req, res) {
             sendJson(res, Object.assign({ success: true }, result));
         }
         catch (e) {
+            utils_1.logger.error(`[API] /api/group/send FAILED: error=${e.message}`);
             sendJson(res, { success: false, error: e.message });
         }
         return;
@@ -3462,6 +3606,27 @@ async function handleRequest(req, res) {
             }
             const instance = await ensureOnline(aid);
             await ensureGroupClient(instance);
+            // 同步服务端群列表到本地存储，确保新审核通过的群也能在左侧列表显示
+            try {
+                await instance.agentCP.syncGroupList();
+                instance.groupListSynced = true;
+            }
+            catch (syncErr) {
+                utils_1.logger.warn('[Group] my-groups syncGroupList error:', syncErr.message);
+            }
+            // 确保所有本地群都已注册在线
+            const localGroups = instance.agentCP.getLocalGroupList();
+            const onlineGroups = new Set(instance.agentCP.getOnlineGroups());
+            for (const g of localGroups) {
+                if (!onlineGroups.has(g.group_id)) {
+                    try {
+                        await instance.agentCP.joinGroupSession(g.group_id);
+                    }
+                    catch (e) {
+                        utils_1.logger.warn(`[Group] my-groups joinGroupSession failed: ${g.group_id}`, e.message);
+                    }
+                }
+            }
             const ops = instance.agentCP.groupOps;
             const target = instance.groupTargetAid;
             const result = await ops.listMyGroups(target);

package/package.json

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