openclaw-lark-multi-agent 0.1.4 → 0.1.6

package/dist/feishu-bot.d.ts

@@ -74,6 +74,12 @@ export declare class FeishuBot {
     private cleanMentions;
     private stripLeadingCommandMentions;
     private replyMessage;
+    private extractBridgeAttachments;
+    private validateBridgeAttachmentPath;
+    private inferFeishuFileType;
+    private isImagePath;
+    private createFeishuDocFromMarkdown;
+    private sendBridgeAttachment;
     /**
      * Send a proactive message to a chat (not a reply).
      */

package/dist/feishu-bot.js

@@ -1,5 +1,9 @@
 import * as lark from "@larksuiteoapi/node-sdk";
+import { existsSync, readFileSync, statSync } from "fs";
+import { basename, extname, resolve } from "path";
+import { getBridgeAttachmentsDir } from "./paths.js";
 const MAX_BOT_STREAK = 10;
+const BRIDGE_ATTACHMENTS_DIR = getBridgeAttachmentsDir();
 /**
  * Manages a single Feishu bot instance.
  *
@@ -107,7 +111,12 @@ export class FeishuBot {
         await this.openclawClient.subscribeSession(sessionKey, async (text) => {
             try {
                 console.log(`[${this.config.name}] Proactive message for ${chatId.slice(-8)}`);
-                await this.sendMessage(chatId, text);
+                const parsed = this.extractBridgeAttachments(text);
+                if (parsed.text.trim())
+                    await this.sendMessage(chatId, parsed.text);
+                for (const attachment of parsed.attachments) {
+                    await this.sendBridgeAttachment(chatId, attachment);
+                }
             }
             catch (err) {
                 console.error(`[${this.config.name}] Failed to deliver proactive msg:`, err.message);
@@ -550,16 +559,22 @@ export class FeishuBot {
                 const maxId = Math.max(...allUnsynced.map((m) => m.id || 0));
                 this.store.markSynced(this.config.name, chatId, maxId);
                 this.store.clearPendingTriggers(this.config.name, chatId, maxId);
-                const trimmedReply = reply.trim();
+                const parsedReply = this.extractBridgeAttachments(reply);
+                const visibleReply = parsedReply.text;
+                const trimmedReply = visibleReply.trim();
                 const shouldReply = trimmedReply.length > 0 && trimmedReply.toUpperCase() !== "NO_REPLY";
+                const hasAttachments = parsedReply.attachments.length > 0;
                 // Record bot reply only if it is user-visible/context-worthy.
-                if (shouldReply) {
+                if (shouldReply || hasAttachments) {
+                    const storedContent = [visibleReply, ...parsedReply.attachments.map((a) => `[Attachment: ${a.type || "file"} ${a.path}]`)]
+                        .filter(Boolean)
+                        .join("\n");
                     const replyId = this.store.insert({
                         chatId,
                         messageId: `self-${this.config.name}-${Date.now()}`,
                         senderType: "bot",
                         senderName: this.config.name,
-                        content: reply,
+                        content: storedContent,
                         timestamp: Date.now(),
                     });
                     if (replyId > 0)
@@ -573,28 +588,33 @@ export class FeishuBot {
                 }
                 // Reply to the last human message on Feishu (ordered after tool msgs)
                 // Skip empty replies and explicit NO_REPLY responses
-                if (shouldReply && lastHuman.messageId) {
+                if ((shouldReply || hasAttachments) && lastHuman.messageId) {
                     if (triggerId && this.store.hasDeliveredReply(this.config.name, chatId, triggerId)) {
                         console.warn(`[${this.config.name}] Reply already delivered, skip duplicate for ${chatId.slice(-8)} msgId=${triggerId}`);
                     }
                     else {
                         await this.sendOrdered(chatId, async () => {
-                            try {
-                                await this.replyMessage(lastHuman.messageId, reply);
+                            if (shouldReply) {
+                                try {
+                                    await this.replyMessage(lastHuman.messageId, visibleReply);
+                                }
+                                catch (err) {
+                                    // Reply can fail for historical messages sent before this bot joined the chat
+                                    // (Feishu 230002: Bot/User can NOT be out of the chat). Fall back to a normal
+                                    // chat message so queue processing still completes.
+                                    console.warn(`[${this.config.name}] replyMessage failed, fallback to sendMessage:`, err.message);
+                                    await this.sendMessage(chatId, visibleReply);
+                                }
                             }
-                            catch (err) {
-                                // Reply can fail for historical messages sent before this bot joined the chat
-                                // (Feishu 230002: Bot/User can NOT be out of the chat). Fall back to a normal
-                                // chat message so queue processing still completes.
-                                console.warn(`[${this.config.name}] replyMessage failed, fallback to sendMessage:`, err.message);
-                                await this.sendMessage(chatId, reply);
+                            for (const attachment of parsedReply.attachments) {
+                                await this.sendBridgeAttachment(chatId, attachment);
                             }
                             if (triggerId)
                                 this.store.markDeliveredReply(this.config.name, chatId, triggerId, lastHuman.messageId);
                         });
                     }
                 }
-                console.log(`[${this.config.name}] [${new Date().toISOString()}] ${shouldReply ? 'Replied' : 'Skipped (empty/NO_REPLY)'} (${reply.length} chars)`);
+                console.log(`[${this.config.name}] [${new Date().toISOString()}] ${shouldReply || hasAttachments ? 'Replied' : 'Skipped (empty/NO_REPLY)'} (${reply.length} chars, attachments=${parsedReply.attachments.length})`);
                 // Replace ack reactions with DONE for all pending messages in this chat
                 const pendingAcks = this.pendingAckMessages.get(chatId) || [];
                 for (const ack of pendingAcks) {
@@ -734,6 +754,137 @@ export class FeishuBot {
             });
         }
     }
+    extractBridgeAttachments(reply) {
+        const attachments = [];
+        const markerPattern = /<LMA_BRIDGE_ATTACHMENTS>([\s\S]*?)<\/LMA_BRIDGE_ATTACHMENTS>/g;
+        let text = reply.replace(markerPattern, (_match, jsonText) => {
+            try {
+                const parsed = JSON.parse(String(jsonText).trim());
+                const rawAttachments = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.attachments) ? parsed.attachments : [parsed];
+                for (const item of rawAttachments) {
+                    if (!item || typeof item.path !== "string")
+                        continue;
+                    attachments.push({
+                        type: item.type === "image" || item.type === "document" || item.type === "file" ? item.type : undefined,
+                        path: item.path,
+                        caption: typeof item.caption === "string" ? item.caption : undefined,
+                    });
+                }
+            }
+            catch (err) {
+                console.warn(`[${this.config.name}] Failed to parse bridge attachment marker:`, err.message);
+            }
+            return "";
+        }).trim();
+        return { text, attachments };
+    }
+    validateBridgeAttachmentPath(filePath) {
+        const resolvedPath = resolve(filePath);
+        const allowedRoot = resolve(BRIDGE_ATTACHMENTS_DIR);
+        if (!(resolvedPath === allowedRoot || resolvedPath.startsWith(allowedRoot + "/"))) {
+            throw new Error(`Attachment path outside allowed directory: ${resolvedPath}`);
+        }
+        if (!existsSync(resolvedPath))
+            throw new Error(`Attachment file not found: ${resolvedPath}`);
+        const stats = statSync(resolvedPath);
+        if (!stats.isFile())
+            throw new Error(`Attachment path is not a file: ${resolvedPath}`);
+        if (stats.size <= 0)
+            throw new Error(`Attachment file is empty: ${resolvedPath}`);
+        if (stats.size > 30 * 1024 * 1024)
+            throw new Error(`Attachment file too large (>30MB): ${resolvedPath}`);
+        return resolvedPath;
+    }
+    inferFeishuFileType(filePath) {
+        const ext = extname(filePath).toLowerCase();
+        if (ext === ".pdf")
+            return "pdf";
+        if ([".doc", ".docx"].includes(ext))
+            return "doc";
+        if ([".xls", ".xlsx", ".csv"].includes(ext))
+            return "xls";
+        if ([".ppt", ".pptx"].includes(ext))
+            return "ppt";
+        return "stream";
+    }
+    isImagePath(filePath) {
+        return [".jpg", ".jpeg", ".png", ".webp", ".gif", ".tiff", ".bmp", ".ico"].includes(extname(filePath).toLowerCase());
+    }
+    async createFeishuDocFromMarkdown(filePath) {
+        const rawTitle = basename(filePath).replace(/\.[^.]+$/, "").trim() || "Markdown Document";
+        const markdown = readFileSync(filePath, "utf8");
+        const docx = this.client.docx;
+        const created = await docx.document.create({ data: { title: rawTitle } });
+        const documentId = created?.data?.document?.document_id || created?.document?.document_id;
+        const revisionId = created?.data?.document?.revision_id || created?.document?.revision_id;
+        if (!documentId)
+            throw new Error(`Feishu doc create returned no document_id for ${filePath}`);
+        const converted = await docx.document.convert({ data: { content_type: "markdown", content: markdown } });
+        const convertedData = converted?.data || converted;
+        const blocks = convertedData?.blocks || [];
+        const firstLevelBlockIds = convertedData?.first_level_block_ids || [];
+        if (Array.isArray(blocks) && blocks.length > 0) {
+            await docx.documentBlockDescendant.create({
+                path: { document_id: documentId, block_id: documentId },
+                data: {
+                    children_id: firstLevelBlockIds,
+                    descendants: blocks,
+                    document_revision_id: revisionId,
+                },
+            });
+        }
+        return { title: rawTitle, url: `https://www.feishu.cn/docx/${documentId}` };
+    }
+    async sendBridgeAttachment(chatId, attachment) {
+        const filePath = this.validateBridgeAttachmentPath(attachment.path);
+        const type = attachment.type || (this.isImagePath(filePath) ? "image" : "file");
+        if (type === "document" && extname(filePath).toLowerCase() === ".md") {
+            const doc = await this.createFeishuDocFromMarkdown(filePath);
+            const caption = attachment.caption?.trim() || `飞书文档：${doc.title}`;
+            await this.sendMessage(chatId, `${caption}
+${doc.url}`);
+            return;
+        }
+        if (attachment.caption?.trim())
+            await this.sendMessage(chatId, attachment.caption.trim());
+        if (type === "image") {
+            if (statSync(filePath).size > 10 * 1024 * 1024)
+                throw new Error(`Image too large (>10MB): ${filePath}`);
+            const uploaded = await this.client.im.image.create({
+                data: { image_type: "message", image: readFileSync(filePath) },
+            });
+            const imageKey = uploaded?.image_key || uploaded?.data?.image_key;
+            if (!imageKey)
+                throw new Error(`Feishu image upload returned no image_key for ${filePath}`);
+            await this.client.im.message.create({
+                params: { receive_id_type: "chat_id" },
+                data: {
+                    receive_id: chatId,
+                    content: JSON.stringify({ image_key: imageKey }),
+                    msg_type: "image",
+                },
+            });
+            return;
+        }
+        const uploaded = await this.client.im.file.create({
+            data: {
+                file_type: this.inferFeishuFileType(filePath),
+                file_name: basename(filePath),
+                file: readFileSync(filePath),
+            },
+        });
+        const fileKey = uploaded?.file_key || uploaded?.data?.file_key;
+        if (!fileKey)
+            throw new Error(`Feishu file upload returned no file_key for ${filePath}`);
+        await this.client.im.message.create({
+            params: { receive_id_type: "chat_id" },
+            data: {
+                receive_id: chatId,
+                content: JSON.stringify({ file_key: fileKey }),
+                msg_type: "file",
+            },
+        });
+    }
     /**
      * Send a proactive message to a chat (not a reply).
      */

package/dist/openclaw-client.d.ts

@@ -25,8 +25,9 @@ export declare class OpenClawClient {
     private sessionMessageCallbacks;
     /** Session keys that should be re-subscribed on reconnect */
     private subscribedKeys;
-    /** Session keys with active chatSend — suppress proactive message delivery */
+    /** Session keys with active/recent chatSend — suppress proactive message delivery */
     private suppressedSessions;
+    private suppressedSessionTimers;
     constructor(config: OpenClawConfig);
     connect(): Promise<void>;
     private _doConnect;
@@ -68,6 +69,8 @@ export declare class OpenClawClient {
      * deliver=false prevents OpenClaw from auto-posting to channels.
      */
     abortChat(sessionKey: string, runId: string): Promise<any>;
+    private suppressSessionKeys;
+    private releaseSuppressedSessionKeysAfter;
     chatSend(params: {
         sessionKey: string;
         message: string;
@@ -75,6 +78,8 @@ export declare class OpenClawClient {
         deliver?: boolean;
         timeoutMs?: number;
     }): Promise<string>;
+    private shouldInjectBridgeAttachmentHint;
+    private bridgeAttachmentHint;
     /**
      * Build and send a context catch-up message followed by the actual message.
      *

package/dist/openclaw-client.js

@@ -2,6 +2,8 @@ import WebSocket from "ws";
 import { randomUUID } from "crypto";
 import { readFileSync } from "fs";
 import { basename, extname } from "path";
+import { getBridgeAttachmentsDir } from "./paths.js";
+const BRIDGE_ATTACHMENTS_DIR = getBridgeAttachmentsDir();
 /**
  * OpenClaw Gateway WebSocket client.
  * Full agent pipeline — tools, memory, skills, context management by OpenClaw.
@@ -21,8 +23,9 @@ export class OpenClawClient {
     sessionMessageCallbacks = new Map();
     /** Session keys that should be re-subscribed on reconnect */
     subscribedKeys = new Set();
-    /** Session keys with active chatSend — suppress proactive message delivery */
+    /** Session keys with active/recent chatSend — suppress proactive message delivery */
     suppressedSessions = new Set();
+    suppressedSessionTimers = new Map();
     constructor(config) {
         this.config = config;
     }
@@ -149,11 +152,23 @@ export class OpenClawClient {
                             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();
+                            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) {
@@ -438,11 +453,32 @@ export class OpenClawClient {
         const key = sessionKey.startsWith("agent:main:") ? sessionKey.slice("agent:main:".length) : sessionKey;
         return this.rpc("chat.abort", { sessionKey: key, runId }, 5000).catch(() => { });
     }
+    suppressSessionKeys(keys) {
+        for (const key of keys) {
+            const timer = this.suppressedSessionTimers.get(key);
+            if (timer)
+                clearTimeout(timer);
+            this.suppressedSessionTimers.delete(key);
+            this.suppressedSessions.add(key);
+        }
+    }
+    releaseSuppressedSessionKeysAfter(keys, delayMs) {
+        for (const key of keys) {
+            const oldTimer = this.suppressedSessionTimers.get(key);
+            if (oldTimer)
+                clearTimeout(oldTimer);
+            const timer = setTimeout(() => {
+                this.suppressedSessions.delete(key);
+                this.suppressedSessionTimers.delete(key);
+            }, delayMs);
+            this.suppressedSessionTimers.set(key, timer);
+        }
+    }
     async chatSend(params) {
         const sk = params.sessionKey;
         const fullSessionKey = `agent:main:${sk}`;
-        this.suppressedSessions.add(sk);
-        this.suppressedSessions.add(fullSessionKey);
+        const suppressedKeys = [sk, fullSessionKey];
+        this.suppressSessionKeys(suppressedKeys);
         try {
             // Drop stale buffered events for this session before starting a new run.
             // This prevents an old final text (e.g. previous "ok") from being consumed by
@@ -461,10 +497,23 @@ export class OpenClawClient {
             return await this.collectReply(result.runId, params.timeoutMs || 1800000, sk);
         }
         finally {
-            this.suppressedSessions.delete(sk);
-            this.suppressedSessions.delete(fullSessionKey);
+            // OpenClaw can emit the final assistant session.message a moment after
+            // collectReply returns. Keep a short grace window so normal chat replies
+            // are not delivered twice via the proactive-message path. Cron/LMA runs
+            // are unaffected because they do not go through chatSend.
+            this.releaseSuppressedSessionKeysAfter(suppressedKeys, 30000);
         }
     }
+    shouldInjectBridgeAttachmentHint(text) {
+        return /发送|发到|发给|传|上传|附件|文件|文档|图片|图像|照片|生成图|做张图|画张图|导出|保存|pdf|docx?|xlsx?|pptx?|markdown|\bmd\b/i.test(text);
+    }
+    bridgeAttachmentHint(text) {
+        if (!this.shouldInjectBridgeAttachmentHint(text))
+            return "";
+        return `
+
+[Bridge attachment capability hint: This is an OpenClaw Lark Multi-Agent bridge session. You cannot send Feishu files/images directly from inside OpenClaw. Do NOT call message, sessions_send, Feishu tools, or proactive send tools for this request. If the user asks you to send an image/file/document to Feishu, only create the local file under ${BRIDGE_ATTACHMENTS_DIR}/ and include this exact marker at the very end of your final reply (do not explain or expose the marker as normal text): <LMA_BRIDGE_ATTACHMENTS>{"attachments":[{"type":"image|file|document","path":"/absolute/path","caption":"optional"}]}</LMA_BRIDGE_ATTACHMENTS>. The bridge layer will parse this marker and send the attachment. Use type=image for images; use type=document for Markdown documents (.md) so the bridge creates a Feishu cloud document and sends its link; use type=file for other ordinary files.]`;
+    }
     /**
      * Build and send a context catch-up message followed by the actual message.
      *
@@ -486,11 +535,12 @@ export class OpenClawClient {
         const mediaInstruction = attachments.length > 0
             ? "\n\n[Media note: Image attachments are included with this message. If your model can inspect images directly, use the attached image input. If it cannot, use the image tool on the provided media/attachment path; do not try unrelated network or model-provider workarounds.]"
             : "";
+        const bridgeAttachmentHint = this.bridgeAttachmentHint(params.currentMessage);
         if (params.unsyncedMessages.length === 0) {
             // No context to catch up, send directly
             return this.chatSend({
                 sessionKey: params.sessionKey,
-                message: params.currentMessage + mediaInstruction,
+                message: params.currentMessage + mediaInstruction + bridgeAttachmentHint,
                 attachments,
                 deliver: params.deliver,
                 timeoutMs: params.timeoutMs,
@@ -512,7 +562,7 @@ export class OpenClawClient {
             `[${params.currentSenderName}]: ${params.currentMessage}`;
         return this.chatSend({
             sessionKey: params.sessionKey,
-            message: combined + mediaInstruction,
+            message: combined + mediaInstruction + bridgeAttachmentHint,
             attachments,
             deliver: params.deliver,
             timeoutMs: params.timeoutMs,
@@ -547,6 +597,10 @@ export class OpenClawClient {
     }
     async disconnect() {
         this.shouldReconnect = false;
+        for (const timer of this.suppressedSessionTimers.values())
+            clearTimeout(timer);
+        this.suppressedSessionTimers.clear();
+        this.suppressedSessions.clear();
         if (this.ws) {
             this.ws.close();
             this.ws = null;

package/dist/paths.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Runtime state defaults to the user's home directory but can be overridden
+ * for packaged deployments, tests, containers, or systemd installations.
+ */
+export declare function getStateDir(): string;
+export declare function getBridgeAttachmentsDir(): string;

package/dist/paths.js

@@ -0,0 +1,12 @@
+import { homedir } from "os";
+import { resolve } from "path";
+/**
+ * Runtime state defaults to the user's home directory but can be overridden
+ * for packaged deployments, tests, containers, or systemd installations.
+ */
+export function getStateDir() {
+    return resolve(process.env.OPENCLAW_LARK_MULTI_AGENT_STATE_DIR || resolve(homedir(), ".openclaw/openclaw-lark-multi-agent"));
+}
+export function getBridgeAttachmentsDir() {
+    return resolve(process.env.OPENCLAW_LARK_MULTI_AGENT_ATTACHMENTS_DIR || resolve(getStateDir(), "attachments"));
+}

package/package.json

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