@larksuite/openclaw-lark 2025.7.15-beta.0

package/src/card/flush-controller.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Generic throttled flush controller.
+ *
+ * A pure scheduling primitive that manages timer-based throttling,
+ * mutex-guarded flushing, and reflush-on-conflict. Contains no
+ * business logic — the actual flush work is provided via a callback.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlushController = void 0;
+const reply_dispatcher_types_1 = require("./reply-dispatcher-types.js");
+// ---------------------------------------------------------------------------
+// FlushController
+// ---------------------------------------------------------------------------
+class FlushController {
+    doFlush;
+    flushInProgress = false;
+    flushResolvers = [];
+    needsReflush = false;
+    pendingFlushTimer = null;
+    lastUpdateTime = 0;
+    isCompleted = false;
+    constructor(doFlush) {
+        this.doFlush = doFlush;
+    }
+    /** Mark the controller as completed — no more flushes after current one. */
+    complete() {
+        this.isCompleted = true;
+    }
+    /** Cancel any pending deferred flush timer. */
+    cancelPendingFlush() {
+        if (this.pendingFlushTimer) {
+            clearTimeout(this.pendingFlushTimer);
+            this.pendingFlushTimer = null;
+        }
+    }
+    /** Wait for any in-progress flush to finish. */
+    waitForFlush() {
+        if (!this.flushInProgress)
+            return Promise.resolve();
+        return new Promise((resolve) => this.flushResolvers.push(resolve));
+    }
+    /**
+     * Execute a flush (mutex-guarded, with reflush on conflict).
+     *
+     * If a flush is already in progress, marks needsReflush so a
+     * follow-up flush fires immediately after the current one completes.
+     */
+    async flush() {
+        if (!this.cardMessageReady() || this.flushInProgress || this.isCompleted) {
+            if (this.flushInProgress && !this.isCompleted)
+                this.needsReflush = true;
+            return;
+        }
+        this.flushInProgress = true;
+        this.needsReflush = false;
+        // Update timestamp BEFORE the API call to prevent concurrent callers
+        // from also entering the flush (race condition fix).
+        this.lastUpdateTime = Date.now();
+        try {
+            await this.doFlush();
+            this.lastUpdateTime = Date.now();
+        }
+        finally {
+            this.flushInProgress = false;
+            const resolvers = this.flushResolvers;
+            this.flushResolvers = [];
+            for (const resolve of resolvers)
+                resolve();
+            // If events arrived while the API call was in flight,
+            // schedule an immediate follow-up flush.
+            if (this.needsReflush && !this.isCompleted && !this.pendingFlushTimer) {
+                this.needsReflush = false;
+                this.pendingFlushTimer = setTimeout(() => {
+                    this.pendingFlushTimer = null;
+                    void this.flush();
+                }, 0);
+            }
+        }
+    }
+    /**
+     * Throttled update entry point.
+     *
+     * @param throttleMs - Minimum interval between flushes (varies by
+     *   CardKit vs IM patch mode). Passed in by the caller so this
+     *   controller remains business-logic-free.
+     */
+    async throttledUpdate(throttleMs) {
+        if (!this.cardMessageReady())
+            return;
+        const now = Date.now();
+        const elapsed = now - this.lastUpdateTime;
+        if (elapsed >= throttleMs) {
+            this.cancelPendingFlush();
+            if (elapsed > reply_dispatcher_types_1.THROTTLE_CONSTANTS.LONG_GAP_THRESHOLD_MS) {
+                // After a long gap, batch briefly so the first visible update
+                // contains meaningful text rather than just 1-2 characters.
+                this.lastUpdateTime = now;
+                this.pendingFlushTimer = setTimeout(() => {
+                    this.pendingFlushTimer = null;
+                    void this.flush();
+                }, reply_dispatcher_types_1.THROTTLE_CONSTANTS.BATCH_AFTER_GAP_MS);
+            }
+            else {
+                await this.flush();
+            }
+        }
+        else if (!this.pendingFlushTimer) {
+            // Inside throttle window — schedule a deferred flush
+            const delay = throttleMs - elapsed;
+            this.pendingFlushTimer = setTimeout(() => {
+                this.pendingFlushTimer = null;
+                void this.flush();
+            }, delay);
+        }
+    }
+    // ------------------------------------------------------------------
+    // Internal
+    // ------------------------------------------------------------------
+    /** Overridable gate: subclasses / consumers can set via setCardMessageReady. */
+    _cardMessageReady = false;
+    cardMessageReady() {
+        return this._cardMessageReady;
+    }
+    setCardMessageReady(ready) {
+        this._cardMessageReady = ready;
+        if (ready) {
+            // Initialize the timestamp so the first throttledUpdate sees a
+            // small elapsed time (matching original behavior where
+            // lastCardUpdateTime = Date.now() was set during card creation).
+            this.lastUpdateTime = Date.now();
+        }
+    }
+}
+exports.FlushController = FlushController;

package/src/card/image-resolver.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * ImageResolver — converts image URLs in markdown to Feishu image keys.
+ *
+ * Used by StreamingCardController to asynchronously download and upload
+ * images referenced via `![alt](https://...)` in model-generated markdown,
+ * replacing them with `![alt](img_xxx)` that Feishu cards can render.
+ */
+import type { ClawdbotConfig } from 'openclaw/plugin-sdk';
+export interface ImageResolverOptions {
+    cfg: ClawdbotConfig;
+    accountId: string | undefined;
+    /** Called when a previously-pending image upload completes. */
+    onImageResolved: () => void;
+}
+export declare class ImageResolver {
+    /** URL → imageKey for successfully uploaded images. */
+    private readonly resolved;
+    /** URL → upload Promise for in-flight uploads (dedup). */
+    private readonly pending;
+    /** URLs that have already failed — skip retries. */
+    private readonly failed;
+    private readonly cfg;
+    private readonly accountId;
+    private readonly onImageResolved;
+    constructor(opts: ImageResolverOptions);
+    /**
+     * Synchronously resolve image URLs in markdown text.
+     *
+     * - `img_xxx` references are kept as-is.
+     * - URLs with a cached imageKey are replaced inline.
+     * - URLs with an in-flight upload are stripped (will appear after re-flush).
+     * - New URLs trigger an async upload and are stripped for now.
+     */
+    resolveImages(text: string): string;
+    /**
+     * Resolve all image URLs in text synchronously: trigger uploads for new
+     * URLs, wait for all pending uploads, then return text with image keys.
+     */
+    resolveImagesAwait(text: string, timeoutMs: number): Promise<string>;
+    private startUpload;
+    private doUpload;
+}

package/src/card/image-resolver.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * ImageResolver — converts image URLs in markdown to Feishu image keys.
+ *
+ * Used by StreamingCardController to asynchronously download and upload
+ * images referenced via `![alt](https://...)` in model-generated markdown,
+ * replacing them with `![alt](img_xxx)` that Feishu cards can render.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageResolver = void 0;
+const media_1 = require("../messaging/outbound/media.js");
+const lark_logger_1 = require("../core/lark-logger.js");
+const log = (0, lark_logger_1.larkLogger)('card/image-resolver');
+/** Matches complete markdown image syntax: `![alt](value)` */
+const IMAGE_RE = /!\[([^\]]*)\]\(([^)\s]+)\)/g;
+class ImageResolver {
+    /** URL → imageKey for successfully uploaded images. */
+    resolved = new Map();
+    /** URL → upload Promise for in-flight uploads (dedup). */
+    pending = new Map();
+    /** URLs that have already failed — skip retries. */
+    failed = new Set();
+    cfg;
+    accountId;
+    onImageResolved;
+    constructor(opts) {
+        this.cfg = opts.cfg;
+        this.accountId = opts.accountId;
+        this.onImageResolved = opts.onImageResolved;
+    }
+    /**
+     * Synchronously resolve image URLs in markdown text.
+     *
+     * - `img_xxx` references are kept as-is.
+     * - URLs with a cached imageKey are replaced inline.
+     * - URLs with an in-flight upload are stripped (will appear after re-flush).
+     * - New URLs trigger an async upload and are stripped for now.
+     */
+    resolveImages(text) {
+        if (!text.includes('!['))
+            return text;
+        return text.replace(IMAGE_RE, (fullMatch, alt, value) => {
+            // Already a Feishu image key — keep.
+            if (value.startsWith('img_'))
+                return fullMatch;
+            // Not a remote URL — strip (local paths, data URIs, etc.).
+            if (!value.startsWith('http://') && !value.startsWith('https://'))
+                return '';
+            // Cached — replace with image key.
+            const cached = this.resolved.get(value);
+            if (cached)
+                return `![${alt}](${cached})`;
+            // Already failed — don't retry, strip.
+            if (this.failed.has(value))
+                return '';
+            // Upload in progress — strip for now.
+            if (this.pending.has(value))
+                return '';
+            // New URL — kick off async upload, strip for now.
+            this.startUpload(value);
+            return '';
+        });
+    }
+    /**
+     * Resolve all image URLs in text synchronously: trigger uploads for new
+     * URLs, wait for all pending uploads, then return text with image keys.
+     */
+    async resolveImagesAwait(text, timeoutMs) {
+        // First pass: trigger uploads for any new URLs
+        this.resolveImages(text);
+        if (this.pending.size > 0) {
+            log.info('resolveImagesAwait: waiting for uploads', { count: this.pending.size, timeoutMs });
+            const allUploads = Promise.all(this.pending.values());
+            const timeout = new Promise((resolve) => setTimeout(resolve, timeoutMs));
+            await Promise.race([allUploads, timeout]);
+            if (this.pending.size > 0) {
+                log.warn('resolveImagesAwait: timed out with pending uploads', {
+                    remaining: this.pending.size,
+                });
+            }
+        }
+        // Second pass: replace URLs with resolved image keys
+        return this.resolveImages(text);
+    }
+    startUpload(url) {
+        const uploadPromise = this.doUpload(url);
+        this.pending.set(url, uploadPromise);
+    }
+    async doUpload(url) {
+        try {
+            log.info('uploading image', { url });
+            const buffer = await (0, media_1.fetchRemoteImageBuffer)(url);
+            const { imageKey } = await (0, media_1.uploadImageLark)({
+                cfg: this.cfg,
+                image: buffer,
+                imageType: 'message',
+                accountId: this.accountId,
+            });
+            log.info('image uploaded', { url, imageKey });
+            this.resolved.set(url, imageKey);
+            this.pending.delete(url);
+            this.onImageResolved();
+            return imageKey;
+        }
+        catch (err) {
+            log.warn('image upload failed', { url, error: String(err) });
+            this.pending.delete(url);
+            this.failed.add(url);
+            return null;
+        }
+    }
+}
+exports.ImageResolver = ImageResolver;

package/src/card/markdown-style.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Markdown 样式优化工具
+ */
+/**
+ * 优化 Markdown 样式：
+ * - 标题降级：H1 → H4，H2~H6 → H5
+ * - 表格前后增加段落间距
+ * - 有序列表：序号后确保只有一个空格
+ * - 无序列表："- " 格式规范化（跳过分隔线 ---）
+ * - 表格：单元格前后补空格，分隔符行规范化，表格前后加空行
+ * - 代码块内容不受影响
+ */
+export declare function optimizeMarkdownStyle(text: string, cardVersion?: number): string;

package/src/card/markdown-style.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Markdown 样式优化工具
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimizeMarkdownStyle = optimizeMarkdownStyle;
+/**
+ * 优化 Markdown 样式：
+ * - 标题降级：H1 → H4，H2~H6 → H5
+ * - 表格前后增加段落间距
+ * - 有序列表：序号后确保只有一个空格
+ * - 无序列表："- " 格式规范化（跳过分隔线 ---）
+ * - 表格：单元格前后补空格，分隔符行规范化，表格前后加空行
+ * - 代码块内容不受影响
+ */
+function optimizeMarkdownStyle(text, cardVersion = 2) {
+    try {
+        let r = _optimizeMarkdownStyle(text, cardVersion);
+        r = stripInvalidImageKeys(r);
+        return r;
+    }
+    catch {
+        return text;
+    }
+}
+function _optimizeMarkdownStyle(text, cardVersion = 2) {
+    // ── 1. 提取代码块，用占位符保护，处理后再还原 ─────────────────────
+    const MARK = '___CB_';
+    const codeBlocks = [];
+    let r = text.replace(/(^|\n)(`{3,})([^\n]*)\n[\s\S]*?\n\2(?=\n|$)/g, (m, prefix = '') => {
+        const block = m.slice(String(prefix).length);
+        return `${prefix}${MARK}${codeBlocks.push(block) - 1}___`;
+    });
+    // ── 2. 标题降级 ────────────────────────────────────────────────────
+    // 只有当原文档包含 h1~h3 标题时才执行降级
+    // 先处理 H2~H6 → H5，再处理 H1 → H4
+    // 顺序不能颠倒：若先 H1→H4，H4（####）会被后面的 #{2,6} 再次匹配成 H5
+    const hasH1toH3 = /^#{1,3} /m.test(text);
+    if (hasH1toH3) {
+        r = r.replace(/^#{2,6} (.+)$/gm, '##### $1'); // H2~H6 → H5
+        r = r.replace(/^# (.+)$/gm, '#### $1'); // H1 → H4
+    }
+    if (cardVersion >= 2) {
+        // ── 3. 连续标题间增加段落间距 ───────────────────────────────────────
+        r = r.replace(/^(#{4,5} .+)\n{1,2}(#{4,5} )/gm, '$1\n<br>\n$2');
+        // ── 4. 表格前后增加段落间距 ─────────────────────────────────────────
+        // 4a. 非表格行直接跟表格行时，先补一个空行
+        r = r.replace(/^([^|\n].*)\n(\|.+\|)/gm, '$1\n\n$2');
+        // 4b. 表格前：在空行之前插入 <br>（即 \n\n| → \n<br>\n\n| ）
+        r = r.replace(/\n\n((?:\|.+\|[^\S\n]*\n?)+)/g, '\n\n<br>\n\n$1');
+        // 4c. 表格后：在表格块末尾追加 <br>（跳过后接分隔线/标题/加粗/文末的情况）
+        r = r.replace(/((?:^\|.+\|[^\S\n]*\n?)+)/gm, (m, _table, offset) => {
+            const after = r.slice(offset + m.length).replace(/^\n+/, '');
+            if (!after || /^(---|#{4,5} |\*\*)/.test(after))
+                return m;
+            return m + '\n<br>\n';
+        });
+        // 4d. 表格前是普通文本（非标题、非加粗行）时，只需 <br>，去掉多余空行
+        //     "text\n\n<br>\n\n|" → "text\n<br>\n|"
+        r = r.replace(/^((?!#{4,5} )(?!\*\*).+)\n\n(<br>)\n\n(\|)/gm, '$1\n$2\n$3');
+        // 4d2. 表格前是加粗行时，<br> 紧贴加粗行，空行保留在后面
+        //     "**bold**\n\n<br>\n\n|" → "**bold**\n<br>\n\n|"
+        r = r.replace(/^(\*\*.+)\n\n(<br>)\n\n(\|)/gm, '$1\n$2\n\n$3');
+        // 4e. 表格后是普通文本（非标题、非加粗行）时，只需 <br>，去掉多余空行
+        //     "| row |\n\n<br>\ntext" → "| row |\n<br>\ntext"
+        r = r.replace(/(\|[^\n]*\n)\n(<br>\n)((?!#{4,5} )(?!\*\*))/gm, '$1$2$3');
+        // ── 5. 还原代码块，并在前后追加 <br> ──────────────────────────────
+        codeBlocks.forEach((block, i) => {
+            r = r.replace(`${MARK}${i}___`, `\n<br>\n${block}\n<br>\n`);
+        });
+    }
+    else {
+        // ── 5. 还原代码块（无 <br>）───────────────────────────────────────
+        codeBlocks.forEach((block, i) => {
+            r = r.replace(`${MARK}${i}___`, block);
+        });
+    }
+    // ── 6. 压缩多余空行（3 个以上连续换行 → 2 个）────────────────────
+    r = r.replace(/\n{3,}/g, '\n\n');
+    return r;
+}
+// ---------------------------------------------------------------------------
+// stripInvalidImageKeys
+// ---------------------------------------------------------------------------
+/** Matches complete markdown image syntax: `![alt](value)` */
+const IMAGE_RE = /!\[([^\]]*)\]\(([^)\s]+)\)/g;
+/**
+ * Strip `![alt](value)` where value is not a valid Feishu image key
+ * (`img_xxx`). Prevents CardKit error 200570.
+ *
+ * HTTP URLs are stripped as well — ImageResolver should have already
+ * replaced them with `img_xxx` keys before this point. This serves
+ * as a safety net for any unresolved URLs.
+ */
+function stripInvalidImageKeys(text) {
+    if (!text.includes('!['))
+        return text;
+    return text.replace(IMAGE_RE, (fullMatch, _alt, value) => {
+        if (value.startsWith('img_'))
+            return fullMatch;
+        return ''; // strip all non-img_ image references (URLs, local paths, etc.)
+    });
+}

package/src/card/reasoning-utils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Shared utilities for the reasoning display subsystem.
+ */
+export declare function normalizeToolName(name?: string): string;
+export declare function truncateText(value: string, maxLength: number): string;
+export declare function redactInlineSecrets(value: string): string;
+/**
+ * Sanitize tool params for safe logging.
+ * Logs only param key names (no values) to avoid leaking sensitive data.
+ */
+export declare function sanitizeParamsForLog(params?: Record<string, unknown>): string;

package/src/card/reasoning-utils.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Shared utilities for the reasoning display subsystem.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeToolName = normalizeToolName;
+exports.truncateText = truncateText;
+exports.redactInlineSecrets = redactInlineSecrets;
+exports.sanitizeParamsForLog = sanitizeParamsForLog;
+function normalizeToolName(name) {
+    return name?.trim().toLowerCase() ?? '';
+}
+function truncateText(value, maxLength) {
+    if (value.length <= maxLength)
+        return value;
+    return `${value.slice(0, maxLength - 3)}...`;
+}
+const INLINE_ASSIGNMENT_RE = /(^|[\s"'`])([A-Za-z_][A-Za-z0-9_]*)(=(?:"[^"]*"|'[^']*'|[^\s"'`]+))/g;
+const AUTH_HEADER_SECRET_RE = /(Authorization\s*:\s*(?:Bearer|Basic|Token)\s+)([^'"\s]+)/gi;
+const QUOTED_HEADER_ARG_RE = /((?:^|[\s"'`])(?:-H|--header)\s+)(['"])([A-Za-z0-9_-]+)(\s*:\s*)([^'"]*)(\2)/gi;
+const UNQUOTED_HEADER_ARG_RE = /((?:^|[\s"'`])(?:-H|--header)\s+)([A-Za-z0-9_-]+)(\s*:\s*)([^\s"'`]+)/gi;
+const SECRET_FLAG_RE = /((?:^|[\s"'`]))(--?[A-Za-z0-9][A-Za-z0-9-]*)(=|\s+)(?:"([^"]*)"|'([^']*)'|([^\s"'`]+))/g;
+const SENSITIVE_NAME_RE = /token|secret|password|api[_-]?key|authorization|cookie|credential|bearer|session[_-]?id|client[_-]?secret|access[_-]?key/i;
+function redactInlineSecrets(value) {
+    return value
+        .replace(INLINE_ASSIGNMENT_RE, (match, prefix, key) => isSensitiveName(key) ? `${prefix}${key}=[redacted]` : match)
+        .replace(AUTH_HEADER_SECRET_RE, '$1[redacted]')
+        .replace(QUOTED_HEADER_ARG_RE, (match, prefix, quote, name, separator) => shouldRedactHeaderValue(name) ? `${prefix}${quote}${name}${separator}[redacted]${quote}` : match)
+        .replace(UNQUOTED_HEADER_ARG_RE, (match, prefix, name, separator) => shouldRedactHeaderValue(name) ? `${prefix}${name}${separator}[redacted]` : match)
+        .replace(SECRET_FLAG_RE, (match, prefix, flag, separator, doubleQuoted, singleQuoted, bare) => {
+        const normalizedFlag = flag.replace(/^-+/, '');
+        if (!isSensitiveName(normalizedFlag))
+            return match;
+        const redactedValue = doubleQuoted !== undefined
+            ? '"[redacted]"'
+            : singleQuoted !== undefined
+                ? "'[redacted]'"
+                : bare !== undefined
+                    ? '[redacted]'
+                    : '[redacted]';
+        return `${prefix}${flag}${separator}${redactedValue}`;
+    });
+}
+function isSensitiveName(value) {
+    return SENSITIVE_NAME_RE.test(value);
+}
+function shouldRedactHeaderValue(name) {
+    return !/^authorization$/i.test(name) && isSensitiveName(name);
+}
+/**
+ * Sanitize tool params for safe logging.
+ * Logs only param key names (no values) to avoid leaking sensitive data.
+ */
+function sanitizeParamsForLog(params) {
+    if (!params || typeof params !== 'object')
+        return '';
+    const keys = Object.keys(params);
+    if (keys.length === 0)
+        return '{}';
+    return `{${keys.join(',')}}`;
+}

package/src/card/reply-dispatcher-types.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Type definitions for the Feishu reply dispatcher subsystem.
+ *
+ * Consolidates all interfaces, state shapes, and constants used across
+ * reply-dispatcher.ts, streaming-card-controller.ts, flush-controller.ts,
+ * and unavailable-guard.ts.
+ */
+import type { ClawdbotConfig } from 'openclaw/plugin-sdk';
+import type { ReplyDispatcher } from 'openclaw/plugin-sdk/reply-runtime';
+import type { FeishuFooterConfig } from '../core/types';
+import type { ToolUseDisplayConfig } from './tool-use-config';
+export declare const CARD_PHASES: {
+    readonly idle: "idle";
+    readonly creating: "creating";
+    readonly streaming: "streaming";
+    readonly completed: "completed";
+    readonly aborted: "aborted";
+    readonly terminated: "terminated";
+    readonly creation_failed: "creation_failed";
+};
+export type CardPhase = (typeof CARD_PHASES)[keyof typeof CARD_PHASES];
+export declare const TERMINAL_PHASES: ReadonlySet<CardPhase>;
+/**
+ * Why a terminal phase was entered.
+ *
+ * - `normal`          — streaming completed successfully (onIdle).
+ * - `error`           — an error occurred during reply generation (onError).
+ * - `abort`           — explicitly cancelled by the caller (abortCard).
+ * - `unavailable`     — source message was deleted/recalled (UnavailableGuard).
+ * - `creation_failed` — card creation failed, falling back to static delivery.
+ */
+export type TerminalReason = 'normal' | 'error' | 'abort' | 'unavailable' | 'creation_failed';
+export declare const PHASE_TRANSITIONS: Record<CardPhase, ReadonlySet<CardPhase>>;
+export interface ReasoningState {
+    accumulatedReasoningText: string;
+    reasoningStartTime: number | null;
+    reasoningElapsedMs: number;
+    isReasoningPhase: boolean;
+}
+export interface ToolUseState {
+    startedAt: number | null;
+    elapsedMs: number;
+    isActive: boolean;
+}
+export interface StreamingTextState {
+    accumulatedText: string;
+    completedText: string;
+    streamingPrefix: string;
+    lastPartialText: string;
+    lastFlushedText: string;
+}
+export interface CardKitState {
+    cardKitCardId: string | null;
+    originalCardKitCardId: string | null;
+    cardKitSequence: number;
+    cardMessageId: string | null;
+}
+/**
+ * Throttle intervals for card updates.
+ *
+ * - `CARDKIT_MS`: CardKit `cardElement.content()` — designed for streaming,
+ *   low throttle is fine.
+ * - `PATCH_MS`: `im.message.patch` — strict rate limits (code 230020).
+ * - `LONG_GAP_THRESHOLD_MS`: After a long idle gap (tool call / LLM thinking),
+ *   defer the first flush briefly.
+ * - `BATCH_AFTER_GAP_MS`: Batching window after a long gap.
+ */
+export declare const THROTTLE_CONSTANTS: {
+    readonly CARDKIT_MS: 100;
+    readonly PATCH_MS: 1500;
+    readonly LONG_GAP_THRESHOLD_MS: 2000;
+    readonly BATCH_AFTER_GAP_MS: 300;
+    readonly REASONING_STATUS_MS: 1500;
+};
+export declare const EMPTY_REPLY_FALLBACK_TEXT = "Done.";
+export interface CreateFeishuReplyDispatcherParams {
+    cfg: ClawdbotConfig;
+    agentId: string;
+    sessionKey: string;
+    chatId: string;
+    replyToMessageId?: string;
+    /** Account ID for multi-account support. */
+    accountId?: string;
+    /** Chat type for scene-aware reply mode selection. */
+    chatType?: 'p2p' | 'group';
+    /** When true, typing indicators are suppressed entirely. */
+    skipTyping?: boolean;
+    /** When true, replies are sent into the thread instead of main chat. */
+    replyInThread?: boolean;
+    /** Thread root id when the reply lives inside a thread; used for sentinel keying. */
+    threadId?: string;
+    toolUseDisplay: ToolUseDisplayConfig;
+}
+/**
+ * The structured return type of createFeishuReplyDispatcher.
+ *
+ * `replyOptions` is typed as `Record<string, unknown>` because the consumer
+ * (`dispatchReplyFromConfig`) accepts the SDK-internal `GetReplyOptions`
+ * which is not re-exported from `openclaw/plugin-sdk`. The record type
+ * is compatible with spread-assignment into `dispatchReplyFromConfig`.
+ */
+export interface FeishuReplyDispatcherResult {
+    dispatcher: ReplyDispatcher;
+    replyOptions: Record<string, unknown>;
+    markDispatchIdle: () => void;
+    markFullyComplete: () => void;
+    abortCard: () => Promise<void>;
+}
+export interface FooterSessionMetrics {
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    totalTokens?: number;
+    totalTokensFresh?: boolean;
+    contextTokens?: number;
+    model?: string;
+}
+export interface StreamingCardDeps {
+    cfg: ClawdbotConfig;
+    agentId: string;
+    sessionKey: string;
+    accountId: string | undefined;
+    chatId: string;
+    replyToMessageId: string | undefined;
+    replyInThread: boolean | undefined;
+    toolUseDisplay: ToolUseDisplayConfig;
+    resolvedFooter: Required<FeishuFooterConfig>;
+}