openclaw-lark-multi-agent 1.2.4 → 1.2.6

package/dist/feishu-bot.d.ts

@@ -123,36 +123,19 @@ export declare class FeishuBot {
     private isLegacyBridgeControlMessage;
     private isRuntimeFailureText;
     /**
-     * Is this main-run error worth auto-retrying (by resuming the session via the
-     * probe loop)? Mainly transient failures — request/response timeouts and
-     * aborted/incomplete runs. We do NOT auto-retry clearly terminal errors
-     * (auth/permission/quota/billing/model-not-supported), which would just fail
-     * again. The error text comes from collectReply's `Agent error: <msg>`.
-     */
-    private isRetryableAgentError;
-    /**
-     * 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),
@@ -182,6 +165,9 @@ export declare class FeishuBot {
      * session kept working and its new output becomes the latest reply, which we
      * re-check. Loops until the session confirms completion, a reply no longer
      * looks truncated, the budget is spent, or the session cannot answer.
+     *
+     * This is the ONLY auto-retry trigger: a reply that LOOKS UNFINISHED. We do not
+     * retry on transient run errors, and we do not auto-compact-and-retry.
      */
     private autoRetryUntilComplete;
     private cancelDelayedFailure;

package/dist/feishu-bot.js

@@ -29,10 +29,6 @@ function autoRetryMax() { return Number(process.env.OPENCLAW_LARK_MULTI_AGENT_AU
 // for the locale-appropriate phrase; detection accepts BOTH so either works.
 const AUTO_RETRY_DONE_PHRASE = process.env.OPENCLAW_LARK_MULTI_AGENT_AUTO_RETRY_DONE_PHRASE || "\u7ed3\u675f\u4e86";
 const AUTO_RETRY_DONE_PHRASE_EN = process.env.OPENCLAW_LARK_MULTI_AGENT_AUTO_RETRY_DONE_PHRASE_EN || "DONE";
-// When an auto-retry probe errors AND context usage is at/above this percent,
-// auto-compact the session once and keep retrying (instead of giving up). This
-// rescues the “session too heavy → run times out / lock contention” failure mode.
-function autoRetryCompactPct() { return Number(process.env.OPENCLAW_LARK_MULTI_AGENT_AUTO_RETRY_COMPACT_PCT || 50); }
 // How many of the most-recent tool calls (and their results) tool-trim keeps
 // intact — recent tool calls may still be relevant to the agent's next step.
 function toolTrimKeepRecent() { return Number(process.env.OPENCLAW_LARK_MULTI_AGENT_TOOLTRIM_KEEP_RECENT || 3); }
@@ -1248,29 +1244,9 @@ export class FeishuBot {
                     }));
                 }
                 catch (mainErr) {
-                    // The main run failed before returning a reply. If it is a retryable
-                    // error (e.g. a request timeout) and not a session-health failure,
-                    // reuse the SAME auto-retry mechanism to let the session resume from
-                    // where it was interrupted, instead of giving up immediately.
-                    if (mainErr instanceof UnhealthySessionError)
-                        throw mainErr;
-                    const errText = mainErr?.message || String(mainErr);
-                    if (autoRetryEnabled() && !isNativeCommandTrigger && this.isRetryableAgentError(errText)) {
-                        console.warn(`[${this.config.name}] main run failed (${errText.slice(0, 80)}) for ${chatId.slice(-8)}; entering auto-retry`);
-                        reply = await this.autoRetryUntilComplete({
-                            chatId,
-                            sessionKey,
-                            senderName: lastHuman.senderName,
-                            triggerId,
-                            lastHumanMessageId: lastHuman.messageId || "",
-                            isNativeCommandTrigger,
-                            initialError: errText,
-                            liveStatus,
-                        });
-                    }
-                    else {
-                        throw mainErr;
-                    }
+                    // The main run failed before returning a reply. Surface the error; we
+                    // only auto-retry replies that look truncated, not transient run errors.
+                    throw mainErr;
                 }
                 finally {
                     // OpenClaw may emit the final assistant session.message just after
@@ -1671,43 +1647,19 @@ export class FeishuBot {
         return text.startsWith("⚠️ Agent 未正常完成") || /\n原因:\s*rpc\b/.test(text);
     }
     /**
-     * Is this main-run error worth auto-retrying (by resuming the session via the
-     * probe loop)? Mainly transient failures — request/response timeouts and
-     * aborted/incomplete runs. We do NOT auto-retry clearly terminal errors
-     * (auth/permission/quota/billing/model-not-supported), which would just fail
-     * again. The error text comes from collectReply's `Agent error: <msg>`.
-     */
-    isRetryableAgentError(errText) {
-        const t = (errText || "").toLowerCase();
-        // Terminal errors: never auto-retry.
-        if (/(unauthorized|permission|forbidden|invalid api key|quota|billing|insufficient|model_not_supported|not supported|invalid_request)/.test(t))
-            return false;
-        // Retryable: timeouts and transient interruptions.
-        return /(timed out|timeout|aborted|operation was aborted|no response|request failed|temporarily|connection|econnreset|socket hang|stream)/.test(t);
-    }
-    /**
-     * 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();
@@ -1723,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),
@@ -1808,21 +1770,16 @@ export class FeishuBot {
      * session kept working and its new output becomes the latest reply, which we
      * re-check. Loops until the session confirms completion, a reply no longer
      * looks truncated, the budget is spent, or the session cannot answer.
+     *
+     * This is the ONLY auto-retry trigger: a reply that LOOKS UNFINISHED. We do not
+     * retry on transient run errors, and we do not auto-compact-and-retry.
      */
     async autoRetryUntilComplete(params) {
         const { chatId, sessionKey, senderName, triggerId, lastHumanMessageId, isNativeCommandTrigger, liveStatus } = params;
         let reply = params.initialReply ?? "";
-        // Whether we still owe at least one probe regardless of how `reply` looks.
-        // The timeout path starts in this state (no reply to inspect yet).
-        let forceProbe = params.initialError !== undefined && !params.initialReply;
-        if (!autoRetryEnabled() || isNativeCommandTrigger) {
-            if (forceProbe)
-                throw new Error(`Agent error: ${params.initialError}`);
+        if (!autoRetryEnabled() || isNativeCommandTrigger)
             return reply;
-        }
         const maxRetry = autoRetryMax();
-        let compacted = false; // auto-compact at most once per auto-retry round
-        let probedAtLeastOnce = false;
         // 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.
@@ -1832,26 +1789,21 @@ export class FeishuBot {
             // /stop while we were looping: abandon retries and deliver what we have.
             if (wasStopped()) {
                 console.log(`[${this.config.name}] auto-retry: aborted by /stop for ${chatId.slice(-8)}`);
-                if (!reply)
-                    throw new Error(`Agent error: ${params.initialError || "stopped by user"}`);
                 return reply;
             }
-            if (!forceProbe) {
-                const parsed = this.extractBridgeAttachments(reply);
-                const trimmed = parsed.text.trim();
-                // Hard rule: a reply that produced attachments (image/file/doc) is a
-                // finished product — never auto-retry it (and never risk dropping the
-                // bridge attachment marker by replacing `reply` with a probe answer).
-                if (parsed.attachments.length > 0)
-                    return reply;
-                // Only engage for plausibly-successful-but-truncated text. Empty/NO_REPLY
-                // and runtime failures have their own handling upstream.
-                if (!trimmed || trimmed.toUpperCase() === "NO_REPLY" || this.isRuntimeFailureText(trimmed))
-                    return reply;
-                if (!this.looksTruncated(trimmed))
-                    return reply;
-            }
-            forceProbe = false; // consumed; subsequent rounds inspect the probe reply
+            const parsed = this.extractBridgeAttachments(reply);
+            const trimmed = parsed.text.trim();
+            // Hard rule: a reply that produced attachments (image/file/doc) is a
+            // finished product — never auto-retry it (and never risk dropping the
+            // bridge attachment marker by replacing `reply` with a probe answer).
+            if (parsed.attachments.length > 0)
+                return reply;
+            // Only engage for plausibly-successful-but-truncated text. Empty/NO_REPLY
+            // and runtime failures have their own handling upstream.
+            if (!trimmed || trimmed.toUpperCase() === "NO_REPLY" || this.isRuntimeFailureText(trimmed))
+                return reply;
+            if (!this.looksTruncated(trimmed))
+                return reply;
             const en = this.isEn(chatId);
             await liveStatus?.progress(en
                 ? `⚠️ Reply looks incomplete — auto-checking (${attempt}/${maxRetry})…`
@@ -1875,41 +1827,11 @@ export class FeishuBot {
                     includeBridgeAttachmentHint: false,
                     onProgress: (event) => liveStatus?.progress(event),
                 }));
-                probedAtLeastOnce = true;
             }
             catch (err) {
-                // Confirmation round failed (timeout/unhealthy). If the session is heavy
-                // (≥ threshold) and we have not compacted yet this round, auto-compact and
-                // keep retrying — a bloated session is the usual cause of these timeouts.
-                // Otherwise stop looping.
+                // The confirmation round itself failed (timeout/unhealthy). Do not spin:
+                // deliver the existing (truncated-looking) reply as-is.
                 console.warn(`[${this.config.name}] auto-retry probe failed for ${chatId.slice(-8)}:`, this.errorSummary(err));
-                if (!compacted) {
-                    const pct = await this.getContextUsagePercent(sessionKey);
-                    if (pct >= autoRetryCompactPct()) {
-                        const en = this.isEn(chatId);
-                        await liveStatus?.progress(en
-                            ? `🧹 Context is large (${pct}%) and the retry failed — auto-compacting…`
-                            : `🧹 上下文过大（${pct}%）且重试出错，正在自动压缩…`).catch(() => { });
-                        try {
-                            const r = await this.compactWithFallback(sessionKey);
-                            compacted = true; // mark as attempted regardless, to avoid re-compacting in a loop
-                            if (r.compacted) {
-                                console.log(`[${this.config.name}] auto-retry: compacted session (${r.method}${r.detail ? " " + r.detail : ""}) at ${pct}% for ${chatId.slice(-8)}; continuing`);
-                                forceProbe = !reply; // if we still have no reply (timeout path), keep probing
-                                continue; // retry the probe on the now-lighter session
-                            }
-                            // Compact was a no-op; do not spin.
-                            console.warn(`[${this.config.name}] auto-retry: compact was a no-op for ${chatId.slice(-8)} (${r.reason || "no reason"})`);
-                        }
-                        catch (compactErr) {
-                            console.warn(`[${this.config.name}] auto-retry compact failed for ${chatId.slice(-8)}:`, this.errorSummary(compactErr));
-                        }
-                    }
-                }
-                // No reply to fall back to (timeout path) and retries exhausted/failed:
-                // re-throw so the caller surfaces the original failure.
-                if (!reply)
-                    throw (err instanceof Error ? err : new Error(`Agent error: ${params.initialError || "retry failed"}`));
                 return reply;
             }
             const probeText = this.extractBridgeAttachments(probeReply).text.trim();
@@ -1917,31 +1839,20 @@ export class FeishuBot {
             // again. Deliver the latest meaningful output we have.
             if (wasStopped()) {
                 console.log(`[${this.config.name}] auto-retry: aborted by /stop mid-probe for ${chatId.slice(-8)}`);
-                const latest = probeText && probeText.toUpperCase() !== "NO_REPLY" ? probeReply : reply;
-                if (!latest)
-                    throw new Error(`Agent error: ${params.initialError || "stopped by user"}`);
-                return latest;
+                return probeText && probeText.toUpperCase() !== "NO_REPLY" ? probeReply : reply;
             }
             if (!probeText || probeText.toUpperCase() === "NO_REPLY") {
-                if (!reply)
-                    throw new Error(`Agent error: ${params.initialError || "no reply after retry"}`);
                 return reply; // session could not answer; deliver existing result
             }
             if (this.isDonePhrase(probeText)) {
                 console.log(`[${this.config.name}] auto-retry: session confirmed done after ${attempt} check(s) for ${chatId.slice(-8)}`);
-                // On the timeout path we have no original reply; the done confirmation
-                // means the interrupted work actually finished — but we have nothing
-                // user-visible to deliver, so treat it as NO_REPLY rather than fabricate.
-                return reply || "NO_REPLY";
+                return reply;
             }
             // Not done: the session kept working. Its output is the new latest reply.
             console.log(`[${this.config.name}] auto-retry: session continued (attempt ${attempt}) for ${chatId.slice(-8)}`);
             reply = probeReply;
         }
         console.warn(`[${this.config.name}] auto-retry budget (${maxRetry}) spent for ${chatId.slice(-8)}; delivering latest result`);
-        void probedAtLeastOnce;
-        if (!reply)
-            throw new Error(`Agent error: ${params.initialError || "retry budget exhausted"}`);
         return reply;
     }
     cancelDelayedFailure(chatId) {

package/package.json

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