openclaw-lark-multi-agent 1.2.3 → 1.2.5

package/dist/feishu-bot.d.ts

@@ -122,14 +122,6 @@ export declare class FeishuBot {
     private isBridgeControlReply;
     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
@@ -155,46 +147,6 @@ export declare class FeishuBot {
      * A plain “no sentence-ending punctuation” is deliberately NOT sufficient.
      */
     private looksTruncated;
-    /**
-     * Did the model type a tool call as plain text instead of emitting a real
-     * function call? When that happens the visible reply ends with a dangling
-     * invoke / parameter / function_calls tag (with or without the `antml:`
-     * prefix), because the tool-call markup leaked into the text channel and the
-     * tool never actually ran. We detect such a tag anchored at the END of the
-     * message — that dangling tag is the tell-tale Stephen flagged ("如果监测到
-     * 这个结尾，说明 tool call 格式出了问题"). On detection the auto-retry loop
-     * sends an explicit "invoke 格式错了，请重试" probe so the agent re-issues the
-     * tool call correctly rather than the generic done-check.
-     */
-    /**
-     * Did the model serialize a tool call as plain text instead of emitting a real
-     * function call? When that happens, the structured tool-call XML leaks into the
-     * visible text channel and the tool never runs. We must distinguish this from a
-     * reply that merely *mentions* a tag (teaching, quoting, showing an example),
-     * which must NOT trigger a retry. So we require strong STRUCTURAL evidence of a
-     * leaked call, not just any tag at the end:
-     *
-     *   1. The reply must END with a closing `</invoke>` (optionally `antml:`).
-     *      A dangling OPEN tag or a bare `</parameter>`/`<function_calls>` alone is
-     *      not enough — too easy to hit in normal prose.
-     *   2. Somewhere before it there must be a matching `<invoke name="...">` OPEN
-     *      tag — i.e. a whole call block (`<invoke…>…</invoke>`) materialized as
-     *      text. A lone `</invoke>` (e.g. “闭合标签是 </invoke>”) is a mention,
-     *      not a leaked call.
-     *   3. The trailing `</invoke>` must NOT be wrapped in inline code/backticks or
-     *      a fenced code block — those are deliberate examples, not a leak.
-     *
-     * Anchored at the very end because a genuinely leaked call is the LAST thing in
-     * the message (the model stopped right after “emitting” it). This keeps the
-     * trigger tight so we do not retry on normal replies that talk about tags.
-     */
-    private looksLikeBrokenToolCall;
-    /**
-     * Is the tag at `tagIndex` inside an inline-code span (`` `…` ``) or a fenced
-     * code block (```` ``` ````)? Such tags are deliberate examples, not a leaked
-     * tool call, so the broken-tool-call detector must ignore them.
-     */
-    private isTrailingTagInCode;
     /** Current context usage percent for a session (totalTokens / contextTokens),
      *  or 0 if it cannot be determined. Same basis as /status. */
     private getContextUsagePercent;
@@ -222,6 +174,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,18 +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 the previous reply ended with a dangling tool-call tag (the model typed
-// an invoke/tool call as plain text and it never ran), the auto-retry probe
-// explicitly tells the agent its invoke format was broken and to retry, instead
-// of the generic done-check. It still accepts the done phrase if actually done.
-const AUTO_RETRY_BROKEN_TOOL_PROBE = process.env.OPENCLAW_LARK_MULTI_AGENT_AUTO_RETRY_BROKEN_TOOL_PROBE
-    || `刚才的任务是不是没结束，invoke 格式错了，invoke 格式错了，请重试。如果结束了，回复“${AUTO_RETRY_DONE_PHRASE}”。`;
-const AUTO_RETRY_BROKEN_TOOL_PROBE_EN = process.env.OPENCLAW_LARK_MULTI_AGENT_AUTO_RETRY_BROKEN_TOOL_PROBE_EN
-    || `Your last task did not finish — the invoke format was broken, the invoke format was broken, please retry. If it is actually done, reply "${AUTO_RETRY_DONE_PHRASE_EN}".`;
-// 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); }
@@ -1256,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
@@ -1678,21 +1646,6 @@ export class FeishuBot {
     isRuntimeFailureText(text) {
         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
@@ -1733,76 +1686,6 @@ export class FeishuBot {
             return true;
         return false;
     }
-    /**
-     * Did the model type a tool call as plain text instead of emitting a real
-     * function call? When that happens the visible reply ends with a dangling
-     * invoke / parameter / function_calls tag (with or without the `antml:`
-     * prefix), because the tool-call markup leaked into the text channel and the
-     * tool never actually ran. We detect such a tag anchored at the END of the
-     * message — that dangling tag is the tell-tale Stephen flagged ("如果监测到
-     * 这个结尾，说明 tool call 格式出了问题"). On detection the auto-retry loop
-     * sends an explicit "invoke 格式错了，请重试" probe so the agent re-issues the
-     * tool call correctly rather than the generic done-check.
-     */
-    /**
-     * Did the model serialize a tool call as plain text instead of emitting a real
-     * function call? When that happens, the structured tool-call XML leaks into the
-     * visible text channel and the tool never runs. We must distinguish this from a
-     * reply that merely *mentions* a tag (teaching, quoting, showing an example),
-     * which must NOT trigger a retry. So we require strong STRUCTURAL evidence of a
-     * leaked call, not just any tag at the end:
-     *
-     *   1. The reply must END with a closing `</invoke>` (optionally `antml:`).
-     *      A dangling OPEN tag or a bare `</parameter>`/`<function_calls>` alone is
-     *      not enough — too easy to hit in normal prose.
-     *   2. Somewhere before it there must be a matching `<invoke name="...">` OPEN
-     *      tag — i.e. a whole call block (`<invoke…>…</invoke>`) materialized as
-     *      text. A lone `</invoke>` (e.g. “闭合标签是 </invoke>”) is a mention,
-     *      not a leaked call.
-     *   3. The trailing `</invoke>` must NOT be wrapped in inline code/backticks or
-     *      a fenced code block — those are deliberate examples, not a leak.
-     *
-     * Anchored at the very end because a genuinely leaked call is the LAST thing in
-     * the message (the model stopped right after “emitting” it). This keeps the
-     * trigger tight so we do not retry on normal replies that talk about tags.
-     */
-    looksLikeBrokenToolCall(text) {
-        const t = (text || "").trim();
-        if (!t)
-            return false;
-        // (1) Must end with a closing invoke tag (the serialized call's terminator).
-        const closeMatch = /<\/\s*(?:antml:)?invoke\s*>\s*$/i.exec(t);
-        if (!closeMatch)
-            return false;
-        // (3) Reject when that closing tag is fenced or inline-code wrapped (example).
-        if (this.isTrailingTagInCode(t, closeMatch.index))
-            return false;
-        // (2) Require a matching opening `<invoke ...>` before the closer — proof that
-        //     a whole call block leaked, not just a mention of the closing tag.
-        const head = t.slice(0, closeMatch.index);
-        if (!/<\s*(?:antml:)?invoke\b[^>]*>/i.test(head))
-            return false;
-        return true;
-    }
-    /**
-     * Is the tag at `tagIndex` inside an inline-code span (`` `…` ``) or a fenced
-     * code block (```` ``` ````)? Such tags are deliberate examples, not a leaked
-     * tool call, so the broken-tool-call detector must ignore them.
-     */
-    isTrailingTagInCode(text, tagIndex) {
-        const before = text.slice(0, tagIndex);
-        // Fenced block: an odd number of ``` before the tag means we are inside one.
-        const fences = (before.match(/```/g) || []).length;
-        if (fences % 2 === 1)
-            return true;
-        // Inline code: an odd number of unescaped backticks on the tag's own line.
-        const lineStart = before.lastIndexOf("\n") + 1;
-        const lineBefore = before.slice(lineStart);
-        const ticks = (lineBefore.match(/`/g) || []).length;
-        if (ticks % 2 === 1)
-            return true;
-        return false;
-    }
     /** Current context usage percent for a session (totalTokens / contextTokens),
      *  or 0 if it cannot be determined. Same basis as /status. */
     async getContextUsagePercent(sessionKey) {
@@ -1886,77 +1769,50 @@ 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.
         const startStopEpoch = this.stopEpoch.get(chatId) || 0;
         const wasStopped = () => (this.stopEpoch.get(chatId) || 0) !== startStopEpoch;
-        // Set per-iteration when the reply under inspection ended with a dangling
-        // tool-call tag (model typed an invoke as plain text); selects the explicit
-        // "invoke format was broken, retry" probe instead of the generic done-check.
-        let brokenToolCall = false;
         for (let attempt = 1; attempt <= maxRetry; attempt++) {
             // /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;
             }
-            brokenToolCall = false;
-            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;
-                // A dangling invoke/tool-call tag is a strong "tool call leaked as text"
-                // signal — engage even if the generic truncation heuristic would miss it.
-                brokenToolCall = this.looksLikeBrokenToolCall(trimmed);
-                if (!this.looksTruncated(trimmed) && !brokenToolCall)
-                    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
-                ? (brokenToolCall
-                    ? `⚠️ Tool-call format looked broken — asking it to retry (${attempt}/${maxRetry})…`
-                    : `⚠️ Reply looks incomplete — auto-checking (${attempt}/${maxRetry})…`)
-                : (brokenToolCall
-                    ? `⚠️ 工具调用格式疑似出错，正在让它重试（${attempt}/${maxRetry}）…`
-                    : `⚠️ 疑似任务未完成，正在自动重试（${attempt}/${maxRetry}）…`)).catch(() => { });
+                ? `⚠️ Reply looks incomplete — auto-checking (${attempt}/${maxRetry})…`
+                : `⚠️ 疑似任务未完成，正在自动重试（${attempt}/${maxRetry}）…`).catch(() => { });
             // One short line, in the user's own voice (we intentionally do not change
             // senderName). Each locale uses its own done-phrase so the English probe
-            // stays fully English; detection accepts both phrases. When the previous
-            // reply ended with a dangling tool-call tag, send the explicit "invoke
-            // format was broken, retry" probe instead of the generic done-check so the
-            // agent re-issues the tool call correctly.
-            const probe = brokenToolCall
-                ? (en ? AUTO_RETRY_BROKEN_TOOL_PROBE_EN : AUTO_RETRY_BROKEN_TOOL_PROBE)
-                : (en
-                    ? `Is that done? If so just reply "${AUTO_RETRY_DONE_PHRASE_EN}", otherwise keep going.`
-                    : `刚才那个任务结束了吗？结束了就回我“${AUTO_RETRY_DONE_PHRASE}”，没结束就接着做。`);
+            // stays fully English; detection accepts both phrases.
+            const probe = en
+                ? `Is that done? If so just reply "${AUTO_RETRY_DONE_PHRASE_EN}", otherwise keep going.`
+                : `刚才那个任务结束了吗？结束了就回我“${AUTO_RETRY_DONE_PHRASE}”，没结束就接着做。`;
             let probeReply;
             try {
                 probeReply = await this.withSessionHealthMonitor(chatId, lastHumanMessageId, triggerId, this.openclawClient.chatSendWithContext({
@@ -1970,41 +1826,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();
@@ -2012,31 +1838,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.3",
+  "version": "1.2.5",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {