openclaw-lark-multi-agent 1.2.7 → 1.3.0

package/dist/feishu-bot.js

@@ -895,11 +895,33 @@ export class FeishuBot {
             const BUSY_TIMEOUT_MS = 1_800_000; // 30 minutes, matches collectReply safety timeout
             const isBusy = busySince > 0 && (Date.now() - busySince) < BUSY_TIMEOUT_MS;
             if (isBusy) {
-                // Queued: show waiting reaction
+                // The agent is mid-run. Instead of only queuing to wait for the current
+                // run to finish, try to STEER this message into the active run so it is
+                // seen at the next tool-call boundary (lets the user nudge/correct a long
+                // run in real time). The lma-steer plugin reports whether it landed.
+                const sessionKeyForSteer = this.getSessionKey(chatId);
+                const steer = await this.openclawClient.steer(sessionKeyForSteer, cleanText).catch(() => ({ status: "unavailable" }));
+                if (steer.status === "steered") {
+                    // Inserted into the active run. Reuse the existing reaction lifecycle:
+                    // mark "Get" (received/inserted); the current run's completion will
+                    // advance it to DONE together with the rest of the batch.
+                    await this.addReaction(messageId, "Get").catch(() => { });
+                    pending.push({ messageId, emoji: "Get", rowId: insertedId });
+                    this.pendingAckMessages.set(chatId, pending);
+                    console.log(`[${this.config.name}] Agent busy for ${chatId.slice(-8)}, STEERED into active run: "${cleanText.substring(0, 50)}..."`);
+                    // The message is already in DB with a pending trigger. Clear that
+                    // trigger so it is NOT re-run as a separate follow-up batch after the
+                    // current run ends — it has already been injected into this run.
+                    if (insertedId > 0)
+                        this.store.clearPendingTrigger(this.config.name, chatId, insertedId);
+                    return;
+                }
+                // Could not steer (no active run raced to idle, rejected, or plugin
+                // unavailable): fall back to the original behavior — queue and wait.
                 await this.addReaction(messageId, "Typing").catch(() => { });
                 pending.push({ messageId, emoji: "Typing", rowId: insertedId });
                 this.pendingAckMessages.set(chatId, pending);
-                console.log(`[${this.config.name}] Agent busy for ${chatId.slice(-8)}, queuing: "${cleanText.substring(0, 50)}..."`);
+                console.log(`[${this.config.name}] Agent busy for ${chatId.slice(-8)} (steer=${steer.status}), queuing: "${cleanText.substring(0, 50)}..."`);
                 return; // Message is in DB, will be picked up when agent finishes
             }
             if (busySince > 0) {
@@ -1119,6 +1141,13 @@ export class FeishuBot {
             const isNativeCommandTrigger = firstIsNative;
             const lastHuman = mergedTriggers[mergedTriggers.length - 1];
             const triggerId = lastHuman.id || 0;
+            // Snapshot the stop generation BEFORE the main run starts. If the user runs
+            // /stop at any point during the main run, handleStopCommand bumps the epoch;
+            // auto-retry compares against this baseline and skips retrying entirely. If
+            // we snapshotted inside auto-retry instead, a /stop that landed during the
+            // main run would already be baked into the baseline and go undetected —
+            // that was the "stop then auto-retry anyway" bug.
+            const runStartStopEpoch = this.stopEpoch.get(chatId) || 0;
             const mergedContent = mergedTriggers.map((m) => m.content).join("\n");
             const mergedTriggerIds = mergedTriggers.map((m) => m.id || 0).filter(Boolean);
             const droppedTriggerIds = droppedMergedTriggers.map((m) => m.id || 0).filter(Boolean);
@@ -1267,6 +1296,7 @@ export class FeishuBot {
                     isNativeCommandTrigger,
                     initialReply: reply,
                     liveStatus,
+                    runStartStopEpoch,
                 });
                 const parsedReply = this.extractBridgeAttachments(reply);
                 const visibleReply = parsedReply.text;
@@ -1780,10 +1810,12 @@ export class FeishuBot {
         if (!autoRetryEnabled() || isNativeCommandTrigger)
             return reply;
         const maxRetry = autoRetryMax();
-        // 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;
+        // Baseline stop generation. Prefer the epoch captured before the main run
+        // (runStartStopEpoch) so a /stop that landed DURING the main run is still
+        // seen here; fall back to the current epoch only if the caller did not pass
+        // one. If the user hit /stop at any point from the main run onward, the
+        // epoch is now past the baseline and we must not auto-retry at all.
+        const startStopEpoch = params.runStartStopEpoch ?? (this.stopEpoch.get(chatId) || 0);
         const wasStopped = () => (this.stopEpoch.get(chatId) || 0) !== startStopEpoch;
         for (let attempt = 1; attempt <= maxRetry; attempt++) {
             // /stop while we were looping: abandon retries and deliver what we have.

package/dist/openclaw-client.d.ts

@@ -116,6 +116,23 @@ export declare class OpenClawClient {
         message: string;
         label?: string;
     }): Promise<any>;
+    /**
+     * Steer a message into the ACTIVE run for a session via the lma-steer plugin's
+     * `lma.steer` gateway method. Unlike a plain new message, this injects the text
+     * at the next tool-call boundary of the run that is currently executing, so the
+     * user can nudge/correct a long run instead of waiting for it to finish.
+     *
+     * Returns a structured status so the bridge can render the right reaction:
+     *  - "steered"       -> queued into the active run (will be seen next boundary)
+     *  - "no_active_run" -> no active run; caller should fall back to normal queueing
+     *  - "rejected"      -> active run refused the injection (compacting/not streaming)
+     *  - "unavailable"   -> the lma-steer plugin/method is not available (e.g. not
+     *                       installed or gateway not restarted); caller falls back.
+     */
+    steer(sessionKey: string, text: string): Promise<{
+        status: "steered" | "no_active_run" | "rejected" | "unavailable";
+        sessionId?: string;
+    }>;
     /**
      * Get session info (model, tokens, etc.) for status display.
      */

package/dist/openclaw-client.js

@@ -920,6 +920,38 @@ export class OpenClawClient {
     async injectAssistantMessage(params) {
         return this.rpc("chat.inject", params, 10000);
     }
+    /**
+     * Steer a message into the ACTIVE run for a session via the lma-steer plugin's
+     * `lma.steer` gateway method. Unlike a plain new message, this injects the text
+     * at the next tool-call boundary of the run that is currently executing, so the
+     * user can nudge/correct a long run instead of waiting for it to finish.
+     *
+     * Returns a structured status so the bridge can render the right reaction:
+     *  - "steered"       -> queued into the active run (will be seen next boundary)
+     *  - "no_active_run" -> no active run; caller should fall back to normal queueing
+     *  - "rejected"      -> active run refused the injection (compacting/not streaming)
+     *  - "unavailable"   -> the lma-steer plugin/method is not available (e.g. not
+     *                       installed or gateway not restarted); caller falls back.
+     */
+    async steer(sessionKey, text) {
+        try {
+            const res = await this.rpc("lma.steer", { sessionKey, text }, 10000);
+            const status = res?.status;
+            if (status === "steered" || status === "no_active_run" || status === "rejected") {
+                return { status, sessionId: typeof res?.sessionId === "string" ? res.sessionId : undefined };
+            }
+            return { status: "unavailable" };
+        }
+        catch (err) {
+            // Unknown method / plugin missing / transient RPC error -> caller falls back
+            // to normal queueing. Never throw into the message path.
+            const msg = err?.message || String(err);
+            if (!/unknown method/i.test(msg)) {
+                console.warn(`[OpenClaw] lma.steer failed for ${sessionKey.slice(-8)}: ${msg}`);
+            }
+            return { status: "unavailable" };
+        }
+    }
     /**
      * Get session info (model, tokens, etc.) for status display.
      */

package/package.json

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