openclaw-lark-multi-agent 1.2.2 → 1.2.4

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,19 +137,24 @@ export declare class FeishuBot {
      * only on cheap text shape here, never on stopReason (the upstream rarely
      * provides one for normal-looking-but-truncated finals).
      */
-    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.
+     * 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 looksLikeBrokenToolCall;
+    private looksTruncated;
     /** Current context usage percent for a session (totalTokens / contextTokens),
      *  or 0 if it cannot be determined. Same basis as /status. */
     private getContextUsagePercent;

package/dist/feishu-bot.js

@@ -29,14 +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.
@@ -75,6 +67,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) */
@@ -1697,43 +1692,38 @@ 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;
-    }
-    /**
-     * 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.
-     */
-    looksLikeBrokenToolCall(text) {
-        const t = (text || "").trim();
-        if (!t)
-            return false;
-        return /<\/?\s*(?:antml:)?(?:invoke|parameter|function_calls)\b[^>]*>\s*$/i.test(t);
+        return false;
     }
     /** Current context usage percent for a session (totalTokens / contextTokens),
      *  or 0 if it cannot be determined. Same basis as /status. */
@@ -1833,12 +1823,19 @@ export class FeishuBot {
         const maxRetry = autoRetryMax();
         let compacted = false; // auto-compact at most once per auto-retry round
         let probedAtLeastOnce = false;
-        // 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;
+        // 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;
         for (let attempt = 1; attempt <= maxRetry; attempt++) {
-            brokenToolCall = false;
+            // /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();
@@ -1851,32 +1848,20 @@ export class FeishuBot {
                 // 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)
+                if (!this.looksTruncated(trimmed))
                     return reply;
             }
             forceProbe = false; // consumed; subsequent rounds inspect the probe 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({
@@ -1928,6 +1913,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"}`);
@@ -3282,6 +3276,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.2",
+  "version": "1.2.4",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {