openclaw-lark-multi-agent 1.0.18 → 1.0.20

package/dist/feishu-bot.d.ts

@@ -176,6 +176,14 @@ export declare class FeishuBot {
      * Send a model-drift notification to the affected chat.
      */
     private hydrateInlineImageKeys;
+    private hydrateFeishuDocsInMessage;
+    private extractFeishuDocRefs;
+    private extractFeishuDocRefsFromText;
+    private hydrateFeishuDoc;
+    private resolveWikiDocRef;
+    private cleanupFeishuMarkdown;
+    private fetchFeishuDocMarkdown;
+    private safeFileName;
     /**
      * Download a resource (image/file/audio) from a Feishu message.
      * Returns the local file path.

package/dist/feishu-bot.js

@@ -2,9 +2,9 @@ import * as lark from "@larksuiteoapi/node-sdk";
 import { createRequire } from "module";
 import { persistBotModel } from "./config.js";
 import { getI18n, normalizeLocale } from "./i18n.js";
-import { existsSync, readFileSync, statSync } from "fs";
-import { basename, extname, resolve } from "path";
-import { getBridgeAttachmentsDir } from "./paths.js";
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { basename, extname, join, resolve } from "path";
+import { getBridgeAttachmentsDir, getDataDir } from "./paths.js";
 import { buildFeishuCardElements } from "./markdown.js";
 import { discussionManager } from "./discussion-manager.js";
 const require = createRequire(import.meta.url);
@@ -13,6 +13,7 @@ const MAX_BOT_STREAK = 10;
 const MAX_MERGED_TRIGGER_MESSAGES = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_MAX_MERGED_TRIGGER_MESSAGES || 100);
 const MAX_MERGED_TRIGGER_BYTES = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_MAX_MERGED_TRIGGER_BYTES || 128 * 1024);
 const BRIDGE_ATTACHMENTS_DIR = getBridgeAttachmentsDir();
+const FEISHU_DOCS_DIR = join(getDataDir(), "feishu-docs");
 /**
  * Manages a single Feishu bot instance.
  *
@@ -322,7 +323,7 @@ export class FeishuBot {
                     }
                 }
             }
-            if (messageType !== "text" && messageType !== "image" && messageType !== "file" && messageType !== "audio" && messageType !== "sticker" && messageType !== "post")
+            if (messageType !== "text" && messageType !== "image" && messageType !== "file" && messageType !== "audio" && messageType !== "sticker" && messageType !== "post" && messageType !== "share_doc")
                 return;
             // --- Dedup: atomically claim this message for this bot before any await.
             // Feishu/WebSocket can deliver the same event more than once; a separate
@@ -401,9 +402,13 @@ export class FeishuBot {
                 // Rich text post - extract all text content
                 cleanText = await this.hydrateInlineImageKeys(this.extractPostText(content), messageId);
             }
+            else if (messageType === "share_doc") {
+                cleanText = content.title || content.name || content.text || content.url || "[Feishu document]";
+            }
             else if (messageType === "sticker") {
                 cleanText = `[Sticker: ${content.file_key || "unknown"}]`;
             }
+            cleanText = await this.hydrateFeishuDocsInMessage(cleanText, content, messageId);
             if (!cleanText.trim())
                 return;
             const routing = this.getRoutingIntent(chatType, message, messageType === "text" ? (content.text || "") : "");
@@ -2181,6 +2186,157 @@ export class FeishuBot {
             out = out.replace(r.from, r.to);
         return out;
     }
+    async hydrateFeishuDocsInMessage(text, content, messageId) {
+        const refs = this.extractFeishuDocRefs(text, content);
+        if (refs.length === 0)
+            return text;
+        const hydrated = [];
+        for (const ref of refs.slice(0, 5)) {
+            try {
+                const doc = await this.hydrateFeishuDoc(ref, messageId);
+                hydrated.push(`[FeishuDoc: ${doc.title || doc.token} -> ${doc.markdownPath}]`);
+            }
+            catch (err) {
+                hydrated.push(`[FeishuDoc: ${ref.title || ref.token} - hydration failed: ${this.errorSummary(err)}]`);
+            }
+        }
+        return `${text.trim()}\n\n[飞书文档已由 LMA 用机器人权限读取并转换为 Markdown 附件，OpenClaw 可直接读取附件内容。]\n${hydrated.join("\n")}`.trim();
+    }
+    extractFeishuDocRefs(text, content) {
+        const refs = [];
+        const add = (ref) => {
+            if (!ref.token || refs.some((r) => r.type === ref.type && r.token === ref.token))
+                return;
+            refs.push(ref);
+        };
+        const scanValue = (value, title) => {
+            if (!value)
+                return;
+            if (typeof value === "string") {
+                for (const ref of this.extractFeishuDocRefsFromText(value, title))
+                    add(ref);
+                return;
+            }
+            if (Array.isArray(value)) {
+                for (const item of value)
+                    scanValue(item, title);
+                return;
+            }
+            if (typeof value !== "object")
+                return;
+            const nextTitle = value.title || value.name || value.file_name || title;
+            const explicitType = String(value.obj_type || value.doc_type || value.type || "").toLowerCase();
+            const docxToken = value.docx_token || value.document_id || (explicitType === "docx" ? value.token : undefined);
+            const docToken = value.doc_token || (explicitType === "doc" ? value.token : undefined);
+            const wikiToken = value.wiki_token || value.node_token || (explicitType === "wiki" ? value.token : undefined);
+            if (docxToken)
+                add({ type: "docx", token: String(docxToken), title: nextTitle, url: value.url || value.href });
+            if (docToken)
+                add({ type: "doc", token: String(docToken), title: nextTitle, url: value.url || value.href });
+            if (wikiToken)
+                add({ type: "wiki", token: String(wikiToken), title: nextTitle, url: value.url || value.href });
+            for (const v of Object.values(value))
+                scanValue(v, nextTitle);
+        };
+        scanValue(content);
+        for (const ref of this.extractFeishuDocRefsFromText(text))
+            add(ref);
+        return refs;
+    }
+    extractFeishuDocRefsFromText(text, title) {
+        const refs = [];
+        const pattern = /https?:\/\/[^\s)\]>"']+\/(docx|docs|wiki)\/([A-Za-z0-9_-]+)/g;
+        for (const match of text.matchAll(pattern)) {
+            const kind = match[1] === "docs" ? "doc" : match[1];
+            refs.push({ type: kind, token: match[2], title, url: match[0] });
+        }
+        return refs;
+    }
+    async hydrateFeishuDoc(ref, messageId) {
+        let resolved = ref;
+        if (ref.type === "wiki")
+            resolved = await this.resolveWikiDocRef(ref);
+        const markdown = this.cleanupFeishuMarkdown(await this.fetchFeishuDocMarkdown(resolved));
+        const title = resolved.title || ref.title || `${resolved.type}-${resolved.token}`;
+        mkdirSync(FEISHU_DOCS_DIR, { recursive: true });
+        const fileName = `${messageId}-${this.safeFileName(title)}-${resolved.token.slice(0, 8)}.md`;
+        const markdownPath = join(FEISHU_DOCS_DIR, fileName);
+        const body = [
+            `# ${title}`,
+            ``,
+            `- Source type: ${ref.type}${resolved.type !== ref.type ? ` -> ${resolved.type}` : ""}`,
+            `- Token: ${ref.token}`,
+            resolved.url || ref.url ? `- URL: ${resolved.url || ref.url}` : "",
+            `- Hydrated at: ${new Date().toISOString()}`,
+            ``,
+            markdown.trim(),
+            ``,
+        ].filter(Boolean).join("\n");
+        writeFileSync(markdownPath, body, "utf8");
+        return { ...resolved, title, markdownPath };
+    }
+    async resolveWikiDocRef(ref) {
+        const resp = await this.client.wiki.v2.space.getNode({ params: { token: ref.token } });
+        const node = resp?.data?.node;
+        if (!node?.obj_token || !node?.obj_type)
+            throw new Error(`Wiki node not readable: ${resp?.msg || "missing obj_token"}`);
+        const objType = String(node.obj_type).toLowerCase();
+        if (objType !== "docx" && objType !== "doc")
+            throw new Error(`Unsupported wiki object type: ${objType}`);
+        return { type: objType, token: node.obj_token, title: node.title || ref.title, url: ref.url };
+    }
+    cleanupFeishuMarkdown(markdown) {
+        return markdown
+            .replace(/\\&\\#/g, "&#")
+            .replace(/\\&#/g, "&#")
+            .replace(/\\&#/g, "&#")
+            .replace(/&#/g, "&#")
+            .replace(/&#(\d+);/g, (_, code) => {
+            const n = Number(code);
+            return Number.isFinite(n) ? String.fromCodePoint(n) : _;
+        })
+            .replace(/&#x([0-9a-fA-F]+);/g, (_, code) => {
+            const n = Number.parseInt(code, 16);
+            return Number.isFinite(n) ? String.fromCodePoint(n) : _;
+        })
+            .replace(/"/g, '"')
+            .replace(/'/g, "'")
+            .replace(/&lt;/g, "<")
+            .replace(/&gt;/g, ">")
+            .replace(/&amp;/g, "&")
+            .replace(/\\([+\-=(){}[\].!,，。；：！？、])/g, "$1")
+            .replace(/\\\*/g, "*")
+            .replace(/\\_/g, "_")
+            .replace(/\n{3,}/g, "\n\n")
+            .trim();
+    }
+    async fetchFeishuDocMarkdown(ref) {
+        let contentErr;
+        const docs = this.client.docs;
+        if ((ref.type === "docx" || ref.type === "doc") && docs?.v1?.content?.get) {
+            try {
+                const resp = await docs.v1.content.get({ params: { doc_token: ref.token, doc_type: ref.type, content_type: "markdown", lang: "zh" } });
+                const content = resp?.data?.content;
+                if (content)
+                    return content;
+                contentErr = new Error(`docs content empty: ${resp?.msg || "unknown"}`);
+            }
+            catch (err) {
+                contentErr = err;
+            }
+        }
+        if (ref.type === "docx") {
+            const resp = await this.client.docx.document.rawContent({ path: { document_id: ref.token } });
+            const content = resp?.data?.content;
+            if (content)
+                return content;
+            throw new Error(`docx raw content empty: ${resp?.msg || this.errorSummary(contentErr)}`);
+        }
+        throw new Error(`Legacy doc markdown hydration failed: ${this.errorSummary(contentErr)}`);
+    }
+    safeFileName(name) {
+        return name.replace(/[\\/:*?\"<>|\s]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "feishu-doc";
+    }
     /**
      * Download a resource (image/file/audio) from a Feishu message.
      * Returns the local file path.

package/dist/openclaw-client.js

@@ -1,12 +1,14 @@
 import WebSocket from "ws";
 import { randomUUID } from "crypto";
-import { mkdirSync, readFileSync, writeFileSync } from "fs";
-import { basename, extname, join } from "path";
+import { mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { basename, extname, join, resolve, sep } from "path";
 import { getBridgeAttachmentsDir, getDataDir } from "./paths.js";
 export const GATEWAY_PROTOCOL_MIN = 3;
 export const GATEWAY_PROTOCOL_MAX = 4;
 const BRIDGE_ATTACHMENTS_DIR = getBridgeAttachmentsDir();
 const CONTEXT_SYNC_DIR = join(getDataDir(), "context-sync");
+const FEISHU_DOCS_DIR = join(getDataDir(), "feishu-docs");
+const MAX_FEISHU_DOC_ATTACHMENT_BYTES = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_MAX_FEISHU_DOC_ATTACHMENT_BYTES || 1024 * 1024);
 const MAX_INLINE_CONTEXT_MESSAGES = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_MAX_INLINE_CONTEXT_MESSAGES || 20);
 const MAX_INLINE_CONTEXT_BYTES = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_MAX_INLINE_CONTEXT_BYTES || 128 * 1024);
 /**
@@ -213,11 +215,18 @@ export class OpenClawClient {
                     // Tool calls in assistant messages — skip, using agent item events instead
                     // (session.message toolCall events are batched, not real-time)
                 }
-                // Agent assistant streams — verbose mode should expose intermediate text,
-                // while normal mode only surfaces the final result via collectReply.
+                // Agent assistant streams — verbose mode buffers intermediate text and
+                // flushes it only on a real boundary (for example, before a tool starts).
+                // This keeps a single assistant preface together instead of leaking it
+                // as multiple debounce-sized Feishu messages.
                 if (frame.event === "agent" && (frame.payload?.stream === "assistant" || frame.payload?.stream === "chatDelta")) {
                     this.handleVerboseAssistantStream(frame.payload);
                 }
+                if (frame.event === "agent" && frame.payload?.stream === "lifecycle" && frame.payload?.data?.phase === "end") {
+                    const rawKey = frame.payload.sessionKey || "";
+                    this.flushVerboseAssistantState(rawKey);
+                    this.clearVerboseAssistantState(rawKey);
+                }
                 // Agent item / command output events — real-time tool tracking for verbose mode.
                 if (frame.event === "agent" && frame.payload?.stream === "item") {
                     const data = frame.payload.data || {};
@@ -382,15 +391,9 @@ export class OpenClawClient {
         this.verboseAssistantLatest.set(key, text);
         this.verboseAssistantLastTouched.set(key, now);
         this.pruneVerboseCaches(now);
-        const existing = this.verboseAssistantTimers.get(key);
-        if (existing)
-            clearTimeout(existing);
-        this.verboseAssistantTimers.set(key, setTimeout(() => {
-            this.verboseAssistantTimers.delete(key);
-            if (!this.isVerboseTranscriptEnabled(rawKey))
-                return;
+        if (text.length >= 3000) {
             this.flushVerboseAssistantState(rawKey);
-        }, 800));
+        }
     }
     handleProactiveSessionMessage(rawKey, msg) {
         const shortKey = rawKey.replace(/^agent:[^:]+:/, "");
@@ -1223,6 +1226,7 @@ export class OpenClawClient {
         const attachments = [];
         const seen = new Set();
         const imagePattern = /\[Image: ([^\]\n]+)\]/g;
+        const docPattern = /\[FeishuDoc: [^\]\n]*? -> ([^\]\n]+\.md)\]/g;
         for (const content of contents) {
             for (const match of content.matchAll(imagePattern)) {
                 const imagePath = match[1]?.trim();
@@ -1243,6 +1247,34 @@ export class OpenClawClient {
                     console.warn(`[OpenClaw] failed to attach image ${imagePath}:`, err.message);
                 }
             }
+            for (const match of content.matchAll(docPattern)) {
+                const docPath = match[1]?.trim();
+                if (!docPath || seen.has(docPath))
+                    continue;
+                seen.add(docPath);
+                try {
+                    const resolvedDocPath = resolve(docPath);
+                    const allowedRoot = resolve(FEISHU_DOCS_DIR);
+                    if (resolvedDocPath !== allowedRoot && !resolvedDocPath.startsWith(`${allowedRoot}${sep}`)) {
+                        throw new Error(`Feishu doc markdown path outside hydration dir: ${docPath}`);
+                    }
+                    const size = statSync(resolvedDocPath).size;
+                    let docContent = readFileSync(resolvedDocPath, "utf8");
+                    if (size > MAX_FEISHU_DOC_ATTACHMENT_BYTES) {
+                        const truncated = Buffer.from(docContent, "utf8").subarray(0, MAX_FEISHU_DOC_ATTACHMENT_BYTES).toString("utf8");
+                        docContent = `${truncated}\n\n---\n[文档过大，LMA 已截断到 ${MAX_FEISHU_DOC_ATTACHMENT_BYTES} bytes；如需完整内容，请让 LMA 扩大 OPENCLAW_LARK_MULTI_AGENT_MAX_FEISHU_DOC_ATTACHMENT_BYTES 或改用本地路径读取。]`;
+                    }
+                    attachments.push({
+                        type: "file",
+                        mimeType: "text/markdown",
+                        fileName: basename(resolvedDocPath),
+                        content: Buffer.from(docContent, "utf8").toString("base64"),
+                    });
+                }
+                catch (err) {
+                    console.warn(`[OpenClaw] failed to attach Feishu doc markdown ${docPath}:`, err.message);
+                }
+            }
         }
         return attachments;
     }

package/package.json

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