openclaw-lark-multi-agent 1.2.5 → 1.2.7

package/dist/feishu-bot.d.ts

@@ -123,28 +123,19 @@ export declare class FeishuBot {
     private isLegacyBridgeControlMessage;
     private isRuntimeFailureText;
     /**
-     * Heuristic: does this reply look truncated / mid-task? Bias toward false
-     * positives (“宁可错杀不放过”) — a false positive only costs one invisible
-     * confirmation round, and the session self-check is the real arbiter. We gate
-     * only on cheap text shape here, never on stopReason (the upstream rarely
-     * provides one for normal-looking-but-truncated finals).
-     */
-    /**
-     * Heuristic: does this reply look genuinely truncated / cut off mid-task?
+     * Heuristic: does this reply look truncated / cut off mid-task? Used as the
+     * SOLE auto-retry trigger — if true, we ask the session a one-line “done?” probe.
      *
-     * IMPORTANT (per Stephen): only retry when there is CLEAR evidence the agent
-     * did not finish — do NOT retry just because a reply lacks a trailing period.
-     * Many complete replies legitimately end without sentence punctuation (a terse
-     * “好的”, a bullet list, a path, a number, a closing word). Treating those as
-     * truncated caused needless extra probe rounds, which hurts UX. So we gate on
-     * strong structural signals only:
+     * Signals (any one is enough):
      *   1. Unbalanced code fence — almost certainly cut off mid code block.
-     *   2. Ends with a dangling connector / lead-in (“然后”, “接下来”, “let me”…)
-     *      or a trailing clause-joining punctuation (comma/colon/semicolon),
-     *      which means a sentence was left hanging.
-     *   3. Ends mid-word inside a Latin word right after a connector-less clause
-     *      (very rare; only when the last “word” is unusually long), kept minimal.
-     * A plain “no sentence-ending punctuation” is deliberately NOT sufficient.
+     *   2. Trailing clause-joining punctuation (comma/colon/semicolon/、) — a
+     *      sentence was left hanging.
+     *   3. A dangling connector / lead-in (“然后”, “接下来”, “let me”, “and”…).
+     *   4. Ends without ANY sentence-ending punctuation / closer (no terminal
+     *      punctuation, closing bracket/quote, code fence, or wrap-up emoji).
+     *      Per Stephen: a reply that ends with no punctuation at all is also
+     *      treated as likely unfinished. A false positive only costs one cheap,
+     *      invisible confirmation probe; the session itself is the real arbiter.
      */
     private looksTruncated;
     /** Current context usage percent for a session (totalTokens / contextTokens),

package/dist/feishu-bot.js

@@ -1647,28 +1647,19 @@ export class FeishuBot {
         return text.startsWith("⚠️ Agent 未正常完成") || /\n原因:\s*rpc\b/.test(text);
     }
     /**
-     * Heuristic: does this reply look truncated / mid-task? Bias toward false
-     * positives (“宁可错杀不放过”) — a false positive only costs one invisible
-     * confirmation round, and the session self-check is the real arbiter. We gate
-     * only on cheap text shape here, never on stopReason (the upstream rarely
-     * provides one for normal-looking-but-truncated finals).
-     */
-    /**
-     * Heuristic: does this reply look genuinely truncated / cut off mid-task?
+     * Heuristic: does this reply look truncated / cut off mid-task? Used as the
+     * SOLE auto-retry trigger — if true, we ask the session a one-line “done?” probe.
      *
-     * IMPORTANT (per Stephen): only retry when there is CLEAR evidence the agent
-     * did not finish — do NOT retry just because a reply lacks a trailing period.
-     * Many complete replies legitimately end without sentence punctuation (a terse
-     * “好的”, a bullet list, a path, a number, a closing word). Treating those as
-     * truncated caused needless extra probe rounds, which hurts UX. So we gate on
-     * strong structural signals only:
+     * Signals (any one is enough):
      *   1. Unbalanced code fence — almost certainly cut off mid code block.
-     *   2. Ends with a dangling connector / lead-in (“然后”, “接下来”, “let me”…)
-     *      or a trailing clause-joining punctuation (comma/colon/semicolon),
-     *      which means a sentence was left hanging.
-     *   3. Ends mid-word inside a Latin word right after a connector-less clause
-     *      (very rare; only when the last “word” is unusually long), kept minimal.
-     * A plain “no sentence-ending punctuation” is deliberately NOT sufficient.
+     *   2. Trailing clause-joining punctuation (comma/colon/semicolon/、) — a
+     *      sentence was left hanging.
+     *   3. A dangling connector / lead-in (“然后”, “接下来”, “let me”, “and”…).
+     *   4. Ends without ANY sentence-ending punctuation / closer (no terminal
+     *      punctuation, closing bracket/quote, code fence, or wrap-up emoji).
+     *      Per Stephen: a reply that ends with no punctuation at all is also
+     *      treated as likely unfinished. A false positive only costs one cheap,
+     *      invisible confirmation probe; the session itself is the real arbiter.
      */
     looksTruncated(text) {
         const t = (text || "").trim();
@@ -1684,6 +1675,16 @@ export class FeishuBot {
         // (2b) Ends on an explicit continuation cue / lead-in.
         if (/(接下来|然后|首先|现在我|让我|下一步|我先|我来|我接着|接着|稍等|let me|now i|next|first|\b(?:and|then|so|to|the|a)\b)\s*$/iu.test(t))
             return true;
+        // (2c) Ends without ANY sentence-ending punctuation / closer. A finished
+        //      reply normally ends with terminal punctuation, a closing bracket/
+        //      quote, a code fence, or a wrap-up emoji; if none of those are present
+        //      the reply was most likely cut off mid-sentence. (Stephen: “结尾没有
+        //      任何标点符号也算疑似未结束”.)
+        const endOk = /[。！？.!?…)\]」』】）"'`”’~～—✨✅👍🙏🎉🙌]\s*$/u.test(t)
+            || /```\s*$/.test(t)
+            || /[}\]]\s*$/.test(t);
+        if (!endOk)
+            return true;
         return false;
     }
     /** Current context usage percent for a session (totalTokens / contextTokens),

package/dist/live-status.d.ts

@@ -55,6 +55,12 @@ export declare class LiveStatusController {
     private createPromise?;
     private finalized;
     private disabled;
+    /** Consecutive safeEdit failures. A single transient Feishu error (e.g. card
+     *  patch code=2200 "Internal Error") must NOT permanently disable the card:
+     *  we skip that one tick and keep the ticker running, so the next second's
+     *  patch recovers it. Only after this many CONSECUTIVE failures do we give up.
+     *  A success resets the counter. */
+    private consecutiveEditFailures;
     private state;
     /** Total tool calls (tool_start events) seen during the run, for the summary. */
     private toolCallCount;
@@ -90,6 +96,13 @@ export declare class LiveStatusController {
     /** Refresh the elapsed-time footer periodically even with no new activity. */
     private startTicker;
     private safeEdit;
+    /**
+     * Terminal edits (complete/fail/noReply) are one-shot — there is no next tick to
+     * recover them — so a transient Feishu error (code=2200 etc.) would leave the
+     * card stuck on "running". Retry the final patch a few times with small backoff
+     * so the card reliably reaches its terminal state.
+     */
+    private safeEditFinal;
     /** Dedupe key includes elapsed so the footer timer ticks even without new
      *  activity, while identical content within the same second is still skipped. */
     private signature;

package/dist/live-status.js

@@ -6,6 +6,12 @@ const DEFAULT_HISTORY = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS
 // so the "已用时间" ticks like a live timer. Interactive-card patch has no 20-edit
 // cap (unlike text edit), so a 1s cadence is fine.
 const DEFAULT_TICK_MS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_TICK_MS || 1000);
+// How many CONSECUTIVE card-edit failures to tolerate before giving up on the
+// card. Feishu's im.message.patch can intermittently return code=2200
+// "Internal Error" (a transient server-side error); a single failure must not
+// freeze the live-status card for the rest of a long run. We skip the failed
+// tick, keep the ticker alive, and only disable after this many in a row.
+const MAX_CONSECUTIVE_EDIT_FAILURES = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_MAX_EDIT_FAILURES || 5);
 export class LiveStatusController {
     callbacks;
     opts;
@@ -19,6 +25,12 @@ export class LiveStatusController {
     createPromise;
     finalized = false;
     disabled = false;
+    /** Consecutive safeEdit failures. A single transient Feishu error (e.g. card
+     *  patch code=2200 "Internal Error") must NOT permanently disable the card:
+     *  we skip that one tick and keep the ticker running, so the next second's
+     *  patch recovers it. Only after this many CONSECUTIVE failures do we give up.
+     *  A success resets the counter. */
+    consecutiveEditFailures = 0;
     state = "running";
     /** Total tool calls (tool_start events) seen during the run, for the summary. */
     toolCallCount = 0;
@@ -85,7 +97,7 @@ export class LiveStatusController {
             await this.createPromise.catch(() => { });
         if (!this.messageId || this.disabled)
             return;
-        await this.safeEdit(this.buildView(), true);
+        await this.safeEditFinal(this.buildView());
     }
     async fail() {
         this.state = "failed";
@@ -95,7 +107,7 @@ export class LiveStatusController {
             await this.createPromise.catch(() => { });
         if (!this.messageId || this.disabled)
             return;
-        await this.safeEdit(this.buildView(), true);
+        await this.safeEditFinal(this.buildView());
     }
     /**
      * Finish when the model explicitly produced no reply (NO_REPLY) or an empty
@@ -111,7 +123,7 @@ export class LiveStatusController {
             await this.createPromise.catch(() => { });
         if (!this.messageId || this.disabled)
             return;
-        await this.safeEdit(this.buildView(), true);
+        await this.safeEditFinal(this.buildView());
     }
     dispose() {
         this.finalized = true;
@@ -216,15 +228,50 @@ export class LiveStatusController {
         try {
             await this.callbacks.edit(this.messageId, view);
             this.lastSentSignature = sig;
+            this.consecutiveEditFailures = 0; // recovered
             return true;
         }
         catch (err) {
-            this.disabled = true;
-            this.stopTimers();
-            this.callbacks.warn?.("live status edit failed", err);
+            // A single transient Feishu error (e.g. card patch code=2200 "Internal
+            // Error", rate limit, network blip) must NOT permanently freeze the card.
+            // Skip this tick and keep the ticker running so the next patch recovers it.
+            // Only give up after several CONSECUTIVE failures (a persistent problem,
+            // e.g. the message was deleted or we truly lost access).
+            this.consecutiveEditFailures++;
+            const giveUp = this.consecutiveEditFailures >= MAX_CONSECUTIVE_EDIT_FAILURES;
+            this.callbacks.warn?.(`live status edit failed (${this.consecutiveEditFailures}/${MAX_CONSECUTIVE_EDIT_FAILURES}${giveUp ? ", disabling" : ", will retry next tick"})`, err);
+            if (giveUp) {
+                this.disabled = true;
+                this.stopTimers();
+            }
             return false;
         }
     }
+    /**
+     * Terminal edits (complete/fail/noReply) are one-shot — there is no next tick to
+     * recover them — so a transient Feishu error (code=2200 etc.) would leave the
+     * card stuck on "running". Retry the final patch a few times with small backoff
+     * so the card reliably reaches its terminal state.
+     */
+    async safeEditFinal(view) {
+        if (!this.messageId || this.disabled)
+            return;
+        const attempts = Math.max(1, MAX_CONSECUTIVE_EDIT_FAILURES);
+        for (let i = 0; i < attempts; i++) {
+            try {
+                await this.callbacks.edit(this.messageId, view);
+                this.lastSentSignature = this.signature(view);
+                return;
+            }
+            catch (err) {
+                const last = i === attempts - 1;
+                this.callbacks.warn?.(`live status final edit failed (${i + 1}/${attempts}${last ? ", giving up" : ", retrying"})`, err);
+                if (last)
+                    return;
+                await new Promise((r) => setTimeout(r, 300 * (i + 1)));
+            }
+        }
+    }
     /** Dedupe key includes elapsed so the footer timer ticks even without new
      *  activity, while identical content within the same second is still skipped. */
     signature(view) {

package/package.json

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