openclaw-lark-multi-agent 1.4.3 → 1.4.5

package/dist/message-store.d.ts

@@ -41,12 +41,13 @@ export interface DeliveryOutboxItem {
     content: string;
     attachmentsJson: string;
     replyToMessageId: string;
-    /** Delivery mode. `patch_live_status` turns the existing live-status card
-     * into the final answer instead of creating a second Feishu message. */
+    /** Delivery mode. New final replies use `send`; `patch_live_status` is kept
+     * for status-only cleanup and restart compatibility with legacy outbox rows. */
     deliveryMode?: "send" | "patch_live_status";
     /** Existing interactive-card message id to patch for patch_live_status. */
     targetMessageId?: string;
-    /** Persisted JSON footer metadata (tool calls / elapsed / model / locale). */
+    /** Persisted JSON delivery metadata (for example final-reply model footer,
+     * or legacy live-status cleanup metadata). */
     deliveryMetaJson?: string;
     /** Durable stage checkpoint: final text/card is already visible. */
     textDelivered?: boolean;

package/dist/openclaw-client.d.ts

@@ -21,7 +21,7 @@ export type ChatAttachment = {
     fileName?: string;
     content: string;
 };
-export declare const GATEWAY_PROTOCOL_MIN = 3;
+export declare const GATEWAY_PROTOCOL_MIN = 4;
 export declare const GATEWAY_PROTOCOL_MAX = 4;
 /**
  * OpenClaw Gateway WebSocket client.
@@ -40,11 +40,14 @@ export declare class OpenClawClient {
     /** Callbacks for tool events (verbose mode) */
     private toolEventCallbacks;
     private lastToolNamesByItemId;
+    /** Deduplicates 2026.8 canonical `agent.stream=tool` events against legacy
+     * `stream=item` mirrors when a runtime emits both representations. */
+    private recentToolEventKeys;
     private sessionMessageCallbacks;
     private progressCallbacks;
-    /** Per-session steered messages awaiting consumption confirmation. Maps the
-     *  normalized text actually sent (possibly wrapped with an insertion prefix)
-     *  to the ORIGINAL display text shown on the live-status card. */
+    /** Per-session steered messages awaiting consumption confirmation. Each
+     * accepted message is retained independently so identical/overlapping text
+     * cannot overwrite another correlation. */
     private pendingSteerTexts;
     /** Sessions where verbose mode should deliver visible transcript text even when mixed with tool blocks. */
     private verboseTranscriptSessions;
@@ -57,9 +60,11 @@ export declare class OpenClawClient {
     /** Session keys whose transcript/session.message updates are currently suppressed. */
     private suppressedSessions;
     private suppressedSessionTimers;
-    /** Session keys whose delivery is owned by this bridge's chatSend final path. */
-    private ownedDeliverySessions;
-    private ownedDeliverySessionTimers;
+    /** Run ids whose final delivery is owned by chatSend/collectReply. Delivery
+     * ownership must be run-scoped: a concurrent queueMode=steer admission may
+     * fall through to a separate ordinary run in the same session. */
+    private ownedDeliveryRuns;
+    private ownedDeliveryRunTimers;
     /** Session keys whose proactive messages must be dropped by the bridge (e.g. discussion scheduler owns delivery). */
     private mutedProactiveSessions;
     private mutedProactiveSessionCounts;
@@ -83,6 +88,7 @@ export declare class OpenClawClient {
     private extractVisibleAssistantText;
     private isVerboseTranscriptEnabled;
     private clearVerboseAssistantState;
+    private claimToolEvent;
     private pruneVerboseCaches;
     private flushVerboseAssistantState;
     private handleVerboseAssistantStream;
@@ -128,21 +134,19 @@ export declare class OpenClawClient {
         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.
+     * 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.
      */
     steer(sessionKey: string, text: string, displayText?: string): Promise<{
-        status: "steered" | "no_active_run" | "rejected" | "unavailable";
-        sessionId?: string;
+        status: "steered" | "unavailable";
+        runId?: string;
+        /** Cancel provisional transcript correlation when LMA falls back to a normal run. */
+        cancelPending?: () => void;
     }>;
     /** Callbacks fired when a steered message is confirmed consumed by the model
      *  (matching sessionUser event). Keyed by bare/short session key. Multiple may
@@ -154,8 +158,9 @@ export declare class OpenClawClient {
      *  is actually consumed by the active run. The bridge uses this to flip the
      *  Feishu reaction from "Typing" (awaiting insertion) to "Get" (inserted).
      *  Return true from the callback to consume/remove it (one-shot). */
-    onSteerConsumed(sessionKey: string, cb: (text: string) => boolean | void): void;
+    onSteerConsumed(sessionKey: string, matchText: string, cb: (text: string) => boolean | void): () => void;
     private shortKey;
+    private canonicalSessionKey;
     private registerPendingSteer;
     /**
      * Called when a sessionUser event is seen for a session. If its text matches a
@@ -175,7 +180,9 @@ export declare class OpenClawClient {
     ensureModel(sessionKey: string, expectedModel: string): Promise<boolean>;
     deleteSession(key: string, deleteTranscript?: boolean): Promise<any>;
     resetSession(key: string): Promise<any>;
-    compactSession(key: string): Promise<any>;
+    compactSession(key: string, options?: {
+        maxLines?: number;
+    }): Promise<any>;
     /**
      * Send a message to a session and get the agent reply.
      * deliver=false prevents OpenClaw from auto-posting to channels.
@@ -187,9 +194,8 @@ export declare class OpenClawClient {
     private emitProactiveForSession;
     private suppressSessionKeys;
     private releaseSuppressedSessionKeysAfter;
-    private ownDeliverySessionKeys;
-    private releaseOwnedDeliverySessionKeysAfter;
-    private isOwnedDeliverySession;
+    private ownDeliveryRun;
+    private releaseOwnedDeliveryRunAfter;
     private addMutedProactiveKey;
     private releaseMutedProactiveKey;
     muteProactiveDelivery(sessionKey: string): (delayMs?: number) => void;
@@ -253,6 +259,7 @@ export declare class OpenClawClient {
      */
     subscribeSession(sessionKey: string, onMessage: (text: string, meta?: {
         sourceType?: string;
+        runId?: string;
     }) => void): Promise<void>;
     setVerboseTranscriptDelivery(sessionKey: string, enabled: boolean): void;
     unsubscribeSession(sessionKey: string): Promise<void>;