openclaw-lark-multi-agent 1.2.8 → 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) {

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.8",
+  "version": "1.3.0",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {