openclaw-lark-multi-agent 1.8.14 → 1.8.15

package/dist/feishu-bot.d.ts

@@ -1,6 +1,12 @@
 import { BotConfig } from "./config.js";
 import { OpenClawClient } from "./openclaw-client.js";
 import { MessageStore } from "./message-store.js";
+/** Observation deadline, never a claim that the underlying SDK was cancelled. */
+export declare class SendDeadlineError extends Error {
+    readonly chatId: string;
+    readonly limit: number;
+    constructor(chatId: string, limit: number);
+}
 /**
  * Manages a single Feishu bot instance.
  *
@@ -47,18 +53,21 @@ export declare class FeishuBot {
      * fails restore their durable fallback. Fired in processQueueInner's
      * failure arms; dropped at each new batch top and on queue exit. */
     private runFailureObservers;
-    /** Steered messages admitted into the CURRENT batch (per chat). Flipped to
-     * DONE when that batch completes successfully; cleared (unflipped) when the
-     * batch scope ends any other way. */
+    /** Ephemeral batch-scoped acceptance bookkeeping, not commitment evidence.
+     * Ending the batch only drops these handles; durable insertion custody stays
+     * accepted and must not inherit the root's DONE. */
     private admittedSteerAcks;
-    /** Identity token of the CURRENT queue owner per chat. Steer acks carry
-     *  the token of the batch that admitted them; a completion path only flips
-     *  acks of its OWN batch, so a superseded inner can never DONE a newer
-     *  batch's steered inputs (2026-10-16 audit B9). */
+    /** Identity token of the CURRENT queue owner per chat. Acceptance bookkeeping
+     * carries its batch token so late old cleanup never takes a newer batch's
+     * handles (2026-10-16 audit B9); neither token proves input commitment. */
     private queueRunTokens;
     /** Go / Go-Checker supervision controller (per-bot instance). */
     private readonly goDeliveryReceipts;
     private readonly goReceiptApis;
+    private readonly sendEffectLeases;
+    /** A deadline releases the chat queue, NOT this exact operation's ownership. */
+    private readonly inFlightDeliveryWork;
+    private assertSendEffectLease;
     private installGoReceiptCapture;
     private goController;
     /** Per-chat durable outbox retry timer. */
@@ -82,6 +91,7 @@ export declare class FeishuBot {
     private adminOpenId;
     private locale;
     private configPath?;
+    private queuedPresentations;
     private static allBots;
     /** Chats where this bot app has actually received an event in this process. */
     private static seenBotChats;
@@ -125,6 +135,7 @@ export declare class FeishuBot {
     /** CAS includes the actual batch, not merely the queue Promise, and excludes
      * local admission/RPC windows even if the host briefly reports idle. */
     private reconcileDispatchCustody;
+    private presentation;
     private stopGeneration;
     private reactionChecks;
     private receiptReaction;
@@ -258,6 +269,12 @@ export declare class FeishuBot {
      * No host proactive-send assumption, no fake platform receipt. */
     private deliverGoExecutorResult;
     private insertionNoticeCurrent;
+    private deliveryDeadlineReason;
+    /** Durable local obligation, separate from the platform retry budget. */
+    private retainLocalDelivery;
+    private isDeliverySettlementRevoked;
+    /** Also runs for a late accepted SDK receipt, without replaying the final. */
+    private settleConfirmedDelivery;
     private dispatchPendingDeliveries;
     private hasFreeModeBot;
     private mentionedBotNames;
@@ -277,6 +294,9 @@ export declare class FeishuBot {
     private buildLiveStatusCard;
     /** Minimal escaping so activity text does not break card markdown. */
     private escapeCardText;
+    /** Keep receipt ownership below sendOrdered's Promise.race. Nothing here
+     * changes business-message/outbox ordering or retries. */
+    private liveStatusCallbacks;
     private sendLiveStatusCard;
     private replyLiveStatusCard;
     private patchLiveStatusCard;
@@ -358,8 +378,10 @@ export declare class FeishuBot {
      * The chain must never wedge: a single hung Feishu call used to block every
      * later send in that chat forever (live-status patches fire per tool event),
      * which froze cards and stranded /stop confirmations. Each link is therefore
-     * raced against a deadline, so a stuck send is abandoned and ordering resumes.
-     * Prefer a larger OPENCLAW_LARK_MULTI_AGENT_SEND_TIMEOUT_MS on slow links.
+     * raced against an observation deadline. The queue advances, but an already
+     * attempted SDK request is NOT cancelled and can settle late. Its outbox keeps
+     * custody; the expired lease forbids any subsequent new SDK effect. This is
+     * not a strict platform-order guarantee for uncancellable in-flight requests.
      */
     private sendOrdered;
     /** One send link: resolve with fn(), or reject at the deadline so the chain advances. */