openclaw-lark-multi-agent 1.4.6 → 1.4.8

package/README.md

@@ -101,18 +101,17 @@ lma install-windows-service
 
 ### Real-time steering
 
-When the agent is mid-run and a new message arrives, the bridge submits it via
-OpenClaw's public `chat.send` API with `queueMode: "steer"`. The RPC
-acknowledgment is provisional: LMA retains its durable pending trigger until a
-matching `session.message` proves transcript commitment/consumption, and only
-then switches Feishu from Typing to Get. Async `error`/`aborted` terminals are
-routed by run id, while unconsumed input remains available for normal queue
-fallback. This replaces the deprecated synchronous plugin primitive whose
-boolean could not represent later runtime rejection.
-
-OpenClaw 2026.8+ no longer requires the bundled `lma-steer` plugin. The
-`install-steer-plugin` command remains temporarily for older installations but
-current LMA releases do not call its private Gateway method.
+When the agent is mid-run and a new message arrives, the bridge calls the
+bundled `lma-steer` plugin. The plugin resolves the active embedded run and only
+returns `steered` after queueing the message into that run. LMA then retains its
+durable pending trigger until a matching `session.message` proves transcript
+commitment/consumption, and only then switches Feishu from Typing to Get.
+
+OpenClaw's public `chat.send { queueMode: "steer" }` returns `started` even when
+a message falls through to a later ordinary run, so LMA does not use that
+ambiguous response as proof of realtime insertion. If the plugin is unavailable,
+there is no active run, or injection is rejected, the message safely stays in
+the normal queue and is never falsely shown as inserted.
 
 Useful CLI commands:
 
@@ -122,7 +121,7 @@ lma doctor
 lma start [config]
 lma init [--state-dir DIR] [--force]
 lma install-systemd [--user|--system] [--state-dir DIR]
-lma install-steer-plugin [--no-force]  # legacy; not needed on OpenClaw 2026.8+
+lma install-steer-plugin [--no-force]  # required for realtime mid-run insertion
 ```
 
 ## Quick start from source
@@ -464,9 +463,11 @@ when that list is non-empty. Exact refs and `provider/*` wildcards are accepted.
 LMA now surfaces a model-policy rejection instead of logging a false “model
 ensured” success.
 
-Mid-run messages use the public `chat.send { queueMode: "steer" }` path. LMA
-keeps the durable trigger until `session.message` confirms consumption; this is
-also the signal for the visible Typing-to-Get transition.
+Mid-run messages use the bundled `lma-steer` plugin because public
+`chat.send { queueMode: "steer" }` cannot distinguish true in-run insertion from
+a later ordinary run. LMA keeps the durable trigger until `session.message`
+confirms consumption; this is also the signal for the visible Typing-to-Get
+transition. Without the plugin, messages remain safely queued.
 
 ## Live status
 

package/README.zh-CN.md

@@ -414,7 +414,7 @@ LMA 以 Gateway protocol 4 为基线，并使用 `openclaw@2026.8.2` 构建和
 
 新版把模型元数据与模型覆盖允许列表分开。如果 `agents.defaults.modelPolicy.allow` 非空，LMA 配置中的每个模型都必须被该列表的精确模型引用或 `provider/*` 通配符允许。遇到拒绝时，LMA 会直接报告 model policy 错误，不再错误记录“模型已确保”。
 
-执行中插入的消息改用公开的 `chat.send { queueMode: "steer" }`。RPC 成功返回只是暂时接受；LMA 会继续保留本地 pending trigger，只有匹配的 `session.message` 确认消息已写入转录并被消费后才清除，同时把飞书标记从 Typing 切换为 Get。异步 `error`/`aborted` 按 runId 投递，未消费的输入仍由普通队列兜底。这样不再依赖无法表达后续异步拒绝的旧同步插件原语。
+执行中插入的消息使用内置 `lma-steer` 插件。插件会解析当前 active embedded run，只有消息确实排入该 run 时才返回 `steered`。LMA 仍会保留本地 pending trigger，直到匹配的 `session.message` 确认消息已写入转录并被消费后才清除，同时把飞书标记从 Typing 切换为 Get。公开的 `chat.send { queueMode: "steer" }` 即使退化为稍后的普通 run 也只返回 `started`，因此不再把它当作实时插入成功的证据。插件不可用、没有 active run 或拒绝插入时，消息会安全保留在普通队列中，不会伪报已插入。
 
 ## Live Status 与最终回复
 

package/dist/cli.js

@@ -206,12 +206,12 @@ function runCapture(cmd, args) {
     }
 }
 /**
- * Install the legacy bundled lma-steer plugin. Current LMA uses OpenClaw's
- * public `chat.send { queueMode: "steer" }` API and does not call this plugin;
- * the command remains only for operators maintaining older LMA deployments.
+ * Install the bundled lma-steer plugin used for observable realtime mid-run
+ * insertion. LMA remains functional without it, but busy messages queue until
+ * the active run completes.
  */
 function cmdInstallSteerPlugin(args) {
-    console.warn("Note: current LMA releases use native chat.send queueMode=steer; this legacy plugin is not required on OpenClaw 2026.8+.");
+    console.warn("Note: lma-steer is required for confirmed realtime mid-run insertion; without it, busy messages remain safely queued.");
     // Default to --force so reinstalling an updated bundled plugin overwrites the
     // previously installed copy. Pass --no-force to keep an existing install.
     const noForce = hasFlag(args, "--no-force");

package/dist/feishu-bot.js

@@ -968,13 +968,6 @@ export class FeishuBot {
                     this.pendingAckMessages.set(chatId, acks);
                     return true;
                 });
-                const previousActiveTarget = this.activeDeliveryTargets.get(chatId);
-                // Install the new Feishu delivery target before admission. OpenClaw may
-                // race from "old run still active" to "dispatch a new run" while
-                // handling queueMode=steer, and that new run can emit events before the
-                // RPC response reaches LMA. Either outcome now routes to this message.
-                const releaseSteerDeliveryTarget = this.setActiveDeliveryTarget(chatId, insertedId, messageId);
-                const provisionalTarget = this.activeDeliveryTargets.get(chatId);
                 const steer = await this.openclawClient.steer(sessionKeyForSteer, steerWrapped, cleanText).catch(() => ({ status: "unavailable" }));
                 if (steer.status === "steered") {
                     if (insertedId > 0) {
@@ -984,39 +977,18 @@ export class FeishuBot {
                                 steer.cancelPending?.();
                         });
                     }
-                    if (provisionalTarget && steer.runId) {
-                        provisionalTarget.runId = steer.runId;
-                        this.bindRunDeliveryTarget(chatId, steer.runId, provisionalTarget);
-                        this.releaseRunDeliveryTargetAfter(chatId, steer.runId, 30 * 60_000);
-                    }
-                    // A steer admission may become an ordinary new run. Keep its run-bound
-                    // reply target long enough for a real tool-heavy run; stale targets are
-                    // harmless because later runIds no longer match.
-                    releaseSteerDeliveryTarget(30 * 60_000);
-                    // RPC acknowledgment is provisional. Keep the durable pending trigger
-                    // until session.message confirms consumption; otherwise the normal
-                    // queue drains it after the current run.
-                    console.log(`[${this.config.name}] Agent busy for ${chatId.slice(-8)}, steer accepted (awaiting transcript consumption): "${cleanText.substring(0, 50)}..."`);
+                    // The plugin confirmed queueing into the existing embedded run. Keep
+                    // that run's original delivery target and retain the durable trigger
+                    // until session.message proves this specific input was consumed.
+                    console.log(`[${this.config.name}] Agent busy for ${chatId.slice(-8)}, plugin steer accepted (awaiting transcript consumption): "${cleanText.substring(0, 50)}..."`);
                     return;
                 }
-                // Native steer was not accepted. Restore the previous run's routing
-                // target and keep the already-created trigger/reaction for normal drain.
+                // Plugin missing/no active run/rejected: keep the durable trigger for
+                // normal queue drain. Never claim that ambiguous native admission was an
+                // in-run insertion.
                 stopWatchingConsumption();
                 if ("cancelPending" in steer)
                     steer.cancelPending?.();
-                const currentTarget = this.activeDeliveryTargets.get(chatId);
-                if (currentTarget && currentTarget.token === provisionalTarget?.token) {
-                    if (currentTarget.timer)
-                        clearTimeout(currentTarget.timer);
-                    this.activeDeliveryTargets.delete(chatId);
-                    if (previousActiveTarget) {
-                        const releaseRestoredTarget = this.setActiveDeliveryTarget(chatId, previousActiveTarget.triggerId, previousActiveTarget.messageId);
-                        const restored = this.activeDeliveryTargets.get(chatId);
-                        if (restored)
-                            restored.liveStatus = previousActiveTarget.liveStatus;
-                        releaseRestoredTarget();
-                    }
-                }
                 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
             }
@@ -1825,9 +1797,10 @@ export class FeishuBot {
     }
     completionSummary(meta, emoji = "✅") {
         const en = meta.locale === "en";
-        return en
+        const core = en
             ? `${emoji} ${meta.toolCalls} tool call${meta.toolCalls === 1 ? "" : "s"} · ⏱ ${meta.elapsed}`
             : `${emoji} 累计${meta.toolCalls} 次工具调用 · ⏱ 耗时${meta.elapsed}`;
+        return meta.model?.trim() ? `${core} · 🧠 ${this.escapeCardText(meta.model.trim())}` : core;
     }
     /** Best-effort terminal cleanup for status-only rows and legacy v1.4.3
      * outbox entries that once targeted the live-status card. */
@@ -2654,6 +2627,7 @@ export class FeishuBot {
             const summary = this.completionSummary({
                 toolCalls: view.toolCalls,
                 elapsed: view.elapsed,
+                model: view.model,
                 locale: en ? "en" : "zh",
             }, statusEmoji);
             return {
@@ -2686,10 +2660,12 @@ export class FeishuBot {
             elements.push({ tag: "markdown", content: en ? "_working…_" : "_正在启动…_" });
         }
         elements.push({ tag: "hr" });
-        // Running/failed status owns timing; model attribution belongs to the final
-        // reply card so the two messages have clear, non-duplicated responsibilities.
-        const footer = en ? `⏱ ${view.elapsed}` : `⏱ 已用 ${view.elapsed}`;
-        elements.push({ tag: "markdown", content: `<font color='grey'>${footer}</font>` });
+        // Keep the active model visible while the run is in progress or failed.
+        // The final reply also keeps model attribution so it remains self-contained.
+        const footerBits = [en ? `⏱ ${view.elapsed}` : `⏱ 已用 ${view.elapsed}`];
+        if (view.model?.trim())
+            footerBits.push(`🧠 ${this.escapeCardText(view.model.trim())}`);
+        elements.push({ tag: "markdown", content: `<font color='grey'>${footerBits.join("  ·  ")}</font>` });
         const template = view.state === "failed" ? "orange" : "blue";
         return {
             schema: "2.0",

package/dist/openclaw-client.d.ts

@@ -137,13 +137,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";

package/dist/openclaw-client.js

@@ -1228,39 +1228,34 @@ export class OpenClawClient {
         return this.rpc("chat.inject", { ...params, sessionKey: this.canonicalSessionKey(params.sessionKey) }, 10000);
     }
     /**
-     * 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.
      */
     async steer(sessionKey, text, displayText) {
         const key = this.canonicalSessionKey(sessionKey);
         try {
-            const res = await this.rpc("chat.send", {
-                sessionKey: key,
-                message: text,
-                queueMode: "steer",
-                deliver: false,
-                idempotencyKey: randomUUID(),
-            }, 10000);
-            const status = res?.status;
-            if (status !== "started" && status !== "in_flight" && status !== "ok") {
+            const res = await this.rpc("lma.steer", { sessionKey: key, text }, 10000);
+            if (res?.status !== "steered") {
+                if (res?.status && res.status !== "no_active_run") {
+                    console.warn(`[OpenClaw] lma.steer ${res.status} for ${key.slice(-8)}`);
+                }
                 return { status: "unavailable" };
             }
-            // This records only a provisional accepted input. Actual success is driven
-            // by handleSteerConsumption after the canonical transcript event arrives.
             const cancelPending = this.registerPendingSteer(key, text, displayText);
-            return {
-                status: "steered",
-                runId: typeof res?.runId === "string" ? res.runId : undefined,
-                cancelPending,
-            };
+            return { status: "steered", cancelPending };
         }
         catch (err) {
-            console.warn(`[OpenClaw] native steer failed for ${key.slice(-8)}: ${err?.message || String(err)}`);
+            const message = err?.message || String(err);
+            console.warn(`[OpenClaw] lma.steer unavailable for ${key.slice(-8)}: ${message}`);
             return { status: "unavailable" };
         }
     }

package/package.json

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

package/plugins/lma-steer/README.md

@@ -1,38 +1,35 @@
-# lma-steer (legacy compatibility plugin)
+# lma-steer
 
-This plugin is retained for older `openclaw-lark-multi-agent` deployments that
-called the private `lma.steer` Gateway method.
+`lma-steer` provides observable mid-run insertion for
+`openclaw-lark-multi-agent`.
 
-Current LMA releases on OpenClaw 2026.8+ do **not** use this plugin. They submit
-mid-run input through the public protocol API:
+OpenClaw's public `chat.send { queueMode: "steer" }` acknowledges admission with
+`started` even when the message falls through to a later ordinary run. That is
+not enough for LMA to tell users whether a message actually entered the active
+run. This plugin resolves the active embedded run and reports one of:
 
-```text
-chat.send { queueMode: "steer" }
-```
+- `steered` — queued into the active embedded run;
+- `no_active_run` — no active embedded run was found;
+- `rejected` — the runtime refused queueing.
 
-The public path owns admission, while LMA retains its durable fallback trigger
-until a matching `session.message` confirms transcript consumption. Only then
-is the Feishu acknowledgement changed from Typing to Get, so provisional
-acceptance and actual model consumption remain distinct.
+LMA treats `steered` as provisional until the matching `session.message`
+confirms transcript consumption. Any other outcome remains in LMA's durable
+normal queue.
 
-## Legacy installation
+## Installation
 
-Only install this plugin when maintaining an older LMA release that explicitly
-requires `lma.steer`:
+Realtime mid-run insertion requires this plugin:
 
 ```bash
 lma install-steer-plugin
 ```
 
-Restart the OpenClaw Gateway after installation. For new deployments, skip this
-step.
+Restart the OpenClaw Gateway after installation. LMA itself remains functional
+without the plugin, but messages received during a run wait safely in the
+normal queue.
 
-## Legacy method
+## Gateway method
 
 - method: `lma.steer`
 - params: `{ sessionKey: string, text: string }`
 - result: `{ status: "steered" | "no_active_run" | "rejected", sessionId?: string }`
-
-Its synchronous `steered` result reflects immediate queue eligibility only; it
-cannot prove later runtime consumption. This limitation is why current LMA uses
-the public native steering path instead.