openclaw-lark-multi-agent 1.8.13 → 1.8.15

package/dist/live-status.d.ts

@@ -22,8 +22,9 @@ export type LiveStatusView = {
     toolCalls: number;
     /** True when finished via noReply(): the model produced no user-visible reply. */
     noReply: boolean;
-    /** Terminal state: running / done / failed (lets renderer pick color). */
-    state: "running" | "done" | "failed";
+    /** Presentation only: queued/admitted do not claim model execution. */
+    state: "queued" | "admitted" | "running" | "done" | "failed";
+    phase?: "queued" | "admitted" | "working" | "waiting" | "done" | "failed";
 };
 /** Persisted metadata needed to turn the live-status card into the final answer. */
 export type LiveStatusFinalMeta = {
@@ -35,15 +36,55 @@ export type LiveStatusFinalMeta = {
     locale: "zh" | "en";
     noReply?: boolean;
 };
+/** Optional external presentation owner (e.g. the durable outbox). A local
+ * execution outcome is NOT a platform delivery receipt. Once handed off, late
+ * card effects request reconciliation from this owner instead of writing a
+ * compact done view over its possibly-unknown final payload. */
+export type LiveStatusTerminalOwner = {
+    onReconcileNeeded: (meta: LiveStatusFinalMeta) => void | Promise<void>;
+};
+/** The adapter MUST call run inside its ordered callback, immediately around
+ * the actual SDK invocation. Its receipt survives an outer queue deadline. */
+export type LiveStatusEffect<T> = {
+    run: (send: () => Promise<T>) => Promise<T | undefined>;
+};
+/** A transport/observation error is not proof that a platform effect failed. */
+export declare class LiveStatusEffectUnknownError extends Error {
+    readonly cause: unknown;
+    constructor(cause: unknown);
+}
+/** Only a definitive platform rejection is safe for the terminal retry loop. */
+export declare class LiveStatusEffectRejectedError extends Error {
+}
+/** Proven local no-effect suppression (settings/epoch/lease), not an unknown
+ * transport outcome and not permission to retry an attempted SDK operation. */
+export declare class LiveStatusEffectSuppressedError extends Error {
+}
 export type LiveStatusCallbacks = {
     /** Create the status card; returns the new message id. */
-    create: (view: LiveStatusView) => Promise<string | undefined>;
-    /** Patch the existing status card. */
-    edit: (messageId: string, view: LiveStatusView) => Promise<void>;
+    create: (view: LiveStatusView, effect: LiveStatusEffect<string | undefined>) => Promise<string | undefined>;
+    /** Patch the existing status card. Reject with LiveStatusEffectRejectedError
+     * only for a definitive no-effect failure; all other rejection is unknown. */
+    edit: (messageId: string, view: LiveStatusView, effect: LiveStatusEffect<void>) => Promise<void>;
     warn?: (message: string, err?: unknown) => void;
+    /** Synchronous journal checkpoint, before scheduling any new UI effect. */
+    desired?: (view: LiveStatusView) => void;
+    /** UI-only cohort completeness. A root outcome is not per-input proof. */
+    unconfirmedInputs?: (outcome: "done" | "failed") => {
+        title: string;
+        detail: string;
+    } | undefined;
 };
 export type LiveStatusOptions = {
     botName: string;
+    initialPhase?: "queued";
+    restore?: {
+        messageId?: string;
+        view?: LiveStatusView;
+        startedAt: number;
+        blockCreate: boolean;
+        blockEdits: boolean;
+    };
     locale?: "zh" | "en";
     delayMs?: number;
     maxChars?: number;
@@ -67,7 +108,19 @@ export declare class LiveStatusController {
     private createTimer?;
     private tickTimer?;
     private createPromise?;
+    private createSuppressed;
+    private waitingCreateAllowed;
     private finalized;
+    private terminalOutcome;
+    private disposed;
+    private generation;
+    /** Frozen/terminal presentation wins over every older progress snapshot. */
+    private pinnedView?;
+    private terminalOwner?;
+    private pendingEdit?;
+    private editPump?;
+    /** Timed-out SDK effects retain receipt ownership, but must not be replayed. */
+    private unknownEdits;
     private waitingForResult;
     private updatesFrozen;
     private disabled;
@@ -78,13 +131,25 @@ export declare class LiveStatusController {
      *  A success resets the counter. */
     private consecutiveEditFailures;
     private state;
+    private blockedEdits;
     /** Total tool calls (tool_start events) seen during the run, for the summary. */
     private toolCallCount;
     /** True when finished via noReply(): show a "no content" summary. */
     private noReplyResult;
     constructor(callbacks: LiveStatusCallbacks, opts: LiveStatusOptions);
+    /** Receipt is durable locally, NOT Gateway admission. */
+    received(detail: string): void;
+    /** A proven never-attempted ordinary recovery may reuse its queued card.
+     * Merely observing an expected root never calls this method. */
+    resumeQueued(): void;
+    /** Enqueue/local receipt remains waiting, not actual-owner/model evidence.
+     * Keep one latest pinned view while allowing another input to coalesce. */
+    showInputWaiting(detail: string, title?: string): Promise<void>;
+    /** Only the exact ACK owner calls this; admission is not model execution. */
+    admitted(successor?: boolean): Promise<void>;
     get id(): string | undefined;
     start(initialDetail?: string): void;
+    setMetadata(model?: string, thinkingLevel?: string): void;
     progress(event: ProgressEvent | string): Promise<void>;
     /** Freeze recurring/progress edits, not the original result observer.
      * A single final/error summary remains allowed when the real outcome arrives. */
@@ -97,10 +162,14 @@ export declare class LiveStatusController {
      * Freeze any successful terminal state (text, attachment-only, or NO_REPLY)
      * without first emitting the compact done patch. The caller persists this
      * metadata in the outbox, which owns the final patch/cleanup. If no card was
-     * created, the caller falls back to normal new-message delivery.
+     * created, the caller falls back to normal new-message delivery. Metadata is
+     * a target/execution snapshot, never a receipt. B2/outbox callers that may own
+     * an unknown or same-card final should supply owner BEFORE attempting it;
+     * late IDs/stale effects then delegate reconciliation instead of patching.
      */
-    prepareTerminalDelivery(noReply?: boolean): Promise<LiveStatusFinalMeta | undefined>;
-    prepareFinalDelivery(): Promise<LiveStatusFinalMeta | undefined>;
+    prepareTerminalDelivery(noReply?: boolean, owner?: LiveStatusTerminalOwner): Promise<LiveStatusFinalMeta | undefined>;
+    private finalMeta;
+    prepareFinalDelivery(owner?: LiveStatusTerminalOwner): Promise<LiveStatusFinalMeta | undefined>;
     fail(): Promise<void>;
     /**
      * Finish when the model explicitly produced no reply (NO_REPLY) or an empty
@@ -109,6 +178,9 @@ export declare class LiveStatusController {
      */
     noReply(): Promise<void>;
     dispose(): void;
+    private pinView;
+    private finishView;
+    private reconcilePinnedView;
     /**
      * Intermediate assistant text arrives as incremental fragments (each flush
      * sends only the newly-added slice). Consecutive fragments with no tool event
@@ -126,13 +198,11 @@ export declare class LiveStatusController {
     /** Refresh the elapsed-time footer periodically even with no new activity. */
     private startTicker;
     private safeEdit;
-    /**
-     * Terminal edits (complete/fail/noReply) are one-shot — there is no next tick to
-     * recover them — so a transient Feishu error (code=2200 etc.) would leave the
-     * card stuck on "running". Retry the final patch a few times with small backoff
-     * so the card reliably reaches its terminal state.
-     */
-    private safeEditFinal;
+    /** One flight + one latest pending snapshot, regardless of tick/event rate. */
+    private queueEdit;
+    private canRunPendingEdit;
+    private flushEdits;
+    private performEdit;
     /** Dedupe key includes elapsed so the footer timer ticks even without new
      *  activity, while identical content within the same second is still skipped. */
     private signature;