openclaw-lark-multi-agent 1.0.21 → 1.0.23

package/dist/live-status.d.ts

@@ -0,0 +1,56 @@
+import type { ProgressEvent } from "./openclaw-client";
+export type LiveStatusCallbacks = {
+    create: (text: string) => Promise<string | undefined>;
+    edit: (messageId: string, text: string) => Promise<void>;
+    warn?: (message: string, err?: unknown) => void;
+};
+export type LiveStatusOptions = {
+    botName: string;
+    locale?: "zh" | "en";
+    delayMs?: number;
+    maxChars?: number;
+    maxEdits?: number;
+    disableHint?: string;
+};
+export declare class LiveStatusController {
+    private readonly callbacks;
+    private readonly opts;
+    private messageId?;
+    private lastSentText;
+    private detail;
+    /** Number of edits already issued against the live message (excludes create). */
+    private editCount;
+    private createTimer?;
+    private createPromise?;
+    private finalized;
+    private disabled;
+    /** True after the running-state budget is spent; future progress is ignored. */
+    private runningLimitReached;
+    constructor(callbacks: LiveStatusCallbacks, opts: LiveStatusOptions);
+    get id(): string | undefined;
+    start(initialDetail?: string): void;
+    progress(event: ProgressEvent | string): Promise<void>;
+    /**
+     * Finish the live status when the real (final) reply is delivered separately.
+     * The final answer is sent by the normal interactive-card path, so the status
+     * message must NOT be overwritten with the answer (text type does not render
+     * Markdown). Feishu renders message deletion as a visible "recalled a message"
+     * tombstone, so keep the status message and mark it done instead.
+     */
+    complete(): Promise<void>;
+    /**
+     * Finish the live status when the run failed and the error is delivered by the
+     * normal path. Use a neutral/negative marker so it does not contradict the
+     * separately delivered error message.
+     */
+    fail(): Promise<void>;
+    dispose(): void;
+    private stopTimers;
+    private ensureCreatedNow;
+    private ensureCreated;
+    private editRunningStatus;
+    private safeEdit;
+    private formatToolStart;
+    private formatStatus;
+    private formatLimitNotice;
+}

package/dist/live-status.js

@@ -0,0 +1,184 @@
+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);
+// Feishu caps a single message at 20 edits (code=230072 once exhausted). Keep the
+// final edit for the completion marker; running-state updates may consume at most
+// maxEdits - 1, with the last running edit reserved for an explicit limit notice.
+const DEFAULT_MAX_EDITS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_MAX_EDITS || 20);
+export class LiveStatusController {
+    callbacks;
+    opts;
+    messageId;
+    lastSentText = "";
+    detail = "";
+    /** Number of edits already issued against the live message (excludes create). */
+    editCount = 0;
+    createTimer;
+    createPromise;
+    finalized = false;
+    disabled = false;
+    /** True after the running-state budget is spent; future progress is ignored. */
+    runningLimitReached = false;
+    constructor(callbacks, opts) {
+        this.callbacks = callbacks;
+        this.opts = opts;
+    }
+    get id() { return this.messageId; }
+    start(initialDetail) {
+        if (this.disabled || this.finalized || this.createTimer || this.messageId)
+            return;
+        this.detail = initialDetail || "";
+        this.createTimer = setTimeout(() => {
+            this.createTimer = undefined;
+            this.createPromise = this.ensureCreated();
+        }, this.opts.delayMs ?? DEFAULT_DELAY_MS);
+    }
+    async progress(event) {
+        if (this.disabled || this.finalized || this.runningLimitReached)
+            return;
+        // Only tool-call start is meaningful enough to spend one of Feishu's limited
+        // edit slots. Ignore verbose assistant notes, lifecycle ticks, tool end, and
+        // tool error; the final/error answer is delivered by the normal message path.
+        if (typeof event !== "string") {
+            if (event.kind !== "tool" || event.phase !== "start")
+                return;
+            this.detail = this.formatToolStart(event);
+        }
+        else {
+            // String progress is kept for tests/backwards compatibility, but in normal
+            // runtime OpenClaw progress is structured and only tool start passes above.
+            this.detail = event.trim();
+        }
+        if (!this.detail)
+            return;
+        await this.ensureCreatedNow();
+        await this.editRunningStatus();
+    }
+    /**
+     * Finish the live status when the real (final) reply is delivered separately.
+     * The final answer is sent by the normal interactive-card path, so the status
+     * message must NOT be overwritten with the answer (text type does not render
+     * Markdown). Feishu renders message deletion as a visible "recalled a message"
+     * tombstone, so keep the status message and mark it done instead.
+     */
+    async complete() {
+        this.finalized = true;
+        this.stopTimers();
+        if (this.createPromise)
+            await this.createPromise.catch(() => { });
+        if (!this.messageId || this.disabled)
+            return;
+        const doneText = this.opts.locale === "en"
+            ? `\u2705 ${this.opts.botName} done`
+            : `\u2705 ${this.opts.botName} \u5df2\u5b8c\u6210`;
+        await this.safeEdit(doneText, true);
+    }
+    /**
+     * Finish the live status when the run failed and the error is delivered by the
+     * normal path. Use a neutral/negative marker so it does not contradict the
+     * separately delivered error message.
+     */
+    async fail() {
+        this.finalized = true;
+        this.stopTimers();
+        if (this.createPromise)
+            await this.createPromise.catch(() => { });
+        if (!this.messageId || this.disabled)
+            return;
+        const failedText = this.opts.locale === "en"
+            ? `\u26A0\uFE0F ${this.opts.botName} stopped`
+            : `\u26A0\uFE0F ${this.opts.botName} \u6267\u884c\u4e2d\u65ad`;
+        await this.safeEdit(failedText, true);
+    }
+    dispose() {
+        this.finalized = true;
+        this.stopTimers();
+    }
+    stopTimers() {
+        if (this.createTimer) {
+            clearTimeout(this.createTimer);
+            this.createTimer = undefined;
+        }
+    }
+    async ensureCreatedNow() {
+        if (this.createTimer) {
+            clearTimeout(this.createTimer);
+            this.createTimer = undefined;
+            this.createPromise = this.ensureCreated();
+        }
+        if (this.createPromise)
+            await this.createPromise.catch(() => { });
+    }
+    async ensureCreated() {
+        if (this.disabled || this.finalized || this.messageId)
+            return;
+        const text = this.formatStatus(true);
+        try {
+            const id = await this.callbacks.create(text);
+            if (!id) {
+                this.disabled = true;
+                return;
+            }
+            this.messageId = id;
+            this.lastSentText = text;
+        }
+        catch (err) {
+            this.disabled = true;
+            this.callbacks.warn?.("live status create failed", err);
+        }
+    }
+    async editRunningStatus() {
+        if (!this.messageId || this.disabled || this.finalized || this.runningLimitReached)
+            return;
+        const maxEdits = this.opts.maxEdits ?? DEFAULT_MAX_EDITS;
+        const runningBudget = Math.max(0, maxEdits - 1); // reserve final edit for complete()
+        if (this.editCount >= runningBudget)
+            return;
+        const isLimitNotice = this.editCount === runningBudget - 1;
+        const text = isLimitNotice ? this.formatLimitNotice() : this.formatStatus();
+        const ok = await this.safeEdit(text);
+        if (ok && isLimitNotice)
+            this.runningLimitReached = true;
+    }
+    async safeEdit(text, force = false) {
+        if (!this.messageId || this.disabled)
+            return false;
+        if (!force && this.finalized)
+            return false;
+        if (!force && text === this.lastSentText)
+            return true;
+        try {
+            await this.callbacks.edit(this.messageId, text);
+            this.lastSentText = text;
+            this.editCount++;
+            return true;
+        }
+        catch (err) {
+            this.disabled = true;
+            this.stopTimers();
+            this.callbacks.warn?.("live status edit failed", err);
+            return false;
+        }
+    }
+    formatToolStart(event) {
+        const raw = event.text || event.name || "";
+        const prefix = `${event.name} start`;
+        let detail = raw.startsWith(prefix) ? raw.slice(prefix.length).trim() : raw.trim();
+        if (detail.startsWith(":"))
+            detail = detail.slice(1).trim();
+        return detail ? `${event.name}: ${detail}` : event.name;
+    }
+    formatStatus(includeDisableHint = false) {
+        const maxChars = this.opts.maxChars ?? DEFAULT_MAX_CHARS;
+        const clean = (this.detail || "").replace(/\s+/g, " ").trim();
+        const clipped = clean.length > maxChars ? `${clean.slice(0, Math.max(0, maxChars - 1))}\u2026` : clean;
+        const base = !clipped
+            ? (this.opts.locale === "en" ? `${this.opts.botName} is working` : `${this.opts.botName} \u6b63\u5728\u6267\u884c`)
+            : (this.opts.locale === "en" ? `${this.opts.botName} is working: ${clipped}` : `${this.opts.botName} \u6b63\u5728\u6267\u884c\uff1a${clipped}`);
+        return includeDisableHint && this.opts.disableHint ? `${base}\n${this.opts.disableHint}` : base;
+    }
+    formatLimitNotice() {
+        return this.opts.locale === "en"
+            ? `${this.opts.botName} reached the update limit and is still running`
+            : `${this.opts.botName} \u5df2\u8fbe\u66f4\u65b0\u9650\u5236\uff0c\u6b63\u5728\u6301\u7eed\u6267\u884c\u4e2d`;
+    }
+}

package/dist/message-store.d.ts

@@ -70,6 +70,12 @@ export declare class MessageStore {
     enqueueDelivery(item: Omit<DeliveryOutboxItem, "id" | "status" | "attempts" | "createdAt" | "updatedAt">): number | null;
     getDeliveryBySource(sessionKey: string, sourceType: string, sourceId: string): DeliveryOutboxItem | null;
     getPendingDeliveries(chatId?: string, botName?: string, maxCount?: number): DeliveryOutboxItem[];
+    markBotSeenInChat(botName: string, chatId: string): void;
+    hasBotSeenInChat(botName: string, chatId: string): boolean;
+    markBotUnavailableInChat(botName: string, chatId: string, reason?: string): void;
+    clearBotUnavailableInChat(botName: string, chatId: string): void;
+    isBotUnavailableInChat(botName: string, chatId: string): boolean;
+    hasAnyDeliveredToChat(botName: string, chatId: string): boolean;
     hasRecentSimilarDelivery(botName: string, chatId: string, contentHash: string, windowMs: number, sourceTypes?: string[]): boolean;
     hasRecentOverlappingDelivery(botName: string, chatId: string, content: string, attachmentsJson: string, windowMs: number, minShortLength?: number, sourceTypes?: string[]): boolean;
     resetStaleDeliveries(botName: string, staleMs: number, maxAttempts: number): {
@@ -119,6 +125,8 @@ export declare class MessageStore {
     getChairmanBot(chatId: string): string;
     setBotVerbose(botName: string, chatId: string, verbose: boolean): void;
     getBotVerbose(botName: string, chatId: string): boolean;
+    setBotLiveStatus(botName: string, chatId: string, on: boolean): void;
+    getBotLiveStatus(botName: string, chatId: string): boolean;
     setBotMode(botName: string, chatId: string, mode: BotChatMode): void;
     getBotMode(botName: string, chatId: string): BotChatMode;
     setBotFreeDiscussion(botName: string, chatId: string, on: boolean): void;

package/dist/message-store.js

@@ -104,12 +104,34 @@ export class MessageStore {
         bot_name TEXT NOT NULL,
         chat_id TEXT NOT NULL,
         verbose INTEGER NOT NULL DEFAULT 0,
+        live_status INTEGER NOT NULL DEFAULT 1,
         free_discussion INTEGER NOT NULL DEFAULT 0,
         mode TEXT NOT NULL DEFAULT 'normal',
         updated_at INTEGER NOT NULL DEFAULT 0,
         PRIMARY KEY (bot_name, chat_id)
       );
 
+      -- Durable positive membership signal. Feishu does not reliably expose bot
+      -- members via chat_members, so receiving an event in a chat is the strongest
+      -- proof that this bot app is actually installed in that group.
+      CREATE TABLE IF NOT EXISTS bot_chat_seen (
+        bot_name TEXT NOT NULL,
+        chat_id TEXT NOT NULL,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (bot_name, chat_id)
+      );
+
+      -- Durable negative membership cache. Feishu message create returns 230002
+      -- when a bot app is not in a chat; cache that so discussion scheduling and
+      -- later proactive deliveries do not keep generating ghost participants.
+      CREATE TABLE IF NOT EXISTS bot_chat_unavailable (
+        bot_name TEXT NOT NULL,
+        chat_id TEXT NOT NULL,
+        reason TEXT NOT NULL DEFAULT '',
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (bot_name, chat_id)
+      );
+
       -- Durable delivery ledger for user-visible assistant outputs. All final
       -- text/attachment outputs should be inserted here first and dispatched
       -- once, regardless of whether they came from chat final, proactive
@@ -135,6 +157,13 @@ export class MessageStore {
       );
       CREATE INDEX IF NOT EXISTS idx_delivery_outbox_pending ON delivery_outbox(status, created_at);
     `);
+        // Migration: add per-bot live status toggle if missing
+        try {
+            this.db.exec(`ALTER TABLE bot_chat_settings ADD COLUMN live_status INTEGER NOT NULL DEFAULT 1`);
+        }
+        catch {
+            // Column already exists
+        }
         // Migration: add delivery_outbox delivery key columns if missing
         try {
             this.db.exec(`ALTER TABLE delivery_outbox ADD COLUMN delivery_key TEXT NOT NULL DEFAULT ''`);
@@ -401,6 +430,42 @@ export class MessageStore {
     `).all(maxCount);
         return rows.map((r) => this.mapDelivery(r));
     }
+    markBotSeenInChat(botName, chatId) {
+        this.db.prepare(`
+      INSERT INTO bot_chat_seen(bot_name, chat_id, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(bot_name, chat_id) DO UPDATE SET updated_at = excluded.updated_at
+    `).run(botName, chatId, Date.now());
+        // If the bot is receiving events from this chat again, it is no longer out
+        // of the chat. This recovers automatically when a bot is re-added to a group.
+        this.clearBotUnavailableInChat(botName, chatId);
+    }
+    hasBotSeenInChat(botName, chatId) {
+        const row = this.db.prepare(`SELECT 1 FROM bot_chat_seen WHERE bot_name = ? AND chat_id = ? LIMIT 1`).get(botName, chatId);
+        return !!row;
+    }
+    markBotUnavailableInChat(botName, chatId, reason = '') {
+        this.db.prepare(`
+      INSERT INTO bot_chat_unavailable(bot_name, chat_id, reason, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(bot_name, chat_id) DO UPDATE SET reason = excluded.reason, updated_at = excluded.updated_at
+    `).run(botName, chatId, reason, Date.now());
+    }
+    clearBotUnavailableInChat(botName, chatId) {
+        this.db.prepare(`DELETE FROM bot_chat_unavailable WHERE bot_name = ? AND chat_id = ?`).run(botName, chatId);
+    }
+    isBotUnavailableInChat(botName, chatId) {
+        const row = this.db.prepare(`SELECT 1 FROM bot_chat_unavailable WHERE bot_name = ? AND chat_id = ? LIMIT 1`).get(botName, chatId);
+        return !!row;
+    }
+    hasAnyDeliveredToChat(botName, chatId) {
+        const row = this.db.prepare(`
+      SELECT 1 FROM delivery_outbox
+      WHERE bot_name = ? AND chat_id = ? AND status = 'delivered'
+      LIMIT 1
+    `).get(botName, chatId);
+        return !!row;
+    }
     hasRecentSimilarDelivery(botName, chatId, contentHash, windowMs, sourceTypes) {
         if (!contentHash)
             return false;
@@ -694,6 +759,22 @@ export class MessageStore {
     `).get(botName, chatId);
         return !!row?.verbose;
     }
+    setBotLiveStatus(botName, chatId, on) {
+        this.db.prepare(`
+      INSERT INTO bot_chat_settings (bot_name, chat_id, live_status, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT (bot_name, chat_id) DO UPDATE SET
+        live_status = excluded.live_status,
+        updated_at = excluded.updated_at
+    `).run(botName, chatId, on ? 1 : 0, Date.now());
+    }
+    getBotLiveStatus(botName, chatId) {
+        const row = this.db.prepare(`
+      SELECT live_status FROM bot_chat_settings
+      WHERE bot_name = ? AND chat_id = ?
+    `).get(botName, chatId);
+        return row ? row.live_status !== 0 : true;
+    }
     setBotMode(botName, chatId, mode) {
         const freeDiscussion = mode === "free" ? 1 : 0;
         this.db.prepare(`

package/dist/openclaw-client.d.ts

@@ -1,5 +1,17 @@
 import { OpenClawConfig } from "./config.js";
 import { ChatMessage } from "./message-store.js";
+export type ProgressEvent = {
+    kind: "tool";
+    phase: "start" | "end" | "error";
+    name: string;
+    text: string;
+} | {
+    kind: "assistant_note";
+    text: string;
+} | {
+    kind: "lifecycle";
+    text: string;
+};
 export type ChatAttachment = {
     type?: string;
     mimeType?: string;
@@ -26,6 +38,7 @@ export declare class OpenClawClient {
     private toolEventCallbacks;
     private lastToolNamesByItemId;
     private sessionMessageCallbacks;
+    private progressCallbacks;
     /** Sessions where verbose mode should deliver visible transcript text even when mixed with tool blocks. */
     private verboseTranscriptSessions;
     private verboseAssistantTimers;
@@ -138,6 +151,7 @@ export declare class OpenClawClient {
         onSendAttempt?: () => void | Promise<void>;
         /** 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>;
     }): Promise<string>;
     private shouldInjectBridgeAttachmentHint;
     private bridgeAttachmentHint;
@@ -170,6 +184,7 @@ export declare class OpenClawClient {
         onSendAttempt?: () => void | Promise<void>;
         /** 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>;
     }): Promise<string>;
     private formatContextLines;
     private writeContextSyncFile;

package/dist/openclaw-client.js

@@ -29,6 +29,7 @@ export class OpenClawClient {
     toolEventCallbacks = new Map();
     lastToolNamesByItemId = new Map();
     sessionMessageCallbacks = new Map();
+    progressCallbacks = new Map();
     /** Sessions where verbose mode should deliver visible transcript text even when mixed with tool blocks. */
     verboseTranscriptSessions = new Set();
     verboseAssistantTimers = new Map();
@@ -239,11 +240,17 @@ export class OpenClawClient {
                         this.flushVerboseAssistantState(rawKey);
                         this.clearVerboseAssistantState(rawKey);
                     }
-                    if (toolCb && data.kind === "tool" && data.name && (data.phase === "start" || data.phase === "end" || data.phase === "error")) {
+                    if (data.kind === "tool" && data.name && (data.phase === "start" || data.phase === "end" || data.phase === "error")) {
                         const phase = data.phase || "event";
                         const meta = data.meta || data.input || data.args || "";
                         const output = data.output || data.result || data.error || "";
-                        toolCb(`${data.name} ${phase}`.trim(), String(meta || ""), String(output || ""));
+                        if (toolCb)
+                            toolCb(`${data.name} ${phase}`.trim(), String(meta || ""), String(output || ""));
+                        const progressCb = this.progressCallbacks.get(rawKey) || this.progressCallbacks.get(shortKey);
+                        if (progressCb) {
+                            const detail = phase === "start" ? String(meta || "") : String(output || meta || "");
+                            void progressCb({ kind: "tool", phase, name: String(data.name), text: `${data.name} ${phase}${detail ? `: ${detail}` : ""}` });
+                        }
                     }
                 }
                 if (frame.event === "agent" && frame.payload?.stream === "command_output") {
@@ -348,11 +355,12 @@ export class OpenClawClient {
         }
     }
     flushVerboseAssistantState(rawKey) {
-        if (!this.isVerboseTranscriptEnabled(rawKey))
-            return false;
         const shortKey = rawKey.replace(/^agent:[^:]+:/, "");
         const cb = this.sessionMessageCallbacks.get(rawKey) || this.sessionMessageCallbacks.get(shortKey);
-        if (!cb)
+        const progressCb = this.progressCallbacks.get(rawKey) || this.progressCallbacks.get(shortKey);
+        if (!this.isVerboseTranscriptEnabled(rawKey) && !progressCb)
+            return false;
+        if (!cb && !progressCb)
             return false;
         const key = rawKey;
         const latest = this.verboseAssistantLatest.get(key)?.trim() || "";
@@ -368,16 +376,22 @@ export class OpenClawClient {
         if (!toSend)
             return false;
         this.verboseAssistantSent.set(key, latest);
-        cb(toSend, { sourceType: "verbose_transcript" });
+        if (this.isVerboseTranscriptEnabled(rawKey) && cb)
+            cb(toSend, { sourceType: "verbose_transcript" });
+        if (progressCb)
+            void progressCb({ kind: "assistant_note", text: toSend });
         return true;
     }
     handleVerboseAssistantStream(payload) {
         const rawKey = payload?.sessionKey || "";
-        if (!rawKey || !this.isVerboseTranscriptEnabled(rawKey))
+        if (!rawKey)
             return;
         const shortKey = rawKey.replace(/^agent:[^:]+:/, "");
         const cb = this.sessionMessageCallbacks.get(rawKey) || this.sessionMessageCallbacks.get(shortKey);
-        if (!cb)
+        const progressCb = this.progressCallbacks.get(rawKey) || this.progressCallbacks.get(shortKey);
+        if (!this.isVerboseTranscriptEnabled(rawKey) && !progressCb)
+            return;
+        if (!cb && !progressCb)
             return;
         const data = payload.data || {};
         const fullText = typeof data.text === "string" ? data.text : typeof data.deltaText === "string" && data.replace ? data.deltaText : "";
@@ -1090,6 +1104,11 @@ export class OpenClawClient {
             }
             console.log(`[OpenClaw] chat.send runId: ${result.runId} (rpc=${Date.now() - sendStartedAt}ms, attachments=${params.attachments?.length || 0})`);
             await params.onSubmitted?.(result.runId);
+            if (params.onProgress) {
+                this.progressCallbacks.set(sk, params.onProgress);
+                this.progressCallbacks.set(fullSessionKey, params.onProgress);
+                void params.onProgress({ kind: "lifecycle", text: "等待 OpenClaw 回复" });
+            }
             return await this.collectReply(result.runId, params.timeoutMs || 1800000, sk, { emptyFinalAsNoReply: params.emptyFinalAsNoReply, expectedUserText: params.message });
         }
         finally {
@@ -1097,6 +1116,8 @@ export class OpenClawClient {
             // collectReply returns. Keep a short grace window so normal chat replies
             // are not delivered twice via the proactive-message path. Cron/LMA runs
             // are unaffected because they do not go through chatSend.
+            this.progressCallbacks.delete(sk);
+            this.progressCallbacks.delete(fullSessionKey);
             this.releaseSuppressedSessionKeysAfter(suppressedKeys, 30000);
             this.releaseOwnedDeliverySessionKeysAfter(suppressedKeys, 30000);
         }
@@ -1149,6 +1170,7 @@ export class OpenClawClient {
                 emptyFinalAsNoReply: params.emptyFinalAsNoReply,
                 onSendAttempt: params.onSendAttempt,
                 onSubmitted: params.onSubmitted,
+                onProgress: params.onProgress,
             });
         }
         // Build context block + actual message in one chat.send, or write the
@@ -1184,6 +1206,7 @@ export class OpenClawClient {
             emptyFinalAsNoReply: params.emptyFinalAsNoReply,
             onSendAttempt: params.onSendAttempt,
             onSubmitted: params.onSubmitted,
+            onProgress: params.onProgress,
         });
     }
     formatContextLines(messages) {

package/package.json

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