openclaw-lark-multi-agent 0.1.3 → 0.1.4

package/README.md

@@ -232,6 +232,29 @@ OpenClaw-level slash commands can be sent by escaping with a double slash:
 
 The bridge converts `//status` to `/status` and forwards it to OpenClaw instead of handling it locally.
 
+How to test the double-slash behavior:
+
+1. In a private chat with one bot, send `//status`.
+   - Expected: the message is forwarded to OpenClaw as `/status`.
+   - It should **not** be handled by the bridge-level `/status` command.
+2. In a group chat, mention a specific bot or use `@all` with a double slash:
+
+```text
+@GPT //status
+@all //reset
+```
+
+Expected: the bridge strips the leading mention for routing, converts `//...` to `/...`, and forwards the command to OpenClaw.
+
+To test bridge-level commands instead, use a single slash:
+
+```text
+/reset
+@all /reset
+```
+
+Expected: the bridge handles the command locally and does not forward it to OpenClaw.
+
 ## Message routing rules
 
 ### Private chats

package/README.zh-CN.md

@@ -232,6 +232,29 @@ openclaw-lark-multi-agent install-windows-service
 
 桥接层会把 `//status` 转成 `/status` 并转发给 OpenClaw，而不是自己处理。
 
+如何测试 double slash 行为：
+
+1. 在某个 bot 私聊里发送 `//status`。
+   - 预期：消息会被转成 `/status` 发给 OpenClaw。
+   - 它**不会**被桥接层当成本地 `/status` 命令处理。
+2. 在群聊里，先 @ 某个 bot，或者 @所有人，再加双斜杠命令：
+
+```text
+@GPT //status
+@所有人 //reset
+```
+
+预期：桥接层只用前面的 @ 来做路由，然后把 `//...` 转成 `/...` 发给 OpenClaw。
+
+如果要测试桥接层自己的命令，用单斜杠：
+
+```text
+/reset
+@所有人 /reset
+```
+
+预期：桥接层本地处理这个命令，不会转发给 OpenClaw。
+
 ## 消息路由规则
 
 ### 私聊

package/dist/feishu-bot.d.ts

@@ -64,11 +64,15 @@ export declare class FeishuBot {
      */
     private processQueue;
     private processQueueInner;
+    private shouldHandleBridgeCommand;
     private shouldRespond;
     private isMentioned;
+    private isAllMention;
+    private mentionedBotName;
     private resolveBotName;
     private resolveHumanName;
     private cleanMentions;
+    private stripLeadingCommandMentions;
     private replyMessage;
     /**
      * Send a proactive message to a chat (not a reply).

package/dist/feishu-bot.js

@@ -302,11 +302,18 @@ export class FeishuBot {
             }
             if (!cleanText.trim())
                 return;
+            // Commands may be prefixed by @all / @bot in group chats. Strip those
+            // leading routing mentions before deciding whether this is a bridge command
+            // or an escaped OpenClaw command.
+            const trimmedCleanText = cleanText.trim();
+            const commandText = this.stripLeadingCommandMentions(trimmedCleanText);
             // Escape hatch: //command means send /command through to OpenClaw,
             // while /command remains a bridge-level openclaw-lark-multi-agent command.
-            const trimmedCleanText = cleanText.trim();
-            if (trimmedCleanText.startsWith("//")) {
-                cleanText = "/" + trimmedCleanText.slice(2);
+            if (commandText.startsWith("//")) {
+                cleanText = "/" + commandText.slice(2).trimStart();
+            }
+            else if (commandText.startsWith("/")) {
+                cleanText = commandText;
             }
             // --- Record to local store (ALL messages, before command/response checks) ---
             const senderName = isBot
@@ -327,11 +334,13 @@ export class FeishuBot {
             // --- Commands: in p2p always respond; in group, check shouldRespond first ---
             // Single slash commands are handled by the bridge. Double slash commands were
             // already unescaped above and should pass through to OpenClaw instead.
-            const isBridgeCommand = !trimmedCleanText.startsWith("//");
+            const isBridgeCommand = !commandText.startsWith("//");
             const isCommand = isBridgeCommand && /^\/(help|status|compact|reset|verbose|free)/.test(cleanText.trim());
             if (isCommand) {
-                // In group chats, commands also require mention/shouldRespond
-                if (chatType !== "p2p" && !this.shouldRespond(chatType, message, isBot, chatId, message.content))
+                // In group chats, bridge commands must be explicitly routed to this bot
+                // or @all. Do not let Free Discussion make a bot execute commands meant
+                // for another bot.
+                if (chatType !== "p2p" && !this.shouldHandleBridgeCommand(chatType, message, isBot, message.content))
                     return;
                 const markCommandSynced = () => {
                     if (insertedId > 0) {
@@ -343,12 +352,33 @@ export class FeishuBot {
                     const helpText = [
                         `📚 ${this.config.name} Bot 命令列表`,
                         `━━━━━━━━━━━━━━━━━━`,
+                        `桥接层命令（单斜杠，由 openclaw-lark-multi-agent 本地处理）`,
                         `📊 /status  — 查看当前模型、Token 用量、Session 状态`,
-                        `🧹 /compact — 压缩上下文（保留摘要，释放 token）`,
-                        `🔄 /reset   — 重置会话（清空历史，从头开始）`,
-                        `🔊 /verbose — 开关 Tool Call 显示（查看 AI 调用了哪些工具）`,
-                        `🔓 /free    — 开关 Free Discussion（群聊中无需 @ 即可回复）`,
+                        `🧹 /compact — 压缩当前 bot 的 OpenClaw session`,
+                        `🔄 /reset   — 重置当前 bot 的 OpenClaw session`,
+                        `🔊 /verbose — 开关当前聊天里的 Tool Call 显示`,
+                        `🔓 /free [on|off|status] — 开关当前 bot 在当前群聊的 Free Discussion`,
                         `❓ /help    — 显示此帮助信息`,
+                        ``,
+                        `OpenClaw 原生命令（双斜杠，会转成单斜杠发给 OpenClaw）`,
+                        `🆕 //new — 新建/切换会话`,
+                        `🔄 //reset — 让 OpenClaw 自己执行 reset`,
+                        `🧹 //compact [instructions] — 让 OpenClaw 压缩上下文`,
+                        `⏹️ //stopOptions — 查看/停止当前运行选项`,
+                        `🧠 //think <level> — 设置思考等级`,
+                        `🤖 //model <id> — 切换/查看模型`,
+                        `⚡ //fast status|on|off — OpenAI fast mode`,
+                        `🔊 //verbose on|off|full — OpenClaw verbose`,
+                        `🧵 //trace on|off|rawStatus — OpenClaw trace`,
+                        `📊 //status — OpenClaw 原生状态`,
+                        `📋 //tasks — 查看任务`,
+                        `👤 //whoami — 查看当前身份/会话`,
+                        `🧩 //contextSkills — 查看当前上下文技能`,
+                        `🛠️ //skill <name> [input] — 调用技能`,
+                        `🧰 //tools — 查看可用工具`,
+                        `📖 //commands — 查看完整 OpenClaw 命令`,
+                        ``,
+                        `示例：群里发 @${this.config.name} //status，可把 /status 直接交给 OpenClaw。`,
                     ].join("\n");
                     await this.replyMessage(messageId, helpText);
                     markCommandSynced();
@@ -390,14 +420,23 @@ export class FeishuBot {
                         markCommandSynced();
                         return;
                     }
-                    const chatInfo = this.store.getChatInfo(chatId);
-                    const isOn = chatInfo?.freeDiscussion || false;
-                    this.store.setFreeDiscussion(chatId, !isOn);
-                    if (isOn) {
-                        await this.replyMessage(messageId, "🔒 Free Discussion 已关闭\n群聊中需要 @ 指定 Bot 才会回复");
+                    const parts = cleanText.trim().split(/\s+/);
+                    const arg = (parts[1] || "").toLowerCase();
+                    const isOn = this.store.getBotFreeDiscussion(this.config.name, chatId);
+                    const next = arg === "on" || arg === "true" || arg === "1"
+                        ? true
+                        : arg === "off" || arg === "false" || arg === "0"
+                            ? false
+                            : arg === "status"
+                                ? isOn
+                                : !isOn;
+                    if (arg !== "status")
+                        this.store.setBotFreeDiscussion(this.config.name, chatId, next);
+                    if (next) {
+                        await this.replyMessage(messageId, `🔓 ${this.config.name} Free Discussion 已开启\n只影响当前 Bot 在当前群聊的自由发言（连续 Bot 回复超过 ${MAX_BOT_STREAK} 轮将暂停，等待人类发言）`);
                     }
                     else {
-                        await this.replyMessage(messageId, "🔓 Free Discussion 已开启\n所有 Bot 可以自由参与讨论（连续 Bot 回复超过 " + MAX_BOT_STREAK + " 轮将暂停，等待人类发言）");
+                        await this.replyMessage(messageId, `🔒 ${this.config.name} Free Discussion 已关闭\n只影响当前 Bot；群聊中需要 @ 指定 Bot 才会回复`);
                     }
                     markCommandSynced();
                     return;
@@ -576,6 +615,16 @@ export class FeishuBot {
             await new Promise((r) => setTimeout(r, 200));
         }
     }
+    shouldHandleBridgeCommand(chatType, message, isBot, rawText) {
+        if (chatType === "p2p")
+            return !isBot;
+        if (isBot)
+            return false;
+        const mentions = message.mentions || [];
+        if (this.isAllMention(rawText, mentions))
+            return true;
+        return this.isMentioned(mentions);
+    }
     shouldRespond(chatType, message, isBot, chatId, rawText) {
         if (chatType === "p2p")
             return !isBot;
@@ -585,52 +634,48 @@ export class FeishuBot {
             return this.isMentioned(mentions);
         }
         // @all in text: all bots respond
-        if (rawText && (rawText.includes("@_all") || rawText.includes("@all")))
+        if (this.isAllMention(rawText, mentions))
             return true;
         // Check if this bot is explicitly mentioned
         if (this.isMentioned(mentions))
             return true;
         // Check if any other bot is mentioned (not us) — don't respond
-        const anyBotMentioned = mentions.some((m) => {
-            for (const bot of FeishuBot.allBots.values()) {
-                if (m.id?.app_id === bot.config.appId)
-                    return true;
-                if (bot.botOpenId && m.id?.open_id === bot.botOpenId)
-                    return true;
-            }
-            return false;
-        });
+        const anyBotMentioned = mentions.some((m) => this.mentionedBotName(m) !== null);
         if (anyBotMentioned && !this.isMentioned(mentions))
             return false;
         // No bot mentioned: check free discussion mode
         if (chatId) {
-            const chatInfo = this.store.getChatInfo(chatId);
-            if (chatInfo?.freeDiscussion)
+            if (this.store.getBotFreeDiscussion(this.config.name, chatId))
                 return true;
         }
         // Default: don't respond without @
         return false;
     }
     isMentioned(mentions) {
-        return mentions.some((m) => {
-            // @ this specific bot
-            if (m.id?.app_id === this.config.appId)
-                return true;
-            if (this.botOpenId && m.id?.open_id === this.botOpenId)
-                return true;
-            // Feishu may provide only a display name in some mention payloads.
-            // Use this only as a fallback; open_id/app_id checks above remain primary.
-            if (typeof m.name === "string") {
-                const normalizedName = m.name.toLowerCase();
-                const normalizedConfigName = this.config.name.toLowerCase();
-                if (normalizedName === normalizedConfigName || normalizedName.includes(`（${normalizedConfigName}）`) || normalizedName.includes(`(${normalizedConfigName})`))
-                    return true;
-            }
-            // @all / @ 所有人 is handled by raw text gating, not by direct-bot mention matching.
-            if (m.key === "all" || m.key === "@_all" || m.id?.user_id === "all" || m.id?.open_id === "all" || m.name === "所有人")
-                return false;
-            return false;
-        });
+        return mentions.some((m) => this.mentionedBotName(m) === this.config.name);
+    }
+    isAllMention(rawText, mentions = []) {
+        if (rawText && (rawText.includes("@_all") || rawText.includes("@all") || rawText.includes("@所有人")))
+            return true;
+        return mentions.some((m) => m.key === "all" || m.key === "@_all" || m.id?.user_id === "all" || m.id?.open_id === "all" || m.name === "所有人");
+    }
+    mentionedBotName(mention) {
+        if (mention.key === "all" || mention.key === "@_all" || mention.id?.user_id === "all" || mention.id?.open_id === "all" || mention.name === "所有人")
+            return null;
+        const candidates = [this, ...Array.from(FeishuBot.allBots.values()).filter((bot) => bot !== this)];
+        for (const bot of candidates) {
+            if (mention.id?.app_id === bot.config.appId)
+                return bot.config.name;
+            if (bot.botOpenId && mention.id?.open_id === bot.botOpenId)
+                return bot.config.name;
+            if (typeof mention.name === "string") {
+                const n = mention.name.toLowerCase();
+                const botName = bot.config.name.toLowerCase();
+                if (n === botName || n.includes(`（${botName}）`) || n.includes(`(${botName})`))
+                    return bot.config.name;
+            }
+        }
+        return null;
     }
     resolveBotName(sender) {
         const openId = sender?.sender_id?.open_id;
@@ -647,6 +692,18 @@ export class FeishuBot {
     cleanMentions(text) {
         return text.replace(/@_user_\d+/g, "").trim();
     }
+    stripLeadingCommandMentions(text) {
+        let s = text.trim();
+        let prev = "";
+        while (s !== prev) {
+            prev = s;
+            s = s
+                .replace(/^(@_all|@all|@所有人|所有人)\s*/i, "")
+                .replace(/^@\S+\s*/u, "")
+                .trimStart();
+        }
+        return s;
+    }
     async replyMessage(messageId, text) {
         // Use interactive card for markdown rendering
         const card = {
@@ -699,16 +756,23 @@ export class FeishuBot {
                 },
             });
         }
-        catch {
+        catch (err) {
+            console.warn(`[${this.config.name}] sendMessage interactive failed:`, JSON.stringify(err?.response?.data || err?.data || { message: err.message }));
             // Fallback to plain text
-            await this.client.im.message.create({
-                params: { receive_id_type: "chat_id" },
-                data: {
-                    receive_id: chatId,
-                    content: JSON.stringify({ text }),
-                    msg_type: "text",
-                },
-            });
+            try {
+                await this.client.im.message.create({
+                    params: { receive_id_type: "chat_id" },
+                    data: {
+                        receive_id: chatId,
+                        content: JSON.stringify({ text }),
+                        msg_type: "text",
+                    },
+                });
+            }
+            catch (fallbackErr) {
+                console.warn(`[${this.config.name}] sendMessage text failed:`, JSON.stringify(fallbackErr?.response?.data || fallbackErr?.data || { message: fallbackErr.message }));
+                throw fallbackErr;
+            }
         }
     }
     /**
@@ -785,7 +849,7 @@ export class FeishuBot {
         const sessionExists = session ? "✅ 活跃" : "⏳ 未初始化";
         const status = session?.status || "unknown";
         const verboseStatus = this.store.getBotVerbose(this.config.name, chatId) ? "🔊 开启" : "🔇 关闭";
-        const freeStatus = chatInfo?.freeDiscussion ? "🔓 开启" : "🔒 关闭";
+        const freeStatus = this.store.getBotFreeDiscussion(this.config.name, chatId) ? "🔓 开启" : "🔒 关闭";
         const statusText = [
             `📊 ${this.config.name} Bot Status`,
             `━━━━━━━━━━━━━━━━━━`,

package/dist/message-store.d.ts

@@ -58,6 +58,8 @@ export declare class MessageStore {
     setVerbose(chatId: string, verbose: boolean): void;
     setBotVerbose(botName: string, chatId: string, verbose: boolean): void;
     getBotVerbose(botName: string, chatId: string): boolean;
+    setBotFreeDiscussion(botName: string, chatId: string, on: boolean): void;
+    getBotFreeDiscussion(botName: string, chatId: string): boolean;
     getChatInfo(chatId: string): ChatInfo | null;
     getAllChatInfo(): ChatInfo[];
     /**

package/dist/message-store.js

@@ -70,11 +70,12 @@ export class MessageStore {
       );
 
       -- Per-bot, per-chat settings. A group can contain multiple bots, so settings
-      -- like verbose must not be shared globally at chat level.
+      -- like verbose/free discussion must not be shared globally at chat level.
       CREATE TABLE IF NOT EXISTS bot_chat_settings (
         bot_name TEXT NOT NULL,
         chat_id TEXT NOT NULL,
         verbose INTEGER NOT NULL DEFAULT 0,
+        free_discussion INTEGER NOT NULL DEFAULT 0,
         updated_at INTEGER NOT NULL DEFAULT 0,
         PRIMARY KEY (bot_name, chat_id)
       );
@@ -100,6 +101,13 @@ export class MessageStore {
         catch {
             // Column already exists
         }
+        // Migration: make free discussion per-bot per-chat.
+        try {
+            this.db.exec(`ALTER TABLE bot_chat_settings ADD COLUMN free_discussion INTEGER NOT NULL DEFAULT 0`);
+        }
+        catch {
+            // Column already exists
+        }
     }
     /**
      * Insert a message. Returns the auto-increment id, or -1 if duplicate.
@@ -270,6 +278,22 @@ export class MessageStore {
     `).get(botName, chatId);
         return !!row?.verbose;
     }
+    setBotFreeDiscussion(botName, chatId, on) {
+        this.db.prepare(`
+      INSERT INTO bot_chat_settings (bot_name, chat_id, free_discussion, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT (bot_name, chat_id) DO UPDATE SET
+        free_discussion = excluded.free_discussion,
+        updated_at = excluded.updated_at
+    `).run(botName, chatId, on ? 1 : 0, Date.now());
+    }
+    getBotFreeDiscussion(botName, chatId) {
+        const row = this.db.prepare(`
+      SELECT free_discussion FROM bot_chat_settings
+      WHERE bot_name = ? AND chat_id = ?
+    `).get(botName, chatId);
+        return !!row?.free_discussion;
+    }
     getChatInfo(chatId) {
         const row = this.db.prepare(`SELECT * FROM chat_info WHERE chat_id = ?`).get(chatId);
         if (!row)

package/dist/openclaw-client.js

@@ -139,15 +139,31 @@ export class OpenClawClient {
                     const msg = frame.payload.message || frame.payload;
                     const role = msg.role;
                     const content = msg.content;
-                    // Proactive assistant text messages (suppress during active chatSend)
-                    if (role === "assistant" && typeof content === "string") {
+                    // 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)) {
+                            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] Suppressing proactive msg for ${shortKey} (active chatSend)`);
                         }
                         else {
                             const cb = this.sessionMessageCallbacks.get(rawKey) || this.sessionMessageCallbacks.get(shortKey);
                             if (cb)
-                                cb(content);
+                                cb(proactiveText);
                         }
                     }
                     // Tool calls in assistant messages — skip, using agent item events instead
@@ -232,6 +248,7 @@ export class OpenClawClient {
             let sessionKey = targetSessionKey ? `agent:main:${targetSessionKey}` : "";
             let chatFinalTimer = null;
             let lifecycleEndTimer = null;
+            let replayInvalidTimer = null;
             const collectStartedAt = Date.now();
             let lifecycleStartedLogged = false;
             const timer = setTimeout(() => {
@@ -240,6 +257,8 @@ export class OpenClawClient {
                     clearTimeout(chatFinalTimer);
                 if (lifecycleEndTimer)
                     clearTimeout(lifecycleEndTimer);
+                if (replayInvalidTimer)
+                    clearTimeout(replayInvalidTimer);
                 console.warn(`[OpenClaw] collectReply timeout for runId=${runId} sessionKey=${sessionKey}`);
                 this.abortChat(targetSessionKey || sessionKey, runId).catch((err) => {
                     console.warn(`[OpenClaw] abort after collectReply timeout failed:`, err.message);
@@ -253,6 +272,8 @@ export class OpenClawClient {
                     clearTimeout(chatFinalTimer);
                 if (lifecycleEndTimer)
                     clearTimeout(lifecycleEndTimer);
+                if (replayInvalidTimer)
+                    clearTimeout(replayInvalidTimer);
                 resolve(finalText);
             };
             const poller = setInterval(() => {
@@ -282,6 +303,12 @@ export class OpenClawClient {
                             continue;
                         }
                         bucket.splice(i, 1);
+                        // If more events arrive after a replay-invalid lifecycle end, that lifecycle
+                        // was not terminal for the user-visible run. Keep waiting for the real final.
+                        if (replayInvalidTimer) {
+                            clearTimeout(replayInvalidTimer);
+                            replayInvalidTimer = null;
+                        }
                         if (ev.stream === "lifecycle" && ev.data?.phase === "start" && !lifecycleStartedLogged) {
                             lifecycleStartedLogged = true;
                             console.log(`[OpenClaw] lifecycle start for runId=${runId} after ${Date.now() - collectStartedAt}ms`);
@@ -310,20 +337,33 @@ export class OpenClawClient {
                             const finalText = chatFinalText || text;
                             const finishFromLifecycle = () => {
                                 const latestFinalText = chatFinalText || text;
+                                if (!chatFinalText && latestFinalText.trim() === "N") {
+                                    // Some providers stream the first character of NO_REPLY ("N") but
+                                    // never deliver a final chat message in time. Never surface a lone
+                                    // "N" to the user; treat it as a suppressed reply.
+                                    finish("NO_REPLY");
+                                    return;
+                                }
                                 if (!latestFinalText && ev.data?.livenessState !== "working") {
                                     const state = ev.data?.livenessState || "unknown";
                                     const reason = ev.data?.stopReason || "";
                                     const replayInvalid = ev.data?.replayInvalid ? ", replayInvalid" : "";
-                                    finish(`⚠️ Agent 未正常完成\n状态: ${state}${replayInvalid}${reason ? "\n原因: " + reason : ""}\n请重试，或用 /reset 重置会话`);
+                                    const failureText = `⚠️ Agent 未正常完成\n状态: ${state}${replayInvalid}${reason ? "\n原因: " + reason : ""}\n请重试，或用 /reset 重置会话`;
+                                    if (ev.data?.replayInvalid) {
+                                        console.warn(`[OpenClaw] replayInvalid lifecycle observed for runId=${evRunId || runId}; waiting for subsequent events before surfacing failure`);
+                                        replayInvalidTimer = setTimeout(() => finish(failureText), 120000);
+                                        return;
+                                    }
+                                    finish(failureText);
                                 }
                                 else {
                                     finish(latestFinalText);
                                 }
                             };
                             // If lifecycle end beats chat final, a short delta like "N" can be a truncated
-                            // final reply. Wait briefly for chatFinal before resolving.
+                            // final reply. Wait for chatFinal before resolving; otherwise suppress lone "N".
                             if (!chatFinalText && text.length <= 1) {
-                                lifecycleEndTimer = setTimeout(finishFromLifecycle, 800);
+                                lifecycleEndTimer = setTimeout(finishFromLifecycle, 5000);
                             }
                             else {
                                 finishFromLifecycle();

package/package.json

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