openclaw-lark-multi-agent 1.2.1 → 1.2.3

package/dist/feishu-bot.d.ts

@@ -21,6 +21,9 @@ export declare class FeishuBot {
     private initializedSessions;
     /** Per-chat busy lock: timestamp when became busy (0 = not busy) */
     private busyChats;
+    /** Per-chat "stop" generation counter. Bumped by /stop so any in-flight
+     *  auto-retry loop can detect it was cancelled and stop retrying immediately. */
+    private stopEpoch;
     /** Per-chat pending reply message IDs (to ack with DONE when their trigger is processed) */
     private pendingAckMessages;
     /** Per-chat pending tool message sends (to await before final reply) */
@@ -134,7 +137,64 @@ export declare class FeishuBot {
      * 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?
+     *
+     * 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:
+     *   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.
+     */
     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;
@@ -214,6 +274,34 @@ export declare class FeishuBot {
     private deleteMessageById;
     private replyMessage;
     private extractBridgeAttachments;
+    /**
+     * Locate one bridge-attachment marker in `text` and recover its JSON payload,
+     * tolerating arbitrary corruption of the OPENING tag (lost prefix, or no
+     * opening tag at all). Strategy:
+     *   1. Find a closing tag — the full `</LMA_BRIDGE_ATTACHMENTS>`, or a partial
+     *      suffix of it (e.g. `_BRIDGE_ATTACHMENTS>`, `RIDGE_ATTACHMENTS>`), or the
+     *      `</parameter>` the marker sometimes degrades into.
+     *   2. From just before that closer, brace-match BACKWARDS to the start of the
+     *      JSON value (`{...}` or `[...]`), so the opening marker is irrelevant.
+     *   3. Return the span to strip [start,end) plus the extracted JSON string.
+     * `start` extends left to swallow any leftover opening-marker remnant (so no
+     * `RIDGE_ATTACHMENTS>` text leaks into the visible reply).
+     */
+    private findBridgeAttachmentMarker;
+    /**
+     * Regex matching a trailing remnant of the opening marker `<LMA_BRIDGE_ATTACHMENTS>`
+     * at the END of a string. Built from every suffix of the full marker so that
+     * however many leading characters the model dropped (`_BRIDGE_ATTACHMENTS>`,
+     * `RIDGE_ATTACHMENTS>`, `>` …), the leftover is fully stripped from the visible
+     * text. Trailing `>` and surrounding whitespace are also consumed.
+     */
+    private openMarkerRemnant;
+    /**
+     * Given the index of a closing tag, walk backwards to extract the balanced
+     * JSON value (`{...}` or `[...]`) that ends just before it. Returns the JSON
+     * string and its start offset, or null if no balanced value is found.
+     */
+    private extractJsonBeforeIndex;
     private pushBridgeAttachment;
     private validateBridgeAttachmentPath;
     private inferFeishuFileType;

package/dist/feishu-bot.js

@@ -29,6 +29,14 @@ 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.
@@ -67,6 +75,9 @@ export class FeishuBot {
     initializedSessions = new Set();
     /** Per-chat busy lock: timestamp when became busy (0 = not busy) */
     busyChats = new Map();
+    /** Per-chat "stop" generation counter. Bumped by /stop so any in-flight
+     *  auto-retry loop can detect it was cancelled and stop retrying immediately. */
+    stopEpoch = new Map();
     /** Per-chat pending reply message IDs (to ack with DONE when their trigger is processed) */
     pendingAckMessages = new Map();
     /** Per-chat pending tool message sends (to await before final reply) */
@@ -1689,26 +1700,108 @@ export class FeishuBot {
      * 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?
+     *
+     * 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:
+     *   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.
+     */
     looksTruncated(text) {
         const t = (text || "").trim();
         if (!t)
             return false; // empty/NO_REPLY handled elsewhere
-        // Unbalanced code fence => almost certainly cut off mid-block.
+        // (1) Unbalanced code fence => almost certainly cut off mid-block.
         const fences = (t.match(/```/g) || []).length;
         if (fences % 2 === 1)
             return true;
-        // Ends with an obvious continuation cue (dangling connector / lead-in).
+        // (2a) Trailing clause-joining punctuation: a sentence was left hanging.
         if (/[，,：:、;；]\s*$/u.test(t))
             return true;
-        if (/(接下来|然后|首先|现在我|让我|下一步|let me|now i|next,?|first,?)\s*$/iu.test(t))
+        // (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;
-        // Core signal: ends without any sentence-ending punctuation / closer
-        // (“连句号都没有就感觉没成功”). Accept terminators across languages,
-        // closing brackets/quotes, code fences, and common emoji endings.
-        const endOk = /[。！？.!?…)\]」』】）"'`”’~～—✨✅👍🙏]\s*$/u.test(t)
-            || /```\s*$/.test(t)
-            || /[}\]]\s*$/.test(t);
-        return !endOk;
+        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. */
@@ -1808,7 +1901,24 @@ export class FeishuBot {
         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();
@@ -1821,20 +1931,32 @@ export class FeishuBot {
                 // and runtime failures have their own handling upstream.
                 if (!trimmed || trimmed.toUpperCase() === "NO_REPLY" || this.isRuntimeFailureText(trimmed))
                     return reply;
-                if (!this.looksTruncated(trimmed))
+                // 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 en = this.isEn(chatId);
             await liveStatus?.progress(en
-                ? `⚠️ Reply looks incomplete — auto-checking (${attempt}/${maxRetry})…`
-                : `⚠️ 疑似任务未完成，正在自动重试（${attempt}/${maxRetry}）…`).catch(() => { });
+                ? (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(() => { });
             // 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.
-            const 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. 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}”，没结束就接着做。`);
             let probeReply;
             try {
                 probeReply = await this.withSessionHealthMonitor(chatId, lastHumanMessageId, triggerId, this.openclawClient.chatSendWithContext({
@@ -1886,6 +2008,15 @@ export class FeishuBot {
                 return reply;
             }
             const probeText = this.extractBridgeAttachments(probeReply).text.trim();
+            // /stop landed while the probe was in flight: stop here rather than loop
+            // 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;
+            }
             if (!probeText || probeText.toUpperCase() === "NO_REPLY") {
                 if (!reply)
                     throw new Error(`Agent error: ${params.initialError || "no reply after retry"}`);
@@ -2475,24 +2606,47 @@ export class FeishuBot {
     }
     extractBridgeAttachments(reply) {
         const attachments = [];
-        // Some models occasionally corrupt the attachment marker while preserving
-        // the exact JSON payload: the closing tag can become </parameter>, or the
-        // opening "<LMA" prefix can be truncated leaving "_BRIDGE_ATTACHMENTS>".
-        // Treat these as recoverable shapes; otherwise the marker leaks as
-        // user-visible text and attachments are not sent.
-        const markerPattern = /(?:<LMA_BRIDGE_ATTACHMENTS>|_BRIDGE_ATTACHMENTS>)([\s\S]*?)(?:<\/LMA_BRIDGE_ATTACHMENTS>|<\/parameter>)/g;
-        let text = reply.replace(markerPattern, (_match, jsonText) => {
+        // Models occasionally corrupt the attachment marker. The opening tag is the
+        // least reliable part: we have seen it lose the "<LMA" prefix ("_BRIDGE_…"),
+        // lose even more ("RIDGE_ATTACHMENTS>"), or drop entirely. The closing tag is
+        // far more reliably emitted. So instead of enumerating opening-tag shapes,
+        // anchor on the closer and recover the JSON payload by brace-balancing
+        // backwards from it — robust no matter how many leading chars are dropped.
+        let text = reply;
+        let guard = 0;
+        for (;;) {
+            if (guard++ > 50)
+                break; // safety: never loop unbounded on pathological input
+            const found = this.findBridgeAttachmentMarker(text);
+            if (!found)
+                break;
+            const { start, end, json } = found;
+            let consumed = false;
             try {
-                const parsed = JSON.parse(String(jsonText).trim());
-                const rawAttachments = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.attachments) ? parsed.attachments : [parsed];
+                const parsed = JSON.parse(json);
+                const rawAttachments = Array.isArray(parsed)
+                    ? parsed
+                    : Array.isArray(parsed?.attachments) ? parsed.attachments : [parsed];
+                const before = attachments.length;
                 for (const item of rawAttachments)
                     this.pushBridgeAttachment(attachments, item);
+                // Only strip the span if it actually yielded at least one attachment;
+                // otherwise leave the text alone rather than eat unrelated content.
+                consumed = attachments.length > before;
             }
             catch (err) {
                 console.warn(`[${this.config.name}] Failed to parse bridge attachment marker:`, err.message);
             }
-            return "";
-        });
+            if (consumed) {
+                text = (text.slice(0, start) + text.slice(end)).replace(/[^\S\n]+\n/g, "\n");
+            }
+            else {
+                // Could not use this span; blank it out so we do not re-find it forever,
+                // but keep scanning in case another valid marker exists earlier.
+                text = text.slice(0, start) + text.slice(end);
+            }
+        }
+        text = text.trim();
         // Compatibility fallback for agents that use OpenClaw's channel directive
         // syntax instead of the LMA marker. In Feishu/LMA, leaving MEDIA:<path> in
         // plain text only shows the path, so parse it into bridge attachments.
@@ -2507,6 +2661,111 @@ export class FeishuBot {
         }).trim();
         return { text, attachments };
     }
+    /**
+     * Locate one bridge-attachment marker in `text` and recover its JSON payload,
+     * tolerating arbitrary corruption of the OPENING tag (lost prefix, or no
+     * opening tag at all). Strategy:
+     *   1. Find a closing tag — the full `</LMA_BRIDGE_ATTACHMENTS>`, or a partial
+     *      suffix of it (e.g. `_BRIDGE_ATTACHMENTS>`, `RIDGE_ATTACHMENTS>`), or the
+     *      `</parameter>` the marker sometimes degrades into.
+     *   2. From just before that closer, brace-match BACKWARDS to the start of the
+     *      JSON value (`{...}` or `[...]`), so the opening marker is irrelevant.
+     *   3. Return the span to strip [start,end) plus the extracted JSON string.
+     * `start` extends left to swallow any leftover opening-marker remnant (so no
+     * `RIDGE_ATTACHMENTS>` text leaks into the visible reply).
+     */
+    findBridgeAttachmentMarker(text) {
+        // Closing-tag candidates, longest/most-specific first. We accept partial
+        // suffixes of the real closing tag because the opening corruption pattern
+        // (dropped leading chars) also happens to the closer.
+        const closeRe = /<\/LMA_BRIDGE_ATTACHMENTS>|[A-Z_]*BRIDGE_ATTACHMENTS>\s*<\/LMA_BRIDGE_ATTACHMENTS>|<\/parameter>/g;
+        // The JSON sits between an (often corrupted) opener and the closer. Find the
+        // closer first, then walk back to the JSON. Prefer the canonical closer.
+        const closers = [];
+        const canonical = /<\/LMA_BRIDGE_ATTACHMENTS>/g;
+        let m;
+        while ((m = canonical.exec(text)))
+            closers.push({ idx: m.index, len: m[0].length });
+        if (closers.length === 0) {
+            // Degraded closer: `</parameter>` immediately after the JSON payload.
+            const param = /<\/parameter>/g;
+            while ((m = param.exec(text)))
+                closers.push({ idx: m.index, len: m[0].length });
+        }
+        void closeRe; // (kept for documentation of accepted shapes)
+        for (const c of closers) {
+            const json = this.extractJsonBeforeIndex(text, c.idx);
+            if (!json)
+                continue;
+            // Extend `start` left over any opening-marker remnant + surrounding space,
+            // so the visible text does not keep a dangling `RIDGE_ATTACHMENTS>` etc.
+            // The remnant is always some trailing SUFFIX of `<LMA_BRIDGE_ATTACHMENTS>`
+            // (corruption drops leading chars), so match any such suffix.
+            let start = json.start;
+            const lead = text.slice(Math.max(0, start - 48), start);
+            const leadMarker = this.openMarkerRemnant().exec(lead);
+            if (leadMarker)
+                start = Math.max(0, start - (lead.length - leadMarker.index));
+            return { start, end: c.idx + c.len, json: json.text };
+        }
+        return null;
+    }
+    /**
+     * Regex matching a trailing remnant of the opening marker `<LMA_BRIDGE_ATTACHMENTS>`
+     * at the END of a string. Built from every suffix of the full marker so that
+     * however many leading characters the model dropped (`_BRIDGE_ATTACHMENTS>`,
+     * `RIDGE_ATTACHMENTS>`, `>` …), the leftover is fully stripped from the visible
+     * text. Trailing `>` and surrounding whitespace are also consumed.
+     */
+    openMarkerRemnant() {
+        const full = "<LMA_BRIDGE_ATTACHMENTS>";
+        const suffixes = [];
+        for (let i = 0; i < full.length; i++)
+            suffixes.push(full.slice(i).replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+        // Longest suffixes first so the regex prefers the most complete remnant.
+        return new RegExp(`(?:${suffixes.join("|")})\\s*$`);
+    }
+    /**
+     * Given the index of a closing tag, walk backwards to extract the balanced
+     * JSON value (`{...}` or `[...]`) that ends just before it. Returns the JSON
+     * string and its start offset, or null if no balanced value is found.
+     */
+    extractJsonBeforeIndex(text, closeIdx) {
+        // Skip whitespace immediately before the closer.
+        let end = closeIdx;
+        while (end > 0 && /\s/.test(text[end - 1]))
+            end--;
+        if (end === 0)
+            return null;
+        const lastChar = text[end - 1];
+        const open = lastChar === "}" ? "{" : lastChar === "]" ? "[" : null;
+        if (!open)
+            return null;
+        const close = lastChar;
+        // Brace-balance backwards, ignoring braces inside strings.
+        let depth = 0;
+        let inStr = false;
+        for (let i = end - 1; i >= 0; i--) {
+            const ch = text[i];
+            if (inStr) {
+                if (ch === '"' && text[i - 1] !== "\\")
+                    inStr = false;
+                continue;
+            }
+            if (ch === '"') {
+                inStr = true;
+                continue;
+            }
+            if (ch === close)
+                depth++;
+            else if (ch === open) {
+                depth--;
+                if (depth === 0)
+                    return { text: text.slice(i, end), start: i };
+            }
+        }
+        return null;
+    }
     pushBridgeAttachment(attachments, item) {
         if (!item || typeof item.path !== "string")
             return;
@@ -3112,6 +3371,9 @@ export class FeishuBot {
     async handleStopCommand(chatId, messageId) {
         const sessionKey = this.getSessionKey(chatId);
         try {
+            // Bump the stop generation FIRST so any in-flight auto-retry loop sees the
+            // cancellation on its next iteration and stops retrying immediately.
+            this.stopEpoch.set(chatId, (this.stopEpoch.get(chatId) || 0) + 1);
             // Abort all active runs for this session (chat.abort with no runId).
             await this.openclawClient.abortChat(sessionKey).catch(() => { });
             // Force-unlock the busy gate so queued messages can be processed.

package/package.json

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