openclaw-lark-multi-agent 1.4.7 → 1.4.9

package/dist/live-status.js

@@ -1,3 +1,4 @@
+import { FOREGROUND_WAIT_MS } from "./session-status.js";
 const DEFAULT_DELAY_MS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_DELAY_MS || 800);
 const DEFAULT_MAX_CHARS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_MAX_CHARS || 120);
 // How many recent activity lines to keep in the card content area.
@@ -22,8 +23,11 @@ export class LiveStatusController {
     startedAt = Date.now();
     createTimer;
     tickTimer;
+    refreshBudgetTimer;
     createPromise;
     finalized = false;
+    waitingForResult = false;
+    updatesFrozen = false;
     disabled = false;
     /** Consecutive safeEdit failures. A single transient Feishu error (e.g. card
      *  patch code=2200 "Internal Error") must NOT permanently disable the card:
@@ -42,9 +46,15 @@ export class LiveStatusController {
     }
     get id() { return this.messageId; }
     start(initialDetail) {
-        if (this.disabled || this.finalized || this.createTimer || this.messageId)
+        if (this.disabled || this.finalized || this.updatesFrozen || this.createTimer || this.messageId)
             return;
         this.startedAt = Date.now();
+        this.refreshBudgetTimer = setTimeout(() => {
+            void this.showWaitingForResult(this.opts.locale === "en"
+                ? "Foreground refresh budget reached; background results are still monitored."
+                : "前台刷新时间已到，过程卡停止实时刷新；后台继续接收结果。").catch(err => this.callbacks.warn?.("live status freeze failed", err));
+        }, this.opts.refreshBudgetMs ?? FOREGROUND_WAIT_MS);
+        this.refreshBudgetTimer.unref?.();
         if (initialDetail && initialDetail.trim()) {
             this.pushLine("lifecycle", initialDetail.trim());
         }
@@ -56,6 +66,12 @@ export class LiveStatusController {
     async progress(event) {
         if (this.disabled || this.finalized)
             return;
+        if (this.updatesFrozen) {
+            // Keep only the cheap local counter for the eventual one-time summary.
+            if (typeof event !== "string" && event.kind === "tool" && event.phase === "start")
+                this.toolCallCount++;
+            return;
+        }
         // Card patch has no 20-edit cap (verified against Feishu im.message.patch),
         // so we can show a small rolling window of recent activity: tool start, tool
         // end, and intermediate assistant text each count as one line. We ignore
@@ -96,9 +112,41 @@ export class LiveStatusController {
         else {
             return; // lifecycle ticks: ignore (footer timer already advances)
         }
+        this.waitingForResult = false;
         await this.ensureCreatedNow();
         await this.safeEdit(this.buildView());
     }
+    /** Freeze recurring/progress edits, not the original result observer.
+     * A single final/error summary remains allowed when the real outcome arrives. */
+    async showWaitingForResult(detail) {
+        if (this.disabled || this.finalized || this.updatesFrozen)
+            return;
+        this.updatesFrozen = true;
+        this.waitingForResult = true;
+        this.pushLine("lifecycle", detail);
+        this.stopTimers();
+        if (this.createPromise)
+            await this.createPromise.catch(() => { });
+        this.stopTimers();
+        if (this.messageId && !this.disabled)
+            await this.safeEditFinal(this.buildView());
+    }
+    /** Release only local observation of a now-idle session, without claiming
+     * the previous task succeeded or was aborted. Normal progress is unchanged. */
+    async pauseForUnconfirmedResult(detail, title) {
+        if (this.finalized)
+            return;
+        this.pushLine("lifecycle", detail);
+        this.finalized = true;
+        this.stopTimers();
+        if (this.createPromise)
+            await this.createPromise.catch(() => { });
+        if (!this.messageId || this.disabled)
+            return;
+        const view = this.buildView();
+        view.title = title || (this.opts.locale === "en" ? `${this.opts.botName} result unconfirmed` : `${this.opts.botName} 结果未确认`);
+        await this.safeEditFinal(view);
+    }
     async complete() {
         this.state = "done";
         this.finalized = true;
@@ -205,6 +253,10 @@ export class LiveStatusController {
             this.lines = this.lines.slice(this.lines.length - limit);
     }
     stopTimers() {
+        if (this.refreshBudgetTimer) {
+            clearTimeout(this.refreshBudgetTimer);
+            this.refreshBudgetTimer = undefined;
+        }
         if (this.createTimer) {
             clearTimeout(this.createTimer);
             this.createTimer = undefined;
@@ -244,11 +296,11 @@ export class LiveStatusController {
     }
     /** Refresh the elapsed-time footer periodically even with no new activity. */
     startTicker() {
-        if (this.tickTimer || this.disabled || this.finalized)
+        if (this.tickTimer || this.disabled || this.finalized || this.updatesFrozen)
             return;
         const tickMs = this.opts.tickMs ?? DEFAULT_TICK_MS;
         this.tickTimer = setInterval(() => {
-            if (this.finalized || this.disabled || !this.messageId)
+            if (this.finalized || this.disabled || this.updatesFrozen || !this.messageId)
                 return;
             void this.safeEdit(this.buildView());
         }, tickMs);
@@ -257,7 +309,7 @@ export class LiveStatusController {
     async safeEdit(view, force = false) {
         if (!this.messageId || this.disabled)
             return false;
-        if (!force && this.finalized)
+        if (!force && (this.finalized || this.updatesFrozen))
             return false;
         const sig = this.signature(view);
         if (!force && sig === this.lastSentSignature)
@@ -338,6 +390,8 @@ export class LiveStatusController {
             title = en ? `\u2705 ${this.opts.botName} done` : `\u2705 ${this.opts.botName} \u5df2\u5b8c\u6210`;
         else if (this.state === "failed")
             title = en ? `\u26A0\uFE0F ${this.opts.botName} stopped` : `\u26A0\uFE0F ${this.opts.botName} \u6267\u884c\u4e2d\u65ad`;
+        else if (this.waitingForResult)
+            title = en ? `${this.opts.botName} waiting (card frozen)` : `${this.opts.botName} 等待后续结果（已停止刷新）`;
         else
             title = en ? `${this.opts.botName} is working` : `${this.opts.botName} \u6b63\u5728\u6267\u884c`;
         // On a clean finish (done / NO_REPLY) show only the compact summary. On a

package/dist/openclaw-client.d.ts

@@ -1,3 +1,4 @@
+import { SessionWaitPaused, type SessionRuntimeStatus } from "./session-status.js";
 import { OpenClawConfig } from "./config.js";
 import { ChatMessage } from "./message-store.js";
 export type ProgressEvent = {
@@ -15,6 +16,9 @@ export type ProgressEvent = {
     kind: "lifecycle";
     text: string;
 };
+export declare class InactiveRunObservation extends Error {
+    constructor();
+}
 export type ChatAttachment = {
     type?: string;
     mimeType?: string;
@@ -37,6 +41,8 @@ export declare class OpenClawClient {
     private reconnectDelay;
     private maxReconnectDelay;
     private shouldReconnect;
+    /** Read-only reconciliation for a collector whose plugin reports no active run. */
+    private runStateChecks;
     /** Callbacks for tool events (verbose mode) */
     private toolEventCallbacks;
     private lastToolNamesByItemId;
@@ -102,8 +108,9 @@ export declare class OpenClawClient {
      * Collect agent reply by polling accumulated events.
      * Matches by initial runId OR sessionKey to handle multi-turn tool calling
      * where OpenClaw creates new runIds for each tool-call round.
-     * No aggressive timeout — waits for lifecycle end as the source of truth.
-     * 30-minute safety net only for catastrophic WS disconnection.
+     * Existing event/anchor matching is retained. After 30 minutes of silence,
+     * reconcile the original run instead of aborting or treating a draft as final.
+     * Explicit terminal/error/disconnect paths keep their existing behavior.
      */
     private collectReply;
     /**
@@ -137,13 +144,17 @@ export declare class OpenClawClient {
         label?: string;
     }): Promise<any>;
     /**
-     * Submit a mid-run message through OpenClaw's public atomic steer path.
-     * OpenClaw 2026.8 deprecated the synchronous plugin primitive previously used
-     * by `lma-steer`: its boolean only represented immediate eligibility and could
-     * still be rejected asynchronously. `chat.send queueMode=steer` owns admission
-     * and transcript persistence. LMA still treats the RPC result as provisional;
-     * the Feishu reaction flips to Get only after a matching `session.message`
-     * confirms that the input was committed/consumed.
+     * Submit a mid-run message through the lma-steer plugin.
+     *
+     * OpenClaw's public `chat.send { queueMode: "steer" }` returns `started` even
+     * when it falls through to a later ordinary run; it therefore cannot tell the
+     * bridge whether THIS message entered the active run. The plugin resolves the
+     * active embedded run and reports `steered` only when it actually queued there.
+     * A matching session.message remains the final consumption confirmation.
+     *
+     * If the plugin is missing, stale, or rejects the injection, return unavailable
+     * and let LMA's durable trigger run normally after the current turn. Never use
+     * the ambiguous public admission as a realtime-insertion success signal.
      */
     steer(sessionKey: string, text: string, displayText?: string): Promise<{
         status: "steered" | "unavailable";
@@ -175,6 +186,10 @@ export declare class OpenClawClient {
     /**
      * Get session info (model, tokens, etc.) for status display.
      */
+    /** Stop claiming an exact run's final output after observation has paused. */
+    releasePausedWait(runId: string): void;
+    getSessionRuntimeStatus(sessionKey: string): Promise<SessionRuntimeStatus>;
+    private classifyWaitTimeout;
     getSessionInfo(sessionKey: string): Promise<any>;
     /**
      * Ensure session is using the expected model. If not, patch it back.
@@ -218,6 +233,7 @@ export declare class OpenClawClient {
         /** Called after chat.send RPC succeeds and OpenClaw has accepted the user message. */
         onSubmitted?: (runId: string) => void | Promise<void>;
         onProgress?: (event: ProgressEvent) => void | Promise<void>;
+        onWaitPaused?: (notice: SessionWaitPaused) => void | Promise<void>;
     }): Promise<string>;
     private shouldInjectBridgeAttachmentHint;
     private bridgeAttachmentHint;
@@ -251,6 +267,7 @@ export declare class OpenClawClient {
         /** Called after chat.send RPC succeeds and OpenClaw has accepted the combined message. */
         onSubmitted?: (runId: string) => void | Promise<void>;
         onProgress?: (event: ProgressEvent) => void | Promise<void>;
+        onWaitPaused?: (notice: SessionWaitPaused) => void | Promise<void>;
     }): Promise<string>;
     private formatContextLines;
     private writeContextSyncFile;