openclaw-lark-multi-agent 1.0.9 → 1.0.11

package/dist/openclaw-client.d.ts

@@ -36,6 +36,13 @@ export declare class OpenClawClient {
     /** Session keys whose proactive messages must be dropped by the bridge (e.g. discussion scheduler owns delivery). */
     private mutedProactiveSessions;
     private mutedProactiveSessionCounts;
+    /** Global limiter for chat.send RPC calls; large multi-bot fan-out can
+     * saturate the Gateway before collectReply even starts. The slot is released
+     * as soon as the chat.send RPC returns a runId; collectReply does not hold it.
+     */
+    private chatSendConcurrency;
+    private activeChatSends;
+    private chatSendWaiters;
     constructor(config: OpenClawConfig);
     connect(): Promise<void>;
     private _doConnect;
@@ -92,6 +99,8 @@ export declare class OpenClawClient {
     private addMutedProactiveKey;
     private releaseMutedProactiveKey;
     muteProactiveDelivery(sessionKey: string): (delayMs?: number) => void;
+    private acquireChatSendSlot;
+    private releaseChatSendSlot;
     chatSend(params: {
         sessionKey: string;
         message: string;

package/dist/openclaw-client.js

@@ -37,6 +37,13 @@ export class OpenClawClient {
     /** Session keys whose proactive messages must be dropped by the bridge (e.g. discussion scheduler owns delivery). */
     mutedProactiveSessions = new Set();
     mutedProactiveSessionCounts = new Map();
+    /** Global limiter for chat.send RPC calls; large multi-bot fan-out can
+     * saturate the Gateway before collectReply even starts. The slot is released
+     * as soon as the chat.send RPC returns a runId; collectReply does not hold it.
+     */
+    chatSendConcurrency = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_CHAT_SEND_CONCURRENCY || 3);
+    activeChatSends = 0;
+    chatSendWaiters = [];
     constructor(config) {
         this.config = config;
     }
@@ -606,12 +613,22 @@ export class OpenClawClient {
                                 }
                                 if (!latestFinalText) {
                                     const failureText = buildFailureText(ev);
-                                    if (ev.data?.replayInvalid) {
+                                    const state = ev.data?.livenessState || "";
+                                    const reason = ev.data?.stopReason || "";
+                                    // replayInvalid, cancelled/rpc, and abandoned are often
+                                    // transient runtime states — the real reply may still arrive
+                                    // shortly after via session.message or a subsequent run.
+                                    // Defer the failure instead of finishing immediately.
+                                    const isTransient = ev.data?.replayInvalid
+                                        || state === "cancelled"
+                                        || state === "abandoned"
+                                        || reason === "rpc";
+                                    if (isTransient) {
                                         pendingRuntimeFailureText = failureText;
-                                        console.warn(`[OpenClaw] replayInvalid lifecycle observed for runId=${evRunId || runId}; waiting for real text or idle timeout`);
+                                        console.warn(`[OpenClaw] transient lifecycle end (${state}, reason=${reason}) for runId=${evRunId || runId}; waiting for real text or idle timeout`);
                                         return;
                                     }
-                                    if (ev.data?.livenessState !== "working") {
+                                    if (state !== "working") {
                                         finish(failureText);
                                         return;
                                     }
@@ -827,6 +844,24 @@ export class OpenClawClient {
                 release();
         };
     }
+    async acquireChatSendSlot() {
+        const limit = Math.max(1, this.chatSendConcurrency || 1);
+        if (this.activeChatSends < limit) {
+            this.activeChatSends++;
+            return () => this.releaseChatSendSlot();
+        }
+        const startedWaitingAt = Date.now();
+        await new Promise((resolve) => this.chatSendWaiters.push(resolve));
+        this.activeChatSends++;
+        console.log(`[OpenClaw] chat.send waited ${Date.now() - startedWaitingAt}ms for concurrency slot (active=${this.activeChatSends}/${limit})`);
+        return () => this.releaseChatSendSlot();
+    }
+    releaseChatSendSlot() {
+        this.activeChatSends = Math.max(0, this.activeChatSends - 1);
+        const next = this.chatSendWaiters.shift();
+        if (next)
+            next();
+    }
     async chatSend(params) {
         const sk = params.sessionKey;
         const fullSessionKey = `agent:main:${sk}`;
@@ -839,14 +874,21 @@ export class OpenClawClient {
             // the next message while still allowing sessionKey matching for internal runIds.
             this.agentEvents.set(fullSessionKey, []);
             this.agentEvents.set(sk, []);
+            const releaseChatSendSlot = await this.acquireChatSendSlot();
+            let result;
             const sendStartedAt = Date.now();
-            const result = await this.rpc("chat.send", {
-                sessionKey: sk,
-                message: params.message,
-                attachments: params.attachments,
-                deliver: params.deliver ?? false,
-                idempotencyKey: randomUUID(),
-            });
+            try {
+                result = await this.rpc("chat.send", {
+                    sessionKey: sk,
+                    message: params.message,
+                    attachments: params.attachments,
+                    deliver: params.deliver ?? false,
+                    idempotencyKey: randomUUID(),
+                });
+            }
+            finally {
+                releaseChatSendSlot();
+            }
             console.log(`[OpenClaw] chat.send runId: ${result.runId} (rpc=${Date.now() - sendStartedAt}ms, attachments=${params.attachments?.length || 0})`);
             return await this.collectReply(result.runId, params.timeoutMs || 1800000, sk, { emptyFinalAsNoReply: params.emptyFinalAsNoReply, expectedUserText: params.message });
         }

package/package.json

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