openclaw-lark-multi-agent 1.8.5 → 1.8.7

package/dist/feishu-bot.js

@@ -1452,7 +1452,14 @@ export class FeishuBot {
                     state = 'rejected'; // prior explicit backend refusal; never silently move it to a successor
                 if (state === 'unavailable' || state === 'capability_blocked')
                     state = 'pending';
-                const record = { ...item, attempted: valid ? (receipt.attempted ?? true) : true, sessionId: item.sessionId, reason: receipt.reason };
+                // Unknown is the NORMAL transient state right after a steer attempt
+                // (the backend acceptance receipt has not landed yet); surfacing it on
+                // every insertion spams the chat (user report 2026-10-16: "每次插入消
+                // 息都发个这个"). Stay silent until it persists through several
+                // re-checks (~45s), then notify exactly once.
+                const unknownChecks = state === 'unknown' ? (Number(item.unknownChecks) || 0) + 1 : 0;
+                const unknownNotified = Boolean(item.unknownNotified) || (state === 'unknown' && unknownChecks >= 3);
+                const record = { ...item, attempted: valid ? (receipt.attempted ?? true) : true, sessionId: item.sessionId, reason: receipt.reason, unknownChecks, unknownNotified };
                 this.store.saveInsertion(this.config.name, chatId, item.rowId, item.insertionId, state, record, Date.now() + (state === 'unknown' ? 15_000 : 5000));
                 if (state === 'ordinary') {
                     void this.enqueueAndDispatchDelivery(chatId, 'insertion_status', `insertion:${item.insertionId}:ordinary`, 'ℹ️ 原 run 已明确结束，且这条消息确定未被插入；现已交回普通队列，只执行一次。', [], item.messageId, `insertion:${item.insertionId}:ordinary`).catch(() => { });
@@ -1475,10 +1482,13 @@ export class FeishuBot {
                         this.admittedSteerAcks.set(chatId, list);
                     }
                 }
-                else if (state === 'unknown' || state === 'target_changed' || state === 'rejected') {
+                else if (state === 'target_changed' || state === 'rejected') {
                     if (item.state !== state)
                         void this.enqueueAndDispatchDelivery(chatId, 'insertion_status', `insertion:${item.insertionId}:${state}`, `ℹ️ 这条插入消息的状态为 ${state}，仍保留本地记录，未确认接收前不会显示 Get，也不会自动重复执行。${receipt.reason || ''}`, [], item.messageId, `insertion:${item.insertionId}:${state}`).catch(() => { });
                 }
+                else if (state === 'unknown' && unknownNotified && !item.unknownNotified) {
+                    void this.enqueueAndDispatchDelivery(chatId, 'insertion_status', `insertion:${item.insertionId}:unknown-prolonged`, `ℹ️ 这条插入消息约 45 秒仍未确认接收：本地记录保留中，不会自动重复执行；确认后会自动显示 Get。`, [], item.messageId, `insertion:${item.insertionId}:unknown-prolonged`).catch(() => { });
+                }
             }
         }
         finally {

package/dist/openclaw-client.js

@@ -900,6 +900,11 @@ export class OpenClawClient {
             let lifecycleEndTimer = null;
             let replayInvalidTimer = null;
             let genericChatErrorTimer = null;
+            // A channel message-tool send marked terminate=true is the turn's intended
+            // user-visible output (2026-10-16 incident: it bypassed the bridge and the
+            // collector waited forever). Capture its text and settle on a short grace.
+            let terminatingSendText = "";
+            let terminatingSendTimer = null;
             let pendingRuntimeFailureText = "";
             let lastActivitySummary = "";
             let lastActivityAt = 0;
@@ -1174,6 +1179,8 @@ export class OpenClawClient {
                     clearTimeout(replayInvalidTimer);
                 if (genericChatErrorTimer)
                     clearTimeout(genericChatErrorTimer);
+                if (terminatingSendTimer)
+                    clearTimeout(terminatingSendTimer);
                 resolve(finalText);
             };
             const collectEvents = () => {
@@ -1310,6 +1317,43 @@ export class OpenClawClient {
                         if (hasEffectiveActivity(ev))
                             resetIdleTimer();
                         rememberActivity(ev);
+                        // Terminating channel-send detection: a message-tool result carrying
+                        // terminate=true ends the turn with that send as its user-visible
+                        // output. The bridge is the delivery channel for LMA sessions, so
+                        // waiting for a further final would hang forever (2026-10-16 frozen
+                        // card incident). Capture the sent text at tool start; settle on a
+                        // short grace unless a real final arrives first.
+                        {
+                            const tdata = ev.data || {};
+                            if (ev.stream === "tool" || (ev.stream === "item" && tdata.kind === "tool")) {
+                                const toolName = String(tdata.name || tdata.toolName || "");
+                                const tphase = tdata.phase === "result" ? (tdata.isError || tdata.error ? "error" : "end") : tdata.phase;
+                                if (toolName === "message" && tphase === "start") {
+                                    const raw = tdata.input ?? tdata.args ?? tdata.meta ?? null;
+                                    if (raw !== null) {
+                                        try {
+                                            const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+                                            if (parsed && typeof parsed.message === "string" && parsed.message.trim())
+                                                terminatingSendText = parsed.message;
+                                        }
+                                        catch { /* non-JSON tool input */ }
+                                    }
+                                }
+                                else if (toolName === "message" && (tphase === "end" || tphase === "error")) {
+                                    const out = String(JSON.stringify(tdata.output ?? tdata.result ?? tdata.error ?? ""));
+                                    if (/"?terminate"?\s*[:=]\s*true/i.test(out) && !terminatingSendTimer) {
+                                        terminatingSendTimer = setTimeout(() => {
+                                            terminatingSendTimer = null;
+                                            if (observationClosed)
+                                                return;
+                                            const best = (chatFinalText.trim() || text.trim() || terminatingSendText || "").trim();
+                                            finish(best || "NO_REPLY");
+                                        }, 10_000);
+                                        terminatingSendTimer.unref?.();
+                                    }
+                                }
+                            }
+                        }
                         // If more events arrive after a replay-invalid lifecycle end, that lifecycle
                         // was not terminal for the user-visible run. Keep waiting for the real final.
                         if (replayInvalidTimer) {
@@ -1625,6 +1669,8 @@ export class OpenClawClient {
                     clearTimeout(replayInvalidTimer);
                 if (genericChatErrorTimer)
                     clearTimeout(genericChatErrorTimer);
+                if (terminatingSendTimer)
+                    clearTimeout(terminatingSendTimer);
                 if (observationKey && this.runStateChecks.get(observationKey) === checkAfterNoActiveRun)
                     this.runStateChecks.delete(observationKey);
             };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-lark-multi-agent",
-  "version": "1.8.5",
+  "version": "1.8.7",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {
@@ -81,4 +81,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}