openclaw-lark-multi-agent 1.2.6 → 1.2.8

package/dist/feishu-bot.js

@@ -1119,6 +1119,13 @@ export class FeishuBot {
             const isNativeCommandTrigger = firstIsNative;
             const lastHuman = mergedTriggers[mergedTriggers.length - 1];
             const triggerId = lastHuman.id || 0;
+            // Snapshot the stop generation BEFORE the main run starts. If the user runs
+            // /stop at any point during the main run, handleStopCommand bumps the epoch;
+            // auto-retry compares against this baseline and skips retrying entirely. If
+            // we snapshotted inside auto-retry instead, a /stop that landed during the
+            // main run would already be baked into the baseline and go undetected —
+            // that was the "stop then auto-retry anyway" bug.
+            const runStartStopEpoch = this.stopEpoch.get(chatId) || 0;
             const mergedContent = mergedTriggers.map((m) => m.content).join("\n");
             const mergedTriggerIds = mergedTriggers.map((m) => m.id || 0).filter(Boolean);
             const droppedTriggerIds = droppedMergedTriggers.map((m) => m.id || 0).filter(Boolean);
@@ -1267,6 +1274,7 @@ export class FeishuBot {
                     isNativeCommandTrigger,
                     initialReply: reply,
                     liveStatus,
+                    runStartStopEpoch,
                 });
                 const parsedReply = this.extractBridgeAttachments(reply);
                 const visibleReply = parsedReply.text;
@@ -1780,10 +1788,12 @@ export class FeishuBot {
         if (!autoRetryEnabled() || isNativeCommandTrigger)
             return reply;
         const maxRetry = autoRetryMax();
-        // Snapshot the stop generation at entry. If the user runs /stop while this
-        // loop is in flight, handleStopCommand bumps the epoch; we detect the change
-        // and stop retrying immediately instead of issuing more probes.
-        const startStopEpoch = this.stopEpoch.get(chatId) || 0;
+        // Baseline stop generation. Prefer the epoch captured before the main run
+        // (runStartStopEpoch) so a /stop that landed DURING the main run is still
+        // seen here; fall back to the current epoch only if the caller did not pass
+        // one. If the user hit /stop at any point from the main run onward, the
+        // epoch is now past the baseline and we must not auto-retry at all.
+        const startStopEpoch = params.runStartStopEpoch ?? (this.stopEpoch.get(chatId) || 0);
         const wasStopped = () => (this.stopEpoch.get(chatId) || 0) !== startStopEpoch;
         for (let attempt = 1; attempt <= maxRetry; attempt++) {
             // /stop while we were looping: abandon retries and deliver what we have.

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.6",
+  "version": "1.2.8",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {