openclaw-lark-multi-agent 0.1.4 → 0.1.5

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;

package/dist/openclaw-client.js

@@ -21,8 +21,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 +150,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 +451,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,8 +495,11 @@ 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);
         }
     }
     /**
@@ -547,6 +584,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/package.json

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