openclaw-lark-multi-agent 1.4.9 → 1.4.10

package/dist/feishu-bot.js

@@ -1388,7 +1388,10 @@ export class FeishuBot {
                         onProgress: (event) => liveStatus?.progress(event),
                         onWaitPaused: async (notice) => {
                             await liveStatus?.showWaitingForResult(notice.message);
-                            if (Date.now() - (this.lastRealDeliveryAt.get(chatId) || 0) >= 5000)
+                            // Yield is a confirmed handoff, not the timeout heuristic. A
+                            // recent unrelated reply must not suppress this turn's notice.
+                            if (notice.reason === "yield" ? !this.store.hasDeliveredReply(this.config.name, chatId, triggerId)
+                                : Date.now() - (this.lastRealDeliveryAt.get(chatId) || 0) >= 5000)
                                 await this.sendWaitPaused(chatId, triggerId, lastHuman.messageId, notice);
                         },
                     }));

package/dist/openclaw-client.js

@@ -231,7 +231,9 @@ export class OpenClawClient {
                             this.agentEvents.get(sk).push({
                                 ...frame.payload,
                                 stream: "chatFinal",
-                                data: { text: textParts.join("\n") },
+                                // Only the Gateway chat-final envelope confirms a handoff.
+                                // Never infer it from tool names, arguments or raw tool output.
+                                data: { text: textParts.join("\n"), gatewayYielded: frame.payload?.yielded === true },
                             });
                         }
                         else if (state === "error") {
@@ -467,6 +469,11 @@ export class OpenClawClient {
     /** Render protocol-4 structured tool args/results without `[object Object]`.
      * Prefer useful, non-secret fields and keep the fallback bounded. */
     formatToolValue(value, toolName, phase) {
+        // sessions_yield.message is private resumed context. Do not mirror its
+        // arguments/results (including JSON strings) into process cards or verbose
+        // tool replies. This is redaction only, never evidence of a handoff.
+        if (toolName === "sessions_yield")
+            return "";
         if (value === null || value === undefined || value === "")
             return "";
         if (typeof value === "string")
@@ -704,7 +711,7 @@ export class OpenClawClient {
      */
     collectReply(runId, timeoutMs = FOREGROUND_WAIT_MS, targetSessionKey, options) {
         let cleanupObservation = () => { };
-        return new Promise((resolve, reject) => {
+        return new Promise((resolveResult, rejectResult) => {
             // Whether we were connected when the run started. We only treat a later
             // disconnect as a mid-run gateway drop (fail fast) if we began connected;
             // this keeps unit tests that drive collectReply without a live socket from
@@ -713,6 +720,7 @@ export class OpenClawClient {
             let text = "";
             let chatDeltaText = "";
             let chatFinalText = "";
+            let chatFinalSeen = false;
             let transcriptAssistantText = "";
             let sessionKey = targetSessionKey ? `agent:main:${targetSessionKey.replace(/^agent:[^:]+:/, "")}` : "";
             let shortSessionKey = targetSessionKey ? targetSessionKey.replace(/^agent:[^:]+:/, "") : "";
@@ -739,12 +747,18 @@ export class OpenClawClient {
             };
             let idleTimer;
             let observationClosed = false;
+            // Close synchronously: a deferred yield notice must not overtake a final
+            // or error just because Promise.finally cleanup has not run yet.
+            const resolve = (value) => { observationClosed = true; resolveResult(value); };
+            const reject = (error) => { observationClosed = true; rejectResult(error); };
             let checkingState = false;
             let lastStateCheckAt = -Infinity;
             let quietNotified = false;
             let decidingTimeout = false;
             let waitNoticeSent = false;
             let foregroundPaused = false;
+            let foregroundYielded = false;
+            let turnYielded = false;
             let foregroundWaitTimer;
             const handleTimeoutResult = async (error) => {
                 if (observationClosed)
@@ -982,6 +996,16 @@ export class OpenClawClient {
                             }
                             continue;
                         }
+                        // After handoff, an unowned new run (including requester-settle)
+                        // retains its existing proactive delivery route. A session/lifecycle
+                        // start alone must not turn it into the old run's final. Discussion's
+                        // transcript mute marks scheduler-owned collection; retain its existing
+                        // anchored collector path rather than changing discussion routing.
+                        if (eventSessionMatches && foregroundYielded && evRunId && !matchesRun
+                            && !this.mutedProactiveSessions.has(sessionKey) && !this.mutedProactiveSessions.has(shortSessionKey)) {
+                            bucket.splice(i, 1);
+                            continue;
+                        }
                         if (eventSessionMatches && expectedUserText && !anchorSeen && !matchesRun) {
                             bucket.splice(i, 1);
                             preAnchorEvents.push(ev);
@@ -1035,6 +1059,10 @@ export class OpenClawClient {
                         if (ev.stream !== "lifecycle") {
                             pendingRuntimeFailureText = "";
                         }
+                        // A matched resumed turn can again complete via the existing
+                        // assistant/transcript + lifecycle path, even without chat final.
+                        if (ev.stream === "lifecycle" && ev.data?.phase === "start")
+                            turnYielded = false;
                         if (ev.stream === "lifecycle" && ev.data?.phase === "start" && !lifecycleStartedLogged) {
                             lifecycleStartedLogged = true;
                             console.log(`[OpenClaw] lifecycle start for runId=${runId} after ${Date.now() - collectStartedAt}ms`);
@@ -1067,17 +1095,48 @@ export class OpenClawClient {
                             }
                         }
                         if (ev.stream === "chatFinal") {
+                            chatFinalSeen = true;
+                            if (ev.data?.gatewayYielded === true) {
+                                // A yielded turn is not a terminal answer, even if its buffered
+                                // message contains a preface. Preserve the collector/queue owner
+                                // and final-delivery key; only pause foreground presentation.
+                                if (chatFinalText.trim())
+                                    continue; // an actual final wins
+                                foregroundYielded = true;
+                                turnYielded = true;
+                                text = chatDeltaText = transcriptAssistantText = "";
+                                if (chatFinalTimer) {
+                                    clearTimeout(chatFinalTimer);
+                                    chatFinalTimer = null;
+                                }
+                                if (lifecycleEndTimer) {
+                                    clearTimeout(lifecycleEndTimer);
+                                    lifecycleEndTimer = null;
+                                }
+                                // Finish scanning this batch first so an already-arrived real
+                                // final/error wins over a stale waiting notice. No status RPC
+                                // (or ten-minute budget) is needed to confirm this wire fact.
+                                if (options?.onWaitPaused)
+                                    void Promise.resolve().then(() => handleTimeoutResult(new SessionWaitPaused(normalizeSessionRuntimeStatus(undefined), false, "yield")));
+                                continue;
+                            }
                             chatFinalText = ev.data?.text || "";
+                            if (chatFinalText.trim())
+                                turnYielded = false;
+                            else if (turnYielded)
+                                continue;
                             // Fallback: if lifecycle end doesn't arrive within 5s, resolve
                             if (!chatFinalTimer) {
                                 chatFinalTimer = setTimeout(() => {
                                     console.warn(`[OpenClaw] collectReply: lifecycle end missing, using chatFinal fallback`);
-                                    this.abortChat(targetSessionKey || sessionKey, runId).catch((err) => {
-                                        console.warn(`[OpenClaw] abort after chatFinal fallback failed:`, err.message);
-                                    });
                                     // Prefer final chat message over accumulated deltas: some providers may
                                     // emit only partial deltas (e.g. "N") while final contains "NO_REPLY".
                                     const latestFinalText = this.pickBestCollectedText(chatFinalText, text, chatDeltaText, transcriptAssistantText);
+                                    // Never abort a yielded original run, nor an empty final.
+                                    if (!foregroundYielded && latestFinalText)
+                                        this.abortChat(targetSessionKey || sessionKey, runId).catch((err) => {
+                                            console.warn(`[OpenClaw] abort after chatFinal fallback failed:`, err.message);
+                                        });
                                     if (latestFinalText) {
                                         finish(latestFinalText);
                                     }
@@ -1092,6 +1151,11 @@ export class OpenClawClient {
                             }
                         }
                         if (ev.stream === "lifecycle" && ev.data?.phase === "end") {
+                            // paused/end_turn can beat the confirming chat event, including
+                            // discussion's emptyFinalAsNoReply path. It is neither success
+                            // nor failure and alone does NOT authorize a handoff notice.
+                            if (!chatFinalText.trim() && (turnYielded || (ev.data?.livenessState === "paused" && ev.data?.stopReason === "end_turn")))
+                                continue;
                             // Prefer final chat message over accumulated deltas: some providers may
                             // emit only partial deltas (e.g. "N") while final contains "NO_REPLY".
                             const finalText = this.pickBestCollectedText(chatFinalText, text, chatDeltaText, transcriptAssistantText);
@@ -1143,7 +1207,12 @@ export class OpenClawClient {
                             };
                             // If lifecycle end beats chat final, a short delta like "N" can be a truncated
                             // final reply. Wait for chatFinal before resolving; otherwise suppress lone "N".
-                            if (!options?.emptyFinalAsNoReply && ev.data?.livenessState === "working" && !chatFinalText && text.length <= 1) {
+                            if ((!options?.emptyFinalAsNoReply && ev.data?.livenessState === "working" && !chatFinalText && text.length <= 1)
+                                || (options?.emptyFinalAsNoReply && !chatFinalSeen && !finalText)) {
+                                // A lifecycle-only empty discussion end also needs this small
+                                // window for a confirming yielded chat final, not instant NO_REPLY.
+                                if (lifecycleEndTimer)
+                                    clearTimeout(lifecycleEndTimer);
                                 lifecycleEndTimer = setTimeout(finishFromLifecycle, 5000);
                             }
                             else {

package/dist/session-status.d.ts

@@ -11,8 +11,9 @@ export declare const isWaitTimeout: (text: string) => boolean;
 export declare function normalizeSessionRuntimeStatus(value: any): SessionRuntimeStatus;
 /** Compact presentation only; never replaces the actual status/model values. */
 export declare function formatSessionFooter(snapshot: SessionRuntimeStatus): string;
-/** Local observation has ended, NOT an assertion that execution failed. */
+/** Foreground waiting paused, NOT an assertion that execution ended. */
 export declare class SessionWaitPaused extends Error {
     readonly snapshot: SessionRuntimeStatus;
-    constructor(snapshot: SessionRuntimeStatus, reportedTimeout?: boolean);
+    readonly reason: "timeout" | "yield";
+    constructor(snapshot: SessionRuntimeStatus, reportedTimeout?: boolean, reason?: "timeout" | "yield");
 }

package/dist/session-status.js

@@ -26,14 +26,18 @@ export function formatSessionFooter(snapshot) {
     const limitK = limit === undefined ? "?" : Math.max(1, Math.round(limit / 1000));
     return `${snapshot.status} · ${usedK}K/${limitK}K`;
 }
-/** Local observation has ended, NOT an assertion that execution failed. */
+/** Foreground waiting paused, NOT an assertion that execution ended. */
 export class SessionWaitPaused extends Error {
     snapshot;
-    constructor(snapshot, reportedTimeout = false) {
-        super(reportedTimeout
-            ? "⏳ 本轮返回了超时，LMA 已暂停本次等待，但不据此认定整个会话已经结束。会话状态见下方；你可以继续等待后续结果。"
-            : "⏳ 本次等待时间已到，LMA 暂停本轮等待，先返回会话状态供你判断。\n没有因此停止运行或自动重发本次请求；你可以继续等待后续结果。");
+    reason;
+    constructor(snapshot, reportedTimeout = false, reason = "timeout") {
+        super(reason === "yield"
+            ? "⏳ 本轮已转入后台等待；若有后续结果，将继续在此回复。未发送停止请求，也未自动重发请求。"
+            : reportedTimeout
+                ? "⏳ 本轮返回了超时，LMA 已暂停本次等待，但不据此认定整个会话已经结束。会话状态见下方；你可以继续等待后续结果。"
+                : "⏳ 本次等待时间已到，LMA 暂停本轮等待，先返回会话状态供你判断。\n没有因此停止运行或自动重发本次请求；你可以继续等待后续结果。");
         this.snapshot = snapshot;
+        this.reason = reason;
         this.name = "SessionWaitPaused";
     }
 }

package/package.json

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