openclaw-lark-multi-agent 0.1.8 → 0.1.10

package/dist/feishu-bot.d.ts

@@ -68,6 +68,7 @@ export declare class FeishuBot {
     private shouldRespond;
     private isMentioned;
     private isAllMention;
+    private isAllMentionItem;
     private mentionedBotName;
     private resolveBotName;
     private resolveHumanName;

package/dist/feishu-bot.js

@@ -2,6 +2,7 @@ import * as lark from "@larksuiteoapi/node-sdk";
 import { existsSync, readFileSync, statSync } from "fs";
 import { basename, extname, resolve } from "path";
 import { getBridgeAttachmentsDir } from "./paths.js";
+import { buildFeishuCardElements } from "./markdown.js";
 const MAX_BOT_STREAK = 10;
 const BRIDGE_ATTACHMENTS_DIR = getBridgeAttachmentsDir();
 /**
@@ -263,6 +264,12 @@ export class FeishuBot {
             if (messageType === "text") {
                 const rawText = content.text || "";
                 cleanText = this.cleanMentions(rawText);
+                // A mention-only text message is still a valid routing trigger. Feishu may
+                // expose mentions as display text like "@万万（Claude）" rather than @_user_xxx,
+                // so decide emptiness after stripping leading routing mentions.
+                if ((this.isMentioned(message.mentions || []) || this.isAllMention(rawText, message.mentions || [])) && !this.stripLeadingCommandMentions(cleanText).trim()) {
+                    cleanText = "请回复上面最近一条用户消息。";
+                }
             }
             else if (messageType === "image") {
                 // Download image and pass local path
@@ -494,7 +501,7 @@ export class FeishuBot {
             // Track this message for reaction status updates
             const pending = this.pendingAckMessages.get(chatId) || [];
             // Anti-loop
-            const streak = this.store.getBotStreak(chatId);
+            const streak = this.store.getBotStreak(chatId, this.config.name);
             if (streak >= MAX_BOT_STREAK) {
                 console.log(`[${this.config.name}] Anti-loop: ${streak} consecutive bot msgs`);
                 return;
@@ -693,9 +700,11 @@ export class FeishuBot {
         // 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) => this.mentionedBotName(m) !== null);
-        if (anyBotMentioned && !this.isMentioned(mentions))
+        // Targeted mentions are exclusive. If a human mentions another person or
+        // another bot, free-mode bots must not steal that message. Free mode only
+        // applies to plain human messages with no targeted mentions.
+        const hasTargetedMention = mentions.some((m) => !this.isAllMentionItem(m));
+        if (hasTargetedMention)
             return false;
         // No bot mentioned: check current per-bot mode
         if (chatId) {
@@ -711,10 +720,13 @@ export class FeishuBot {
     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 === "所有人");
+        return mentions.some((m) => this.isAllMentionItem(m));
+    }
+    isAllMentionItem(mention) {
+        return mention.key === "all" || mention.key === "@_all" || mention.id?.user_id === "all" || mention.id?.open_id === "all" || mention.name === "所有人";
     }
     mentionedBotName(mention) {
-        if (mention.key === "all" || mention.key === "@_all" || mention.id?.user_id === "all" || mention.id?.open_id === "all" || mention.name === "所有人")
+        if (this.isAllMentionItem(mention))
             return null;
         const candidates = [this, ...Array.from(FeishuBot.allBots.values()).filter((bot) => bot !== this)];
         for (const bot of candidates) {
@@ -763,12 +775,7 @@ export class FeishuBot {
             schema: "2.0",
             config: { wide_screen_mode: true },
             body: {
-                elements: [
-                    {
-                        tag: "markdown",
-                        content: text,
-                    },
-                ],
+                elements: buildFeishuCardElements(text),
             },
         };
     }

package/dist/markdown.d.ts

@@ -0,0 +1,31 @@
+declare function optimizeMarkdownStyle(text: string, cardVersion?: number): string;
+declare function convertMarkdownTables(markdown: string): string;
+type FeishuMarkdownElement = {
+    tag: "markdown";
+    content: string;
+};
+type FeishuTableElement = {
+    tag: "table";
+    page_size?: number;
+    row_height?: "low";
+    header_style?: Record<string, unknown>;
+    columns: Array<{
+        name: string;
+        display_name: string;
+        data_type: "lark_md";
+        width?: string;
+        vertical_align?: "top" | "center" | "bottom";
+        horizontal_align?: "left" | "center" | "right";
+    }>;
+    rows: Array<Record<string, string>>;
+};
+export type FeishuCardElement = FeishuMarkdownElement | FeishuTableElement;
+declare function buildTableElement(lines: string[], index: number): FeishuTableElement | null;
+export declare function buildFeishuCardElements(markdown: string): FeishuCardElement[];
+export declare function prepareMarkdownForFeishu(text: string): string;
+export declare const __test__: {
+    convertMarkdownTables: typeof convertMarkdownTables;
+    optimizeMarkdownStyle: typeof optimizeMarkdownStyle;
+    buildTableElement: typeof buildTableElement;
+};
+export {};

package/dist/markdown.js

@@ -0,0 +1,203 @@
+const MARKDOWN_STYLE_MARKERS = {
+    bold: { open: "**", close: "**" },
+    italic: { open: "_", close: "_" },
+    strikethrough: { open: "~~", close: "~~" },
+    code: { open: "`", close: "`" },
+    code_block: { open: "```\n", close: "```" },
+};
+const IMAGE_RE = /!\[([^\]]*)\]\(([^)\s]+)\)/g;
+function protectCodeBlocks(text) {
+    const blocks = [];
+    const protectedText = text.replace(/(^|\n)(`{3,})([^\n]*)\n[\s\S]*?\n\2(?=\n|$)/g, (match, prefix = "") => {
+        const block = match.slice(String(prefix).length);
+        const token = `___LMA_CB_${blocks.length}___`;
+        blocks.push({ token, text: block });
+        return `${prefix}${token}`;
+    });
+    return { text: protectedText, blocks };
+}
+function restoreCodeBlocks(text, blocks, cardVersion = 2) {
+    let restored = text;
+    for (const { token, text: block } of blocks) {
+        restored = restored.replace(token, cardVersion >= 2 ? `\n<br>\n${block}\n<br>\n` : block);
+    }
+    return restored;
+}
+function stripInvalidImageKeys(text) {
+    if (!text.includes("!["))
+        return text;
+    return text.replace(IMAGE_RE, (fullMatch, _alt, value) => {
+        if (String(value).startsWith("img_"))
+            return fullMatch;
+        return "";
+    });
+}
+function optimizeMarkdownStyle(text, cardVersion = 2) {
+    try {
+        const protectedResult = protectCodeBlocks(text);
+        let r = protectedResult.text;
+        const hasH1toH3 = /^#{1,3} /m.test(text);
+        if (hasH1toH3) {
+            r = r.replace(/^#{2,6} (.+)$/gm, "##### $1");
+            r = r.replace(/^# (.+)$/gm, "#### $1");
+        }
+        if (cardVersion >= 2) {
+            r = r.replace(/^(#{4,5} .+)\n{1,2}(#{4,5} )/gm, "$1\n<br>\n$2");
+            r = r.replace(/^([^|\n].*)\n(\|.+\|)/gm, "$1\n\n$2");
+            r = r.replace(/\n\n((?:\|.+\|[^\S\n]*\n?)+)/g, "\n\n<br>\n\n$1");
+            r = r.replace(/((?:^\|.+\|[^\S\n]*\n?)+)/gm, (match, _table, offset) => {
+                const after = r.slice(offset + match.length).replace(/^\n+/, "");
+                if (!after || /^(---|#{4,5} |\*\*)/.test(after))
+                    return match;
+                return `${match}\n<br>\n`;
+            });
+            r = r.replace(/^((?!#{4,5} )(?!\*\*).+)\n\n(<br>)\n\n(\|)/gm, "$1\n$2\n$3");
+            r = r.replace(/^(\*\*.+)\n\n(<br>)\n\n(\|)/gm, "$1\n$2\n\n$3");
+            r = r.replace(/(\|[^\n]*\n)\n(<br>\n)((?!#{4,5} )(?!\*\*))/gm, "$1$2$3");
+        }
+        r = restoreCodeBlocks(r, protectedResult.blocks, cardVersion);
+        r = r.replace(/\n{3,}/g, "\n\n");
+        return stripInvalidImageKeys(r);
+    }
+    catch {
+        return text;
+    }
+}
+function isMarkdownTableSeparator(line) {
+    const trimmed = line.trim();
+    if (!trimmed.includes("|"))
+        return false;
+    const cells = trimmed.replace(/^\|/, "").replace(/\|$/, "").split("|").map((cell) => cell.trim());
+    return cells.length >= 2 && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
+}
+function isMarkdownTableRow(line) {
+    const trimmed = line.trim();
+    return trimmed.includes("|") && trimmed.replace(/^\|/, "").replace(/\|$/, "").split("|").length >= 2;
+}
+function splitMarkdownTableRow(line) {
+    return line.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((cell) => cell.trim());
+}
+function formatTableAsCodeBlock(lines) {
+    const rows = lines.filter((line) => !isMarkdownTableSeparator(line)).map(splitMarkdownTableRow);
+    if (rows.length === 0)
+        return lines.join("\n");
+    const width = Math.max(...rows.map((row) => row.length));
+    const widths = Array.from({ length: width }, (_, i) => Math.max(...rows.map((row) => row[i]?.length ?? 0), 1));
+    const renderedRows = rows.map((row, rowIndex) => {
+        const rendered = widths.map((w, i) => (row[i] ?? "").padEnd(w)).join("  ").trimEnd();
+        if (rowIndex === 0 && rows.length > 1) {
+            const sep = widths.map((w) => "─".repeat(w)).join("  ");
+            return `${rendered}\n${sep}`;
+        }
+        return rendered;
+    });
+    return `\n\`\`\`\n${renderedRows.join("\n")}\n\`\`\`\n`;
+}
+function convertMarkdownTables(markdown) {
+    const { text, blocks } = protectCodeBlocks(markdown);
+    const lines = text.split("\n");
+    const out = [];
+    let i = 0;
+    while (i < lines.length) {
+        if (i + 1 < lines.length && isMarkdownTableRow(lines[i]) && isMarkdownTableSeparator(lines[i + 1])) {
+            const tableLines = [lines[i], lines[i + 1]];
+            i += 2;
+            while (i < lines.length && isMarkdownTableRow(lines[i])) {
+                tableLines.push(lines[i]);
+                i++;
+            }
+            out.push(formatTableAsCodeBlock(tableLines));
+            continue;
+        }
+        out.push(lines[i]);
+        i++;
+    }
+    return restoreCodeBlocks(out.join("\n"), blocks, 1);
+}
+function buildTableElement(lines, index) {
+    const rows = lines.filter((line) => !isMarkdownTableSeparator(line)).map(splitMarkdownTableRow);
+    if (rows.length < 2)
+        return null;
+    const headers = rows[0];
+    if (headers.length === 0)
+        return null;
+    const width = Math.min(Math.max(...rows.map((row) => row.length)), 50);
+    const columns = Array.from({ length: width }, (_, i) => ({
+        name: `c${index}_${i}`,
+        display_name: headers[i] || `列 ${i + 1}`,
+        data_type: "lark_md",
+        width: "auto",
+        vertical_align: "top",
+        horizontal_align: "left",
+    }));
+    const dataRows = rows.slice(1).map((row) => {
+        const item = {};
+        for (let i = 0; i < columns.length; i++)
+            item[columns[i].name] = row[i] || "";
+        return item;
+    });
+    return {
+        tag: "table",
+        page_size: Math.min(Math.max(dataRows.length, 1), 10),
+        header_style: {
+            text_align: "left",
+            text_size: "normal",
+            background_style: "grey",
+            text_color: "default",
+            bold: true,
+            lines: 2,
+        },
+        columns,
+        rows: dataRows,
+    };
+}
+function pushMarkdownElement(elements, text) {
+    const content = optimizeMarkdownStyle(text.trim(), 2).trim();
+    if (!content)
+        return;
+    elements.push({ tag: "markdown", content });
+}
+export function buildFeishuCardElements(markdown) {
+    const { text, blocks } = protectCodeBlocks(markdown);
+    const lines = text.split("\n");
+    const elements = [];
+    const buffer = [];
+    let tableCount = 0;
+    let i = 0;
+    while (i < lines.length) {
+        if (i + 1 < lines.length && isMarkdownTableRow(lines[i]) && isMarkdownTableSeparator(lines[i + 1])) {
+            const tableLines = [lines[i], lines[i + 1]];
+            i += 2;
+            while (i < lines.length && isMarkdownTableRow(lines[i])) {
+                tableLines.push(lines[i]);
+                i++;
+            }
+            pushMarkdownElement(elements, restoreCodeBlocks(buffer.join("\n"), blocks, 1));
+            buffer.length = 0;
+            // Feishu cards support up to 5 table components per card. Fall back to a
+            // readable code-block table after that instead of sending an invalid card.
+            if (tableCount < 5) {
+                const table = buildTableElement(tableLines, tableCount);
+                if (table) {
+                    elements.push(table);
+                    tableCount++;
+                }
+                else {
+                    buffer.push(formatTableAsCodeBlock(tableLines));
+                }
+            }
+            else {
+                buffer.push(formatTableAsCodeBlock(tableLines));
+            }
+            continue;
+        }
+        buffer.push(lines[i]);
+        i++;
+    }
+    pushMarkdownElement(elements, restoreCodeBlocks(buffer.join("\n"), blocks, 1));
+    return elements.length > 0 ? elements : [{ tag: "markdown", content: "" }];
+}
+export function prepareMarkdownForFeishu(text) {
+    return optimizeMarkdownStyle(convertMarkdownTables(text), 2);
+}
+export const __test__ = { convertMarkdownTables, optimizeMarkdownStyle, buildTableElement };

package/dist/message-store.d.ts

@@ -51,9 +51,13 @@ export declare class MessageStore {
      */
     getRecent(chatId: string, maxCount?: number): ChatMessage[];
     /**
-     * Count consecutive bot messages at the tail of a chat.
+     * Count consecutive messages from one bot at the tail of a chat.
+     *
+     * Other bots do not consume this bot's anti-loop budget. Human messages reset
+     * the streak. This lets multiple bots free-discuss without a global bot-streak
+     * guard shutting everyone down after N total bot messages.
      */
-    getBotStreak(chatId: string): number;
+    getBotStreak(chatId: string, botName: string): number;
     upsertChatInfo(info: ChatInfo): void;
     setFreeDiscussion(chatId: string, on: boolean): void;
     setVerbose(chatId: string, verbose: boolean): void;

package/dist/message-store.js

@@ -233,21 +233,25 @@ export class MessageStore {
         }));
     }
     /**
-     * Count consecutive bot messages at the tail of a chat.
+     * Count consecutive messages from one bot at the tail of a chat.
+     *
+     * Other bots do not consume this bot's anti-loop budget. Human messages reset
+     * the streak. This lets multiple bots free-discuss without a global bot-streak
+     * guard shutting everyone down after N total bot messages.
      */
-    getBotStreak(chatId) {
+    getBotStreak(chatId, botName) {
         const rows = this.db.prepare(`
-      SELECT sender_type FROM messages
+      SELECT sender_type, sender_name FROM messages
       WHERE chat_id = ?
       ORDER BY timestamp DESC
-      LIMIT 20
+      LIMIT 50
     `).all(chatId);
         let count = 0;
         for (const r of rows) {
-            if (r.sender_type === "bot")
-                count++;
-            else
+            if (r.sender_type === "human")
                 break;
+            if (r.sender_type === "bot" && r.sender_name === botName)
+                count++;
         }
         return count;
     }

package/package.json

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