openclaw-lark-multi-agent 1.0.4 → 1.0.5

package/dist/discussion-manager.js

@@ -133,10 +133,11 @@ export class DiscussionManager {
     buildPrompt(session) {
         const previous = session.completedRounds.length === 0
             ? "（暂无，当前是第一轮）"
-            : session.completedRounds.map((round) => {
+            : (() => {
+                const round = session.completedRounds[session.completedRounds.length - 1];
                 const lines = Object.entries(round.replies).map(([bot, text]) => `- ${bot}: ${text || "NO_REPLY"}`);
                 return `Round ${round.round}:\n${lines.join("\n")}`;
-            }).join("\n\n");
+            })();
         return [
             "这是一个多智能体结构化讨论。",
             "",

package/dist/feishu-bot.d.ts

@@ -146,6 +146,7 @@ export declare class FeishuBot {
     /**
      * Send a model-drift notification to the affected chat.
      */
+    private hydrateInlineImageKeys;
     /**
      * Download a resource (image/file/audio) from a Feishu message.
      * Returns the local file path.

package/dist/feishu-bot.js

@@ -360,7 +360,7 @@ export class FeishuBot {
             }
             else if (messageType === "post") {
                 // Rich text post - extract all text content
-                cleanText = this.extractPostText(content);
+                cleanText = await this.hydrateInlineImageKeys(this.extractPostText(content), messageId);
             }
             else if (messageType === "sticker") {
                 cleanText = `[Sticker: ${content.file_key || "unknown"}]`;
@@ -1107,6 +1107,7 @@ export class FeishuBot {
                 currentSenderName: "Discussion Scheduler",
                 deliver: false,
                 timeoutMs: 1_800_000,
+                emptyFinalAsNoReply: true,
             });
         }
         finally {
@@ -1588,6 +1589,24 @@ export class FeishuBot {
     /**
      * Send a model-drift notification to the affected chat.
      */
+    async hydrateInlineImageKeys(text, messageId) {
+        const imageKeyPattern = /\[Image: (img_[^\]\n]+)\]/g;
+        const replacements = [];
+        for (const match of text.matchAll(imageKeyPattern)) {
+            const imageKey = match[1];
+            try {
+                const imgPath = await this.downloadResource(messageId, imageKey, "image");
+                replacements.push({ from: match[0], to: `[Image: ${imgPath}]` });
+            }
+            catch (err) {
+                replacements.push({ from: match[0], to: `[Image: download failed - ${err.message}]` });
+            }
+        }
+        let out = text;
+        for (const r of replacements)
+            out = out.replace(r.from, r.to);
+        return out;
+    }
     /**
      * Download a resource (image/file/audio) from a Feishu message.
      * Returns the local file path.

package/dist/index.js

@@ -2,7 +2,7 @@ import { loadConfig } from "./config.js";
 import { OpenClawClient } from "./openclaw-client.js";
 import { MessageStore } from "./message-store.js";
 import { FeishuBot } from "./feishu-bot.js";
-import { mkdirSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
 export async function startApp(configPath) {
@@ -19,6 +19,22 @@ export async function startApp(configPath) {
         : resolve(dirname(resolvedConfigPath), "data");
     mkdirSync(dataDir, { recursive: true });
     console.log(`Data dir: ${dataDir}`);
+    const lockPath = resolve(dataDir, "lma.pid");
+    if (existsSync(lockPath)) {
+        const oldPid = Number(readFileSync(lockPath, "utf8").trim());
+        if (Number.isFinite(oldPid) && oldPid > 0) {
+            try {
+                process.kill(oldPid, 0);
+                throw new Error(`Another openclaw-lark-multi-agent instance is already running (pid ${oldPid}). Stop it before starting a new one.`);
+            }
+            catch (err) {
+                const code = err.code;
+                if (code !== "ESRCH")
+                    throw err;
+            }
+        }
+    }
+    writeFileSync(lockPath, `${process.pid}\n`);
     const store = new MessageStore(resolve(dataDir, "messages.db"));
     // Connect to OpenClaw Gateway via WebSocket
     const openclawClient = new OpenClawClient(config.openclaw);
@@ -39,6 +55,11 @@ export async function startApp(configPath) {
         console.log("\nShutting down...");
         openclawClient.disconnect();
         store.close();
+        try {
+            if (readFileSync(lockPath, "utf8").trim() === String(process.pid))
+                rmSync(lockPath, { force: true });
+        }
+        catch { }
         process.exit(0);
     };
     process.on("SIGINT", shutdown);

package/dist/openclaw-client.d.ts

@@ -6,6 +6,8 @@ export type ChatAttachment = {
     fileName?: string;
     content: string;
 };
+export declare const GATEWAY_PROTOCOL_MIN = 3;
+export declare const GATEWAY_PROTOCOL_MAX = 4;
 /**
  * OpenClaw Gateway WebSocket client.
  * Full agent pipeline — tools, memory, skills, context management by OpenClaw.
@@ -25,9 +27,12 @@ export declare class OpenClawClient {
     private sessionMessageCallbacks;
     /** Session keys that should be re-subscribed on reconnect */
     private subscribedKeys;
-    /** Session keys with active/recent chatSend — proactive is forwarded and deduped by outbox. */
+    /** Session keys whose transcript/session.message updates are currently suppressed. */
     private suppressedSessions;
     private suppressedSessionTimers;
+    /** Session keys whose delivery is owned by this bridge's chatSend final path. */
+    private ownedDeliverySessions;
+    private ownedDeliverySessionTimers;
     /** Session keys whose proactive messages must be dropped by the bridge (e.g. discussion scheduler owns delivery). */
     private mutedProactiveSessions;
     private mutedProactiveSessionCounts;
@@ -73,8 +78,15 @@ export declare class OpenClawClient {
      * deliver=false prevents OpenClaw from auto-posting to channels.
      */
     abortChat(sessionKey: string, runId: string): Promise<any>;
+    private sessionKeyVariants;
+    private trackChatEventSession;
+    private extractTextFromChatMessage;
+    private emitProactiveForSession;
     private suppressSessionKeys;
     private releaseSuppressedSessionKeysAfter;
+    private ownDeliverySessionKeys;
+    private releaseOwnedDeliverySessionKeysAfter;
+    private isOwnedDeliverySession;
     private addMutedProactiveKey;
     private releaseMutedProactiveKey;
     muteProactiveDelivery(sessionKey: string): (delayMs?: number) => void;
@@ -84,6 +96,7 @@ export declare class OpenClawClient {
         attachments?: ChatAttachment[];
         deliver?: boolean;
         timeoutMs?: number;
+        emptyFinalAsNoReply?: boolean;
     }): Promise<string>;
     private shouldInjectBridgeAttachmentHint;
     private bridgeAttachmentHint;
@@ -107,6 +120,7 @@ export declare class OpenClawClient {
         currentSenderName: string;
         deliver?: boolean;
         timeoutMs?: number;
+        emptyFinalAsNoReply?: boolean;
     }): Promise<string>;
     private extractImageAttachments;
     disconnect(): Promise<void>;

package/dist/openclaw-client.js

@@ -3,6 +3,8 @@ import { randomUUID } from "crypto";
 import { readFileSync } from "fs";
 import { basename, extname } from "path";
 import { getBridgeAttachmentsDir } from "./paths.js";
+export const GATEWAY_PROTOCOL_MIN = 3;
+export const GATEWAY_PROTOCOL_MAX = 4;
 const BRIDGE_ATTACHMENTS_DIR = getBridgeAttachmentsDir();
 /**
  * OpenClaw Gateway WebSocket client.
@@ -23,9 +25,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 — proactive is forwarded and deduped by outbox. */
+    /** Session keys whose transcript/session.message updates are currently suppressed. */
     suppressedSessions = new Set();
     suppressedSessionTimers = new Map();
+    /** Session keys whose delivery is owned by this bridge's chatSend final path. */
+    ownedDeliverySessions = new Set();
+    ownedDeliverySessionTimers = 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();
@@ -60,8 +65,8 @@ export class OpenClawClient {
                             id: "connect-1",
                             method: "connect",
                             params: {
-                                minProtocol: 4,
-                                maxProtocol: 99,
+                                minProtocol: GATEWAY_PROTOCOL_MIN,
+                                maxProtocol: GATEWAY_PROTOCOL_MAX,
                                 client: {
                                     id: "gateway-client",
                                     version: "1.0.0",
@@ -111,8 +116,24 @@ export class OpenClawClient {
                     // Normalize chat events to look like agent events for collectReply
                     if (frame.event === "chat") {
                         const state = frame.payload?.state;
+                        this.trackChatEventSession(sk, state, frame.payload);
                         const msg = frame.payload?.message;
-                        if (state === "final") {
+                        if (state === "delta") {
+                            // v4: chat delta events carry deltaText (incremental text chunk)
+                            const deltaText = frame.payload?.deltaText;
+                            if (deltaText) {
+                                this.agentEvents.get(sk).push({
+                                    ...frame.payload,
+                                    stream: "chatDelta",
+                                    data: {
+                                        deltaText,
+                                        delta: deltaText, // v3 compat
+                                        replace: frame.payload?.replace || false,
+                                    },
+                                });
+                            }
+                        }
+                        else if (state === "final") {
                             // Store chat final text as fallback (only used if agent stream had no text)
                             const textParts = [];
                             if (msg?.content) {
@@ -215,7 +236,8 @@ export class OpenClawClient {
             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`);
+            console.log(`[OpenClaw] Dropping proactive transcript msg for ${shortKey}; waiting for final delivery path`);
+            return false;
         }
         const cb = this.sessionMessageCallbacks.get(rawKey) || this.sessionMessageCallbacks.get(shortKey);
         if (cb)
@@ -266,9 +288,10 @@ export class OpenClawClient {
      * No aggressive timeout — waits for lifecycle end as the source of truth.
      * 30-minute safety net only for catastrophic WS disconnection.
      */
-    collectReply(runId, timeoutMs = 1800000, targetSessionKey) {
+    collectReply(runId, timeoutMs = 1800000, targetSessionKey, options) {
         return new Promise((resolve, reject) => {
             let text = "";
+            let chatDeltaText = "";
             let chatFinalText = "";
             let sessionKey = targetSessionKey ? `agent:main:${targetSessionKey}` : "";
             let chatFinalTimer = null;
@@ -292,7 +315,7 @@ export class OpenClawClient {
                     this.abortChat(targetSessionKey || sessionKey, runId).catch((err) => {
                         console.warn(`[OpenClaw] abort after collectReply idle timeout failed:`, err.message);
                     });
-                    resolve(text || chatFinalText || "(timeout: no reply received)");
+                    resolve(text || chatDeltaText || chatFinalText || "(timeout: no reply received)");
                 }, timeoutMs);
             };
             resetIdleTimer();
@@ -348,14 +371,23 @@ export class OpenClawClient {
                             lifecycleStartedLogged = true;
                             console.log(`[OpenClaw] lifecycle start for runId=${runId} after ${Date.now() - collectStartedAt}ms`);
                         }
-                        if (ev.stream === "assistant" && (ev.data?.deltaText || ev.data?.delta)) {
+                        if ((ev.stream === "assistant" || ev.stream === "chatDelta") && (ev.data?.deltaText || ev.data?.delta)) {
                             const chunk = ev.data.deltaText || ev.data.delta;
-                            if (ev.data?.replace) {
-                                // v4: non-prefix replacement — deltaText is the full replacement
-                                text = chunk;
+                            if (ev.stream === "assistant") {
+                                if (ev.data?.replace) {
+                                    text = chunk;
+                                }
+                                else {
+                                    text += chunk;
+                                }
                             }
                             else {
-                                text += chunk;
+                                if (ev.data?.replace) {
+                                    chatDeltaText = chunk;
+                                }
+                                else {
+                                    chatDeltaText += chunk;
+                                }
                             }
                         }
                         if (ev.stream === "chatFinal") {
@@ -369,10 +401,13 @@ export class OpenClawClient {
                                     });
                                     // Prefer final chat message over accumulated deltas: some providers may
                                     // emit only partial deltas (e.g. "N") while final contains "NO_REPLY".
-                                    const latestFinalText = chatFinalText || text;
+                                    const latestFinalText = chatFinalText || text || chatDeltaText;
                                     if (latestFinalText) {
                                         finish(latestFinalText);
                                     }
+                                    else if (options?.emptyFinalAsNoReply) {
+                                        finish("NO_REPLY");
+                                    }
                                     else {
                                         console.warn(`[OpenClaw] collectReply: empty chatFinal fallback ignored; waiting for real text or idle timeout`);
                                         chatFinalTimer = null;
@@ -383,9 +418,9 @@ export class OpenClawClient {
                         if (ev.stream === "lifecycle" && ev.data?.phase === "end") {
                             // Prefer final chat message over accumulated deltas: some providers may
                             // emit only partial deltas (e.g. "N") while final contains "NO_REPLY".
-                            const finalText = chatFinalText || text;
+                            const finalText = chatFinalText || text || chatDeltaText;
                             const finishFromLifecycle = () => {
-                                const latestFinalText = chatFinalText || text;
+                                const latestFinalText = chatFinalText || text || chatDeltaText;
                                 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
@@ -393,6 +428,10 @@ export class OpenClawClient {
                                     finish("NO_REPLY");
                                     return;
                                 }
+                                if (!latestFinalText && options?.emptyFinalAsNoReply) {
+                                    finish("NO_REPLY");
+                                    return;
+                                }
                                 if (!latestFinalText) {
                                     const state = ev.data?.livenessState || "unknown";
                                     const reason = ev.data?.stopReason || "";
@@ -414,7 +453,7 @@ export class OpenClawClient {
                             };
                             // If lifecycle end beats chat final, a short delta like "N" can be a truncated
                             // final reply. Wait for chatFinal before resolving; otherwise suppress lone "N".
-                            if (!chatFinalText && text.length <= 1) {
+                            if (!options?.emptyFinalAsNoReply && !chatFinalText && text.length <= 1) {
                                 lifecycleEndTimer = setTimeout(finishFromLifecycle, 5000);
                             }
                             else {
@@ -490,6 +529,53 @@ 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(() => { });
     }
+    sessionKeyVariants(key) {
+        const shortKey = key.startsWith("agent:main:") ? key.slice("agent:main:".length) : key;
+        return [shortKey, `agent:main:${shortKey}`];
+    }
+    trackChatEventSession(sessionKey, state, payload) {
+        if (!sessionKey || sessionKey === "__default__")
+            return;
+        const keys = this.sessionKeyVariants(sessionKey);
+        if (this.isOwnedDeliverySession(sessionKey)) {
+            // This chat event belongs to a bridge-owned chat.send run. The final answer
+            // is delivered by collectReply/processQueue, so transcript session.message
+            // mirrors must stay suppressed briefly.
+            this.suppressSessionKeys(keys);
+            if (state === "final" || state === "error" || state === "aborted")
+                this.releaseSuppressedSessionKeysAfter(keys, 30000);
+            return;
+        }
+        // External WebChat/Control UI chat against an LMA session: do not forward
+        // streaming transcript updates, but allow the final chat message to be
+        // delivered through the proactive callback after it is committed.
+        if (state === "delta") {
+            this.suppressSessionKeys(keys);
+        }
+        else if (state === "final") {
+            const text = this.extractTextFromChatMessage(payload?.message);
+            if (text)
+                this.emitProactiveForSession(sessionKey, text);
+            // Keep transcript mirrors suppressed briefly; chat final already emitted
+            // the user-visible result for external WebChat/Control UI turns.
+            this.releaseSuppressedSessionKeysAfter(keys, 30000);
+        }
+        else if (state === "error" || state === "aborted") {
+            this.releaseSuppressedSessionKeysAfter(keys, 0);
+        }
+    }
+    extractTextFromChatMessage(message) {
+        const parts = Array.isArray(message?.content) ? message.content : [];
+        return parts.filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n").trim();
+    }
+    emitProactiveForSession(sessionKey, text) {
+        const [shortKey, fullKey] = this.sessionKeyVariants(sessionKey);
+        const cb = this.sessionMessageCallbacks.get(fullKey) || this.sessionMessageCallbacks.get(shortKey);
+        if (!cb)
+            return false;
+        cb(text);
+        return true;
+    }
     suppressSessionKeys(keys) {
         for (const key of keys) {
             const timer = this.suppressedSessionTimers.get(key);
@@ -511,6 +597,31 @@ export class OpenClawClient {
             this.suppressedSessionTimers.set(key, timer);
         }
     }
+    ownDeliverySessionKeys(keys) {
+        for (const key of keys) {
+            const timer = this.ownedDeliverySessionTimers.get(key);
+            if (timer)
+                clearTimeout(timer);
+            this.ownedDeliverySessionTimers.delete(key);
+            this.ownedDeliverySessions.add(key);
+        }
+    }
+    releaseOwnedDeliverySessionKeysAfter(keys, delayMs) {
+        for (const key of keys) {
+            const oldTimer = this.ownedDeliverySessionTimers.get(key);
+            if (oldTimer)
+                clearTimeout(oldTimer);
+            const timer = setTimeout(() => {
+                this.ownedDeliverySessions.delete(key);
+                this.ownedDeliverySessionTimers.delete(key);
+            }, delayMs);
+            this.ownedDeliverySessionTimers.set(key, timer);
+        }
+    }
+    isOwnedDeliverySession(sessionKey) {
+        const [shortKey, fullKey] = this.sessionKeyVariants(sessionKey);
+        return this.ownedDeliverySessions.has(shortKey) || this.ownedDeliverySessions.has(fullKey);
+    }
     addMutedProactiveKey(key) {
         const count = this.mutedProactiveSessionCounts.get(key) || 0;
         this.mutedProactiveSessionCounts.set(key, count + 1);
@@ -552,6 +663,7 @@ export class OpenClawClient {
         const fullSessionKey = `agent:main:${sk}`;
         const suppressedKeys = [sk, fullSessionKey];
         this.suppressSessionKeys(suppressedKeys);
+        this.ownDeliverySessionKeys(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
@@ -567,7 +679,7 @@ export class OpenClawClient {
                 idempotencyKey: randomUUID(),
             });
             console.log(`[OpenClaw] chat.send runId: ${result.runId} (rpc=${Date.now() - sendStartedAt}ms, attachments=${params.attachments?.length || 0})`);
-            return await this.collectReply(result.runId, params.timeoutMs || 1800000, sk);
+            return await this.collectReply(result.runId, params.timeoutMs || 1800000, sk, { emptyFinalAsNoReply: params.emptyFinalAsNoReply });
         }
         finally {
             // OpenClaw can emit the final assistant session.message a moment after
@@ -575,6 +687,7 @@ export class OpenClawClient {
             // 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);
+            this.releaseOwnedDeliverySessionKeysAfter(suppressedKeys, 30000);
         }
     }
     shouldInjectBridgeAttachmentHint(text) {
@@ -617,6 +730,7 @@ export class OpenClawClient {
                 attachments,
                 deliver: params.deliver,
                 timeoutMs: params.timeoutMs,
+                emptyFinalAsNoReply: params.emptyFinalAsNoReply,
             });
         }
         // Build context block + actual message in one chat.send
@@ -639,6 +753,7 @@ export class OpenClawClient {
             attachments,
             deliver: params.deliver,
             timeoutMs: params.timeoutMs,
+            emptyFinalAsNoReply: params.emptyFinalAsNoReply,
         });
     }
     extractImageAttachments(contents) {
@@ -676,6 +791,10 @@ export class OpenClawClient {
         this.suppressedSessions.clear();
         this.mutedProactiveSessions.clear();
         this.mutedProactiveSessionCounts.clear();
+        for (const timer of this.ownedDeliverySessionTimers.values())
+            clearTimeout(timer);
+        this.ownedDeliverySessionTimers.clear();
+        this.ownedDeliverySessions.clear();
         if (this.ws) {
             this.ws.close();
             this.ws = null;

package/package.json

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