lark-remote 0.1.6 → 0.1.7

package/dist/card/card-session.js

@@ -40,6 +40,74 @@ export class CardSession {
             this.resolveController = resolve;
             this.rejectController = reject;
         });
+        this.coalesceMs = opts.coalesceMs ?? 100;
+    }
+    /**
+     * 调度一次延迟 flush。已有 pending 调度则复用（合批核心）；否则起一个
+     * coalesceMs 定时器。flushInFlight 期间不再起 timer（避免重入叠加），但置
+     * pendingReschedule 以便 in-flight flush 完成后重新调度——否则 in-flight 期间
+     * 到达的 push/update 会停留为 stale 中间帧（P2-1）。
+     */
+    scheduleFlush() {
+        if (this.flushTimer)
+            return;
+        if (this.flushInFlight) {
+            this.pendingReschedule = true;
+            return;
+        }
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = undefined;
+            void this.flush();
+        }, this.coalesceMs);
+    }
+    /**
+     * 执行一次 render + updateCard。合批窗口到期或 finish 即时 flush 时调用。
+     * flushInFlight 防止 timer 回调与 finish 的即时 flush 重入。
+     *
+     * 终态守卫：若 finish() 已把 state 转为终态，跳过本次 patch——避免 in-flight flush
+     * 用 pre-terminal state 覆盖 finish 已发的终态卡。finish() 自身会 await 任何
+     * in-flight flush 保证顺序，此守卫是双保险。
+     */
+    async flush() {
+        if (this.flushInFlight)
+            return;
+        if (!this.isFlushableState())
+            return;
+        this.flushInFlight = true;
+        const flushPromise = (async () => {
+            try {
+                await this.updateCard();
+            }
+            finally {
+                this.flushInFlight = false;
+                // flushInFlight 守卫保证同一时刻只有一个 in-flight flush，故可无条件清空。
+                this.flushP = undefined;
+                // P2-1：in-flight 期间若有 push/update 到达（pendingReschedule），重新调度一次
+                // flush 渲染累积事件，避免 stale 中间帧。终态守卫在 flush() 入口已拦截，
+                // 故 finish 后不会误触发。
+                if (this.pendingReschedule) {
+                    this.pendingReschedule = false;
+                    this.scheduleFlush();
+                }
+            }
+        })();
+        this.flushP = flushPromise;
+        return flushPromise;
+    }
+    /**
+     * 取消待 flush 的合批调度（finish/settle 前清理，避免延迟 update 与终态
+     * 渲染竞争）。返回是否有被取消的 pending 调度。同时清掉 pendingReschedule，
+     * 防止 in-flight flush 的 finally 在 finish await 之后又起 dangling timer
+     * （finish 自身会渲染含累积事件的终态卡，无需 follow-up）。
+     */
+    cancelPendingFlush() {
+        this.pendingReschedule = false;
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = undefined;
+            return true;
+        }
+        return false;
     }
     get currentState() {
         return this.state;
@@ -48,6 +116,24 @@ export class CardSession {
     get cardMessageId() {
         return this.messageId;
     }
+    /**
+     * P1-3 合批窗口（ms）。连续事件各触发一次全卡 render + patch 是流式 CPU 主要
+     * 来源；窗口内多个事件复用同一次延迟 flush。窗口大小可通过 constructor 覆盖
+     * （测试用小窗口/0 禁用）。run/bash 子类共用的 flush 骨架（scheduleFlush/flush/
+     * cancelPendingFlush/settle）下沉到基类。
+     */
+    coalesceMs;
+    flushTimer;
+    flushInFlight = false; /** P2-1：in-flight flush 期间到达的 push/update 标记。scheduleFlush 在
+     *  flushInFlight 时早退不调度新 timer，但事件已 reduce 进 state；若无此标志，
+     *  in-flight flush 完成后该事件无 follow-up render，停留为 stale 中间帧。
+     *  finally 检查此标志后重新 scheduleFlush，保证 in-flight 期间累积的事件最终被渲染。 */
+    pendingReschedule = false;
+    /** 当前 in-flight flush 的 promise（若 flush 正在 await updateCard）。
+     *  finish() 在终态 patch 前 await 它，保证 in-flight 的 pre-terminal patch 先落地、
+     *  terminal patch 后落地——否则两条 controller.update 并发无 FIFO，
+     *  pre-terminal 可能在 terminal 之后 resolve 留下"思考中"终帧（P2）。 */
+    flushP;
     async start() {
         if (this.streamOutcome) {
             // 二次调用也套 timeout 保护：若 controllerReady 永不 settle（首次超时失败），

package/dist/card/card-shared.d.ts

@@ -1,8 +1,4 @@
 import { type AgentKind } from '../runner/index.js';
-interface TruncateOptions {
-    suffix?: string;
-    normalizeWhitespace?: boolean;
-}
 /**
  * Display name for an agent kind in the run card header.
  *
@@ -11,7 +7,7 @@ interface TruncateOptions {
  * wire up the registry (notably unit tests of pure render helpers).
  */
 export declare function agentDisplayName(kind: string): string;
-export declare function truncate(str: string, max: number, options?: TruncateOptions): string;
+export { truncate } from '../common/truncate.js';
 interface TerminalLabelOptions {
     prefix?: string;
 }
@@ -26,12 +22,6 @@ export declare function stopButton(runId: string): object;
  * Standardized: ✨ 新会话 + primary type
  */
 export declare function newSessionButton(): object;
-/**
- * Create a CardKit 2.0 "resume session" button with behaviors callback.
- * Carries both sessionId and agent so the handler routes to the correct
- * agent's session reader (P2 fix: completion cards from non-default agents
- * must carry agent to avoid wrong-reader fallback).
- */
 /**
  * Create a CardKit 2.0 Compact button for Codex app-server mode.
  * Triggers thread/compact/start via the codex.compact callback.
@@ -47,4 +37,3 @@ export declare function compactButton(runId: string): object;
  */
 export declare function resumeCompactButton(sessionId: string, agent: string): object;
 export declare function resumeUseButton(sessionId: string, agent: AgentKind): object;
-export {};

package/dist/card/card-shared.js

@@ -25,26 +25,7 @@ export function agentDisplayName(kind) {
         return 'Kimi';
     return kind;
 }
-export function truncate(str, max, options) {
-    const suffix = options?.suffix ?? '…';
-    const normalize = options?.normalizeWhitespace ?? false;
-    let s = str;
-    if (normalize)
-        s = s.replace(/\s+/g, ' ').trim();
-    if (s.length <= max)
-        return s;
-    const suffixLen = suffix.length;
-    const budget = max - suffixLen;
-    if (budget <= 0)
-        return suffix;
-    let end = 0;
-    for (const ch of s) {
-        if (end + ch.length > budget)
-            break;
-        end += ch.length;
-    }
-    return s.slice(0, end) + suffix;
-}
+export { truncate } from '../common/truncate.js';
 const TERMINAL_LABELS = {
     done: '已完成',
     error: '出错',
@@ -96,12 +77,6 @@ export function newSessionButton() {
         behaviors: [{ type: 'callback', value: { cmd: 'new-session' } }],
     };
 }
-/**
- * Create a CardKit 2.0 "resume session" button with behaviors callback.
- * Carries both sessionId and agent so the handler routes to the correct
- * agent's session reader (P2 fix: completion cards from non-default agents
- * must carry agent to avoid wrong-reader fallback).
- */
 /**
  * Create a CardKit 2.0 Compact button for Codex app-server mode.
  * Triggers thread/compact/start via the codex.compact callback.

package/dist/card/run-card-session.d.ts

@@ -1,34 +1,9 @@
-import { CardSession, type CardChannel, type StreamSettleResult } from './card-session.js';
+import { CardSession, type CardChannel } from './card-session.js';
 import type { AgentEvent } from '../runner/index.js';
 import { type FinishMeta, type RunState, type RunTerminal } from './run-state.js';
 import { type RunCardRenderOptions } from './run-renderer.js';
 export type { CardChannel as RunCardChannel };
 export declare class RunCardSession extends CardSession<RunState, RunCardRenderOptions> {
-    /**
-     * P1-3 push 合批窗口（ms）。连续 text delta 各触发一次全卡 render + patch 是
-     * 流式 CPU 主要来源（§P1-3）。窗口内多个事件复用同一次
-     * 延迟 flush，只 render + controller.update 一次。100ms 内人眼无感，且 text
-     * 流式 patch 次数 -80%。窗口大小可通过 constructor 覆盖（测试用小窗口）。
-     */
-    private readonly coalesceMs;
-    private flushTimer;
-    private flushInFlight;
-    /**
-     * P2-1：in-flight flush 期间到达的 push 标记。scheduleFlush 在 flushInFlight
-     * 时早退不调度新 timer，但事件已 reduce 进 state；若无此标志，in-flight flush
-     * 完成后该事件无 follow-up render，停留为 stale 中间帧（生产 SDK 的
-     * controller.update 经 throttle + setTimeout 异步 resolve，故 flush 与
-     * 下一个 push 交叠是真实场景）。finally 检查此标志后重新 scheduleFlush，
-     * 保证 in-flight 期间累积的事件最终被渲染。
-     */
-    private pendingReschedule;
-    /**
-     * 当前 in-flight flush 的 promise（若 flush 正在 await updateCard）。
-     * finish() 在终态 patch 前 await 它，保证 in-flight 的 pre-terminal patch
-     * 先落地、terminal patch 后落地——否则两条 controller.update 并发无 FIFO，
-     * pre-terminal 可能在 terminal 之后 resolve 留下"思考中"终帧（P2）。
-     */
-    private flushP;
     constructor(opts: {
         connector: CardChannel;
         chatId: string;
@@ -44,35 +19,7 @@ export declare class RunCardSession extends CardSession<RunState, RunCardRenderO
     protected get errorPrefix(): string;
     protected renderCard(state: RunState, options: RunCardRenderOptions): object;
     protected hasOwnBudgetProtection(): boolean;
+    protected isFlushableState(): boolean;
     push(event: AgentEvent): Promise<void>;
-    /**
-     * 调度一次延迟 flush。已有 pending 调度则复用（合批核心）；否则起一个
-     * coalesceMs 定时器。flushInFlight 期间不再起 timer（避免重入叠加），但置
-     * pendingReschedule 以便 in-flight flush 完成后重新调度——否则 in-flight 期间
-     * 到达的 push 会停留为 stale 中间帧（P2-1）。
-     */
-    private scheduleFlush;
-    /**
-     * 执行一次 render + updateCard。合批窗口到期或 finish 立即 flush 时调用。
-     * flushInFlight 防止 timer 回调与 finish 的即时 flush 重入。
-     *
-     * 终态守卫：若 finish() 已把 state 转为终态（done/error/interrupted/idle_timeout），
-     * 跳过本次 patch——避免 in-flight flush 用 pre-terminal state 覆盖 finish 已发的
-     * 终态卡。finish() 自身会 await 任何 in-flight flush 保证顺序，此守卫是双保险。
-     */
-    private flush;
-    /**
-     * 取消待 flush 的合批调度（finish/settle 前清理，避免延迟 update 与终态
-     * 渲染竞争）。返回是否有被取消的 pending 调度。同时清掉 pendingReschedule，
-     * 防止 in-flight flush 的 finally 在 finish await 之后又起 dangling timer
-     * （finish 自身会渲染含累积事件的终态卡，无需 follow-up）。
-     */
-    private cancelPendingFlush;
     finish(terminal: Exclude<RunTerminal, 'running' | 'finalizing'>, meta?: FinishMeta): Promise<void>;
-    /**
-     * settle 前兜底取消合批调度。bridge 正常流程 finish→settle，finish 已 cancel；
-     * 但若未来有直调 settle（未经 finish）的路径，避免 dangling timer 在 release
-     * 后触发 void flush() 去更新已释放的 stream（harmless 但无谓）。
-     */
-    settle(): Promise<StreamSettleResult>;
 }

package/dist/card/run-card-session.js

@@ -2,31 +2,6 @@ import { CardSession } from './card-session.js';
 import { createInitialRunState, finishRun, reduceRunState, } from './run-state.js';
 import { renderRunCard } from './run-renderer.js';
 export class RunCardSession extends CardSession {
-    /**
-     * P1-3 push 合批窗口（ms）。连续 text delta 各触发一次全卡 render + patch 是
-     * 流式 CPU 主要来源（§P1-3）。窗口内多个事件复用同一次
-     * 延迟 flush，只 render + controller.update 一次。100ms 内人眼无感，且 text
-     * 流式 patch 次数 -80%。窗口大小可通过 constructor 覆盖（测试用小窗口）。
-     */
-    coalesceMs;
-    flushTimer;
-    flushInFlight = false;
-    /**
-     * P2-1：in-flight flush 期间到达的 push 标记。scheduleFlush 在 flushInFlight
-     * 时早退不调度新 timer，但事件已 reduce 进 state；若无此标志，in-flight flush
-     * 完成后该事件无 follow-up render，停留为 stale 中间帧（生产 SDK 的
-     * controller.update 经 throttle + setTimeout 异步 resolve，故 flush 与
-     * 下一个 push 交叠是真实场景）。finally 检查此标志后重新 scheduleFlush，
-     * 保证 in-flight 期间累积的事件最终被渲染。
-     */
-    pendingReschedule = false;
-    /**
-     * 当前 in-flight flush 的 promise（若 flush 正在 await updateCard）。
-     * finish() 在终态 patch 前 await 它，保证 in-flight 的 pre-terminal patch
-     * 先落地、terminal patch 后落地——否则两条 controller.update 并发无 FIFO，
-     * pre-terminal 可能在 terminal 之后 resolve 留下"思考中"终帧（P2）。
-     */
-    flushP;
     constructor(opts) {
         super(createInitialRunState(opts.runId), {
             connector: opts.connector,
@@ -35,8 +10,8 @@ export class RunCardSession extends CardSession {
             renderOptions: opts.renderOptions,
             startTimeoutMs: opts.startTimeoutMs,
             settleTimeoutMs: opts.settleTimeoutMs,
+            coalesceMs: opts.coalesceMs,
         });
-        this.coalesceMs = opts.coalesceMs ?? 100;
     }
     get logPrefix() {
         return '[card]';
@@ -53,6 +28,11 @@ export class RunCardSession extends CardSession {
         // enforceCardBudget stringify pass is redundant for run cards.
         return true;
     }
+    isFlushableState() {
+        // finish() 已转终态（done/error/interrupted/idle_timeout）时不再 patch；
+        // 'finalizing' 是非终态，in-flight/延迟 flush 仍可渲染累积事件。
+        return this.state.terminal === 'running' || this.state.terminal === 'finalizing';
+    }
     async push(event) {
         // state 每事件立即 reduce（始终最新），但 updateCard 延迟到合批窗口末尾。
         // 窗口内多次 push 复用同一 flushTimer，只 render + controller.update 一次
@@ -70,75 +50,6 @@ export class RunCardSession extends CardSession {
         }
         this.scheduleFlush();
     }
-    /**
-     * 调度一次延迟 flush。已有 pending 调度则复用（合批核心）；否则起一个
-     * coalesceMs 定时器。flushInFlight 期间不再起 timer（避免重入叠加），但置
-     * pendingReschedule 以便 in-flight flush 完成后重新调度——否则 in-flight 期间
-     * 到达的 push 会停留为 stale 中间帧（P2-1）。
-     */
-    scheduleFlush() {
-        if (this.flushTimer)
-            return;
-        if (this.flushInFlight) {
-            this.pendingReschedule = true;
-            return;
-        }
-        this.flushTimer = setTimeout(() => {
-            this.flushTimer = undefined;
-            void this.flush();
-        }, this.coalesceMs);
-    }
-    /**
-     * 执行一次 render + updateCard。合批窗口到期或 finish 立即 flush 时调用。
-     * flushInFlight 防止 timer 回调与 finish 的即时 flush 重入。
-     *
-     * 终态守卫：若 finish() 已把 state 转为终态（done/error/interrupted/idle_timeout），
-     * 跳过本次 patch——避免 in-flight flush 用 pre-terminal state 覆盖 finish 已发的
-     * 终态卡。finish() 自身会 await 任何 in-flight flush 保证顺序，此守卫是双保险。
-     */
-    async flush() {
-        if (this.flushInFlight)
-            return;
-        // finish() 已转终态：in-flight/延迟 flush 不再用旧 state patch
-        if (this.state.terminal !== 'running' && this.state.terminal !== 'finalizing') {
-            return;
-        }
-        this.flushInFlight = true;
-        const flushPromise = (async () => {
-            try {
-                await this.updateCard();
-            }
-            finally {
-                this.flushInFlight = false;
-                // flushInFlight 守卫保证同一时刻只有一个 in-flight flush，故可无条件清空。
-                this.flushP = undefined;
-                // P2-1：in-flight 期间若有 push 到达（pendingReschedule），重新调度一次
-                // flush 渲染累积事件，避免 stale 中间帧。终态守卫在 flush() 入口已拦截，
-                // 故 finish 后不会误触发。
-                if (this.pendingReschedule) {
-                    this.pendingReschedule = false;
-                    this.scheduleFlush();
-                }
-            }
-        })();
-        this.flushP = flushPromise;
-        return flushPromise;
-    }
-    /**
-     * 取消待 flush 的合批调度（finish/settle 前清理，避免延迟 update 与终态
-     * 渲染竞争）。返回是否有被取消的 pending 调度。同时清掉 pendingReschedule，
-     * 防止 in-flight flush 的 finally 在 finish await 之后又起 dangling timer
-     * （finish 自身会渲染含累积事件的终态卡，无需 follow-up）。
-     */
-    cancelPendingFlush() {
-        this.pendingReschedule = false;
-        if (this.flushTimer) {
-            clearTimeout(this.flushTimer);
-            this.flushTimer = undefined;
-            return true;
-        }
-        return false;
-    }
     async finish(terminal, meta = {}) {
         // 终态必须即时显示（spec）：取消合批窗口，不等延迟 flush 调度。
         this.cancelPendingFlush();
@@ -152,14 +63,5 @@ export class RunCardSession extends CardSession {
         await this.updateCard();
         this.release();
     }
-    /**
-     * settle 前兜底取消合批调度。bridge 正常流程 finish→settle，finish 已 cancel；
-     * 但若未来有直调 settle（未经 finish）的路径，避免 dangling timer 在 release
-     * 后触发 void flush() 去更新已释放的 stream（harmless 但无谓）。
-     */
-    async settle() {
-        this.cancelPendingFlush();
-        return super.settle();
-    }
 }
 //# sourceMappingURL=run-card-session.js.map