openclaw-lark-multi-agent 0.1.14 → 0.1.15

package/dist/discussion-manager.js

@@ -92,10 +92,27 @@ export class DiscussionManager {
                 replies[value.botName] = value.error ? `[ERROR] ${value.error}` : value.text.trim();
             }
             current.completedRounds.push({ round: current.currentRound, replies });
+            const noReplyNames = participants
+                .map((participant) => participant.name)
+                .filter((name) => {
+                const text = (replies[name] || "").trim();
+                return !text || text.toUpperCase() === "NO_REPLY";
+            });
+            const errorNames = participants
+                .map((participant) => participant.name)
+                .filter((name) => (replies[name] || "").trim().startsWith("[ERROR]"));
             const allNoReply = participants.every((participant) => {
                 const text = (replies[participant.name] || "").trim();
                 return !text || text.toUpperCase() === "NO_REPLY" || text.startsWith("[ERROR]");
             });
+            if (sendSystemMessage && !allNoReply && (noReplyNames.length > 0 || errorNames.length > 0)) {
+                const parts = [];
+                if (noReplyNames.length > 0)
+                    parts.push(`${noReplyNames.join("、")} 无新增回复`);
+                if (errorNames.length > 0)
+                    parts.push(`${errorNames.join("、")} 出错`);
+                await sendSystemMessage(`💬 第 ${current.currentRound}/${current.maxRounds} 轮：${parts.join("；")}`).catch(() => { });
+            }
             if (allNoReply) {
                 current.status = "completed";
                 this.sessions.delete(current.chatId);

package/dist/feishu-bot.js

@@ -503,6 +503,8 @@ export class FeishuBot {
             }
             // --- Discuss mode: group-level multi-bot round scheduler. It takes over
             // plain human messages so normal Free mode does not duplicate Round 1.
+            // Targeted mentions must fall through to normal routing so @GPT still
+            // works while discuss mode is enabled.
             if (chatType !== "p2p" && !isBot && this.store.getChatInfo(chatId)?.discuss) {
                 const mentions = message.mentions || [];
                 const hasTargetedMention = mentions.some((m) => !this.isAllMentionItem(m));
@@ -924,11 +926,16 @@ export class FeishuBot {
     async enqueueAndDispatchDelivery(chatId, sourceType, sourceId, text, attachments = [], replyToMessageId, deliveryKey) {
         if (!text.trim() && attachments.length === 0)
             return;
-        const normalizedPayload = `${text.trim()}|${JSON.stringify(attachments)}`;
+        const attachmentsJson = JSON.stringify(attachments);
+        const normalizedPayload = `${text.trim()}|${attachmentsJson}`;
         const contentHash = this.stableHash(normalizedPayload);
         const finalDeliveryKey = deliveryKey || sourceId;
-        if (!deliveryKey && this.store.hasRecentSimilarDelivery(this.config.name, chatId, contentHash, 60_000))
-            return;
+        if (!deliveryKey) {
+            if (this.store.hasRecentSimilarDelivery(this.config.name, chatId, contentHash, 60_000))
+                return;
+            if (this.store.hasRecentOverlappingDelivery(this.config.name, chatId, text, attachmentsJson, 60_000, 8))
+                return;
+        }
         const deliveryId = this.store.enqueueDelivery({
             sessionKey: this.deliverySessionKey(chatId),
             chatId,
@@ -938,7 +945,7 @@ export class FeishuBot {
             deliveryKey: finalDeliveryKey,
             contentHash,
             content: text,
-            attachmentsJson: JSON.stringify(attachments),
+            attachmentsJson,
             replyToMessageId: replyToMessageId || "",
         });
         if (deliveryId === null)
@@ -998,22 +1005,36 @@ export class FeishuBot {
     }
     async runDiscussionTurn(chatId, prompt, meta) {
         const sessionKey = await this.ensureSession(chatId);
-        const reply = await this.openclawClient.chatSendWithContext({
-            sessionKey,
-            unsyncedMessages: [],
-            currentMessage: prompt,
-            currentSenderName: "Discussion Scheduler",
-            deliver: false,
-            timeoutMs: 1_800_000,
-        });
+        const releaseProactiveMute = this.openclawClient.muteProactiveDelivery(sessionKey);
+        let reply;
+        try {
+            reply = await this.openclawClient.chatSendWithContext({
+                sessionKey,
+                unsyncedMessages: [],
+                currentMessage: prompt,
+                currentSenderName: "Discussion Scheduler",
+                deliver: false,
+                timeoutMs: 1_800_000,
+            });
+        }
+        finally {
+            // OpenClaw can emit the final assistant session.message shortly after
+            // chatSend/collectReply returns. Keep discussion proactive muted briefly;
+            // the discussion coordinator already owns user-visible delivery.
+            releaseProactiveMute(120_000);
+        }
         const parsedReply = this.extractBridgeAttachments(reply);
-        let visibleReply = parsedReply.text.trim();
-        const isVisible = visibleReply.length > 0 && visibleReply.toUpperCase() !== "NO_REPLY";
+        const rawVisibleReply = parsedReply.text.trim();
+        const discussionMarkerPattern = /\n*—— 第 \d+\/\d+ 轮 · .+$/;
+        const cleanVisibleReply = rawVisibleReply.replace(discussionMarkerPattern, "").trim();
+        let displayReply = cleanVisibleReply;
+        const isVisible = cleanVisibleReply.length > 0 && cleanVisibleReply.toUpperCase() !== "NO_REPLY";
         if (isVisible && meta) {
-            visibleReply = `${visibleReply}\n\n—— 第 ${meta.round}/${meta.maxRounds} 轮 · ${this.config.name}`;
+            const roundMarker = `—— 第 ${meta.round}/${meta.maxRounds} 轮 · ${this.config.name}`;
+            displayReply = `${displayReply}\n\n${roundMarker}`;
         }
         if (isVisible || parsedReply.attachments.length > 0) {
-            const storedContent = [visibleReply, ...parsedReply.attachments.map((a) => `[Attachment: ${a.type || "file"} ${a.path}]`)]
+            const storedContent = [displayReply, ...parsedReply.attachments.map((a) => `[Attachment: ${a.type || "file"} ${a.path}]`)]
                 .filter(Boolean)
                 .join("\n");
             this.store.insert({
@@ -1024,9 +1045,9 @@ export class FeishuBot {
                 content: storedContent,
                 timestamp: Date.now(),
             });
-            await this.enqueueAndDispatchDelivery(chatId, "discussion", `discussion:${Date.now()}:${Math.random().toString(36).slice(2)}`, isVisible ? visibleReply : "", parsedReply.attachments);
+            await this.enqueueAndDispatchDelivery(chatId, "discussion", `discussion:${Date.now()}:${Math.random().toString(36).slice(2)}`, isVisible ? displayReply : "", parsedReply.attachments);
         }
-        return { botName: this.config.name, text: visibleReply, visible: isVisible };
+        return { botName: this.config.name, text: cleanVisibleReply, visible: isVisible };
     }
     async replyMessage(messageId, text) {
         // Use Feishu CardKit v2 markdown component for full Markdown rendering.

package/dist/message-store.d.ts

@@ -61,6 +61,7 @@ export declare class MessageStore {
     getDeliveryBySource(sessionKey: string, sourceType: string, sourceId: string): DeliveryOutboxItem | null;
     getPendingDeliveries(chatId?: string, botName?: string, maxCount?: number): DeliveryOutboxItem[];
     hasRecentSimilarDelivery(botName: string, chatId: string, contentHash: string, windowMs: number): boolean;
+    hasRecentOverlappingDelivery(botName: string, chatId: string, content: string, attachmentsJson: string, windowMs: number, minShortLength?: number): boolean;
     claimDelivery(id: number): boolean;
     markDeliveryDelivered(id: number): void;
     markDeliveryFailed(id: number): void;

package/dist/message-store.js

@@ -304,6 +304,29 @@ export class MessageStore {
     `).get(botName, chatId, contentHash, Date.now() - windowMs);
         return !!row;
     }
+    hasRecentOverlappingDelivery(botName, chatId, content, attachmentsJson, windowMs, minShortLength = 8) {
+        const normalized = content.trim();
+        if (normalized.length < minShortLength)
+            return false;
+        const rows = this.db.prepare(`
+      SELECT content, attachments_json FROM delivery_outbox
+      WHERE bot_name = ? AND chat_id = ? AND created_at >= ? AND status IN ('pending', 'delivering', 'delivered')
+      ORDER BY created_at DESC
+      LIMIT 20
+    `).all(botName, chatId, Date.now() - windowMs);
+        for (const row of rows) {
+            if ((row.attachments_json || '[]') !== attachmentsJson)
+                continue;
+            const existing = String(row.content || '').trim();
+            if (existing.length < minShortLength)
+                continue;
+            const shorter = existing.length <= normalized.length ? existing : normalized;
+            const longer = existing.length <= normalized.length ? normalized : existing;
+            if (shorter.length >= minShortLength && longer.includes(shorter))
+                return true;
+        }
+        return false;
+    }
     claimDelivery(id) {
         const result = this.db.prepare(`
       UPDATE delivery_outbox SET status = 'delivering', attempts = attempts + 1, updated_at = ? WHERE id = ? AND status = 'pending'

package/dist/openclaw-client.d.ts

@@ -25,12 +25,16 @@ export declare class OpenClawClient {
     private sessionMessageCallbacks;
     /** Session keys that should be re-subscribed on reconnect */
     private subscribedKeys;
-    /** Session keys with active/recent chatSend — suppress proactive message delivery */
+    /** Session keys with active/recent chatSend — proactive is forwarded and deduped by outbox. */
     private suppressedSessions;
     private suppressedSessionTimers;
+    /** Session keys whose proactive messages must be dropped by the bridge (e.g. discussion scheduler owns delivery). */
+    private mutedProactiveSessions;
+    private mutedProactiveSessionCounts;
     constructor(config: OpenClawConfig);
     connect(): Promise<void>;
     private _doConnect;
+    private handleProactiveSessionMessage;
     private scheduleReconnect;
     private rpc;
     /**
@@ -71,6 +75,9 @@ export declare class OpenClawClient {
     abortChat(sessionKey: string, runId: string): Promise<any>;
     private suppressSessionKeys;
     private releaseSuppressedSessionKeysAfter;
+    private addMutedProactiveKey;
+    private releaseMutedProactiveKey;
+    muteProactiveDelivery(sessionKey: string): (delayMs?: number) => void;
     chatSend(params: {
         sessionKey: string;
         message: string;

package/dist/openclaw-client.js

@@ -23,9 +23,12 @@ export class OpenClawClient {
     sessionMessageCallbacks = new Map();
     /** Session keys that should be re-subscribed on reconnect */
     subscribedKeys = new Set();
-    /** Session keys with active/recent chatSend — suppress proactive message delivery */
+    /** Session keys with active/recent chatSend — proactive is forwarded and deduped by outbox. */
     suppressedSessions = new Set();
     suppressedSessionTimers = new Map();
+    /** Session keys whose proactive messages must be dropped by the bridge (e.g. discussion scheduler owns delivery). */
+    mutedProactiveSessions = new Set();
+    mutedProactiveSessionCounts = new Map();
     constructor(config) {
         this.config = config;
     }
@@ -140,45 +143,7 @@ export class OpenClawClient {
                     // Try both raw key and without agent:main: prefix
                     const shortKey = rawKey.replace(/^agent:[^:]+:/, "");
                     const msg = frame.payload.message || frame.payload;
-                    const role = msg.role;
-                    const content = msg.content;
-                    // Proactive assistant text messages (suppress during active chatSend).
-                    // Cron/session-targeted runs often emit structured content arrays rather
-                    // than a plain string. Extract only visible text parts and ignore thinking
-                    // / tool blocks so the bridge can deliver final cron results via the bot.
-                    let proactiveText = "";
-                    if (role === "assistant") {
-                        if (typeof content === "string") {
-                            proactiveText = content;
-                        }
-                        else if (Array.isArray(content)) {
-                            const hasToolBlock = content.some((part) => {
-                                const type = String(part?.type || "").toLowerCase();
-                                return type === "toolcall" || type === "tool_call" || type === "tooluse" || type === "tool_use" || type === "toolresult" || type === "tool_result";
-                            });
-                            // Do not deliver mixed text+toolCall assistant messages through
-                            // the proactive final-text path; those are usually intermediate
-                            // reasoning/status during a tool loop. Tool calls are still
-                            // delivered via the verbose channel from agent item events when
-                            // /verbose is enabled. Cron final messages arrive as text-only
-                            // (optionally with thinking).
-                            if (!hasToolBlock) {
-                                proactiveText = content
-                                    .filter((part) => part?.type === "text" && typeof part.text === "string")
-                                    .map((part) => part.text)
-                                    .join("\n")
-                                    .trim();
-                            }
-                        }
-                    }
-                    if (proactiveText) {
-                        if (this.suppressedSessions.has(rawKey) || this.suppressedSessions.has(shortKey)) {
-                            console.log(`[OpenClaw] Forwarding proactive msg for ${shortKey} during active chatSend; delivery outbox will dedupe`);
-                        }
-                        const cb = this.sessionMessageCallbacks.get(rawKey) || this.sessionMessageCallbacks.get(shortKey);
-                        if (cb)
-                            cb(proactiveText);
-                    }
+                    this.handleProactiveSessionMessage(rawKey, msg);
                     // Tool calls in assistant messages — skip, using agent item events instead
                     // (session.message toolCall events are batched, not real-time)
                 }
@@ -210,6 +175,53 @@ export class OpenClawClient {
             });
         });
     }
+    handleProactiveSessionMessage(rawKey, msg) {
+        const shortKey = rawKey.replace(/^agent:[^:]+:/, "");
+        const role = msg.role;
+        const content = msg.content;
+        // Proactive assistant text messages. Cron/session-targeted runs often emit
+        // structured content arrays rather than a plain string. Extract only visible
+        // text parts and ignore thinking/tool blocks so the bridge can deliver final
+        // cron results via the bot.
+        let proactiveText = "";
+        if (role === "assistant") {
+            if (typeof content === "string") {
+                proactiveText = content;
+            }
+            else if (Array.isArray(content)) {
+                const hasToolBlock = content.some((part) => {
+                    const type = String(part?.type || "").toLowerCase();
+                    return type === "toolcall" || type === "tool_call" || type === "tooluse" || type === "tool_use" || type === "toolresult" || type === "tool_result";
+                });
+                // Do not deliver mixed text+toolCall assistant messages through
+                // the proactive final-text path; those are usually intermediate
+                // reasoning/status during a tool loop. Tool calls are still
+                // delivered via the verbose channel from agent item events when
+                // /verbose is enabled. Cron final messages arrive as text-only
+                // (optionally with thinking).
+                if (!hasToolBlock) {
+                    proactiveText = content
+                        .filter((part) => part?.type === "text" && typeof part.text === "string")
+                        .map((part) => part.text)
+                        .join("\n")
+                        .trim();
+                }
+            }
+        }
+        if (!proactiveText)
+            return false;
+        if (this.mutedProactiveSessions.has(rawKey) || this.mutedProactiveSessions.has(shortKey)) {
+            console.log(`[OpenClaw] Dropping proactive msg for ${shortKey}; delivery is owned by the caller`);
+            return false;
+        }
+        if (this.suppressedSessions.has(rawKey) || this.suppressedSessions.has(shortKey)) {
+            console.log(`[OpenClaw] Forwarding proactive msg for ${shortKey} during active chatSend; delivery outbox will dedupe`);
+        }
+        const cb = this.sessionMessageCallbacks.get(rawKey) || this.sessionMessageCallbacks.get(shortKey);
+        if (cb)
+            cb(proactiveText);
+        return Boolean(cb);
+    }
     scheduleReconnect() {
         const delay = this.reconnectDelay;
         this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay);
@@ -492,6 +504,42 @@ export class OpenClawClient {
             this.suppressedSessionTimers.set(key, timer);
         }
     }
+    addMutedProactiveKey(key) {
+        const count = this.mutedProactiveSessionCounts.get(key) || 0;
+        this.mutedProactiveSessionCounts.set(key, count + 1);
+        this.mutedProactiveSessions.add(key);
+    }
+    releaseMutedProactiveKey(key) {
+        const count = this.mutedProactiveSessionCounts.get(key) || 0;
+        if (count <= 1) {
+            this.mutedProactiveSessionCounts.delete(key);
+            this.mutedProactiveSessions.delete(key);
+        }
+        else {
+            this.mutedProactiveSessionCounts.set(key, count - 1);
+        }
+    }
+    muteProactiveDelivery(sessionKey) {
+        const shortKey = sessionKey.startsWith("agent:main:") ? sessionKey.slice("agent:main:".length) : sessionKey;
+        const fullKey = `agent:main:${shortKey}`;
+        const keys = [shortKey, fullKey];
+        for (const key of keys)
+            this.addMutedProactiveKey(key);
+        let released = false;
+        return (delayMs = 0) => {
+            if (released)
+                return;
+            released = true;
+            const release = () => {
+                for (const key of keys)
+                    this.releaseMutedProactiveKey(key);
+            };
+            if (delayMs > 0)
+                setTimeout(release, delayMs);
+            else
+                release();
+        };
+    }
     async chatSend(params) {
         const sk = params.sessionKey;
         const fullSessionKey = `agent:main:${sk}`;
@@ -619,6 +667,8 @@ export class OpenClawClient {
             clearTimeout(timer);
         this.suppressedSessionTimers.clear();
         this.suppressedSessions.clear();
+        this.mutedProactiveSessions.clear();
+        this.mutedProactiveSessionCounts.clear();
         if (this.ws) {
             this.ws.close();
             this.ws = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-lark-multi-agent",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {