@wu529778790/open-im 1.2.4-beta.2 → 1.3.0

package/dist/constants.d.ts

@@ -5,8 +5,10 @@ export declare const IMAGE_DIR: string;
 export declare const READ_ONLY_TOOLS: string[];
 export declare const TERMINAL_ONLY_COMMANDS: Set<string>;
 export declare const DEDUP_TTL_MS: number;
-/** 飞书流式更新节流：350ms 留出余量（官方 5 QPS 限制），配合块级流式减少 patch 次数 */
-export declare const FEISHU_THROTTLE_MS = 350;
+/** 飞书 patch 节流（旧方案，5 QPS） */
+export declare const FEISHU_THROTTLE_MS = 200;
+/** CardKit 流式更新节流：80ms（约 12 次/秒，cardElement.content 专为打字机设计，支持更高频率） */
+export declare const CARDKIT_THROTTLE_MS = 80;
 /** Telegram 编辑消息节流：200ms（open-im 默认值） */
 export declare const TELEGRAM_THROTTLE_MS = 200;
 /** WeChat 流式更新节流：1000ms（AGP 协议建议值） */
@@ -14,5 +16,7 @@ export declare const WECHAT_THROTTLE_MS = 1000;
 export declare const WEWORK_THROTTLE_MS = 500;
 export declare const MAX_TELEGRAM_MESSAGE_LENGTH = 4000;
 export declare const MAX_FEISHU_MESSAGE_LENGTH = 4000;
+/** CardKit 流式内容最大长度（卡片上限约 30KB，留余量） */
+export declare const MAX_STREAMING_CONTENT_LENGTH = 25000;
 export declare const MAX_WECHAT_MESSAGE_LENGTH = 2048;
 export declare const MAX_WEWORK_MESSAGE_LENGTH = 2048;

package/dist/constants.js

@@ -34,8 +34,10 @@ export const TERMINAL_ONLY_COMMANDS = new Set([
     "/add-dir",
 ]);
 export const DEDUP_TTL_MS = 5 * 60 * 1000;
-/** 飞书流式更新节流：350ms 留出余量（官方 5 QPS 限制），配合块级流式减少 patch 次数 */
-export const FEISHU_THROTTLE_MS = 350;
+/** 飞书 patch 节流（旧方案，5 QPS） */
+export const FEISHU_THROTTLE_MS = 200;
+/** CardKit 流式更新节流：80ms（约 12 次/秒，cardElement.content 专为打字机设计，支持更高频率） */
+export const CARDKIT_THROTTLE_MS = 80;
 /** Telegram 编辑消息节流：200ms（open-im 默认值） */
 export const TELEGRAM_THROTTLE_MS = 200;
 /** WeChat 流式更新节流：1000ms（AGP 协议建议值） */
@@ -43,5 +45,7 @@ export const WECHAT_THROTTLE_MS = 1000;
 export const WEWORK_THROTTLE_MS = 500;
 export const MAX_TELEGRAM_MESSAGE_LENGTH = 4000;
 export const MAX_FEISHU_MESSAGE_LENGTH = 4000;
+/** CardKit 流式内容最大长度（卡片上限约 30KB，留余量） */
+export const MAX_STREAMING_CONTENT_LENGTH = 25000;
 export const MAX_WECHAT_MESSAGE_LENGTH = 2048;
 export const MAX_WEWORK_MESSAGE_LENGTH = 2048;

package/dist/feishu/card-builder.d.ts

@@ -0,0 +1,17 @@
+/**
+ * CardKit 2.0 卡片构建 - 支持打字机流式效果
+ * 参考 cc-im: https://github.com/congqiu/cc-im
+ */
+export type CardStatus = 'processing' | 'thinking' | 'streaming' | 'done' | 'error';
+interface CardOptions {
+    content: string;
+    status: CardStatus;
+    note?: string;
+    thinking?: string;
+}
+export declare function truncateForStreaming(text: string): string;
+/** CardKit 2.0 格式，含 element_id 供 cardElement.content 流式更新 */
+export declare function buildCardV2Object(options: CardOptions, cardId?: string): Record<string, unknown>;
+export declare function buildCardV2(options: CardOptions, cardId?: string): string;
+export declare function splitLongContent(text: string, maxLen?: number): string[];
+export {};

package/dist/feishu/card-builder.js

@@ -0,0 +1,84 @@
+/**
+ * CardKit 2.0 卡片构建 - 支持打字机流式效果
+ * 参考 cc-im: https://github.com/congqiu/cc-im
+ */
+import { MAX_STREAMING_CONTENT_LENGTH, MAX_FEISHU_MESSAGE_LENGTH } from '../constants.js';
+import { splitLongContent as sharedSplitLongContent, truncateText } from '../shared/utils.js';
+const HEADER_TEMPLATES = {
+    processing: 'blue',
+    thinking: 'blue',
+    streaming: 'blue',
+    done: 'green',
+    error: 'red',
+};
+const HEADER_TITLES = {
+    processing: 'Claude Code - 处理中...',
+    thinking: 'Claude Code - 思考中...',
+    streaming: 'Claude Code',
+    done: 'Claude Code',
+    error: 'Claude Code - 错误',
+};
+export function truncateForStreaming(text) {
+    return truncateText(text, MAX_STREAMING_CONTENT_LENGTH);
+}
+/** CardKit 2.0 格式，含 element_id 供 cardElement.content 流式更新 */
+export function buildCardV2Object(options, cardId) {
+    const { content, status, note, thinking } = options;
+    const elements = [];
+    // 完成状态下，如果有思考过程，添加折叠面板
+    if (status === 'done' && thinking) {
+        elements.push({
+            tag: 'collapsible_panel',
+            expanded: false,
+            header: {
+                title: { tag: 'markdown', content: '💭 **思考过程**' },
+            },
+            border: { color: 'grey' },
+            elements: [{ tag: 'markdown', content: thinking }],
+        });
+    }
+    elements.push({
+        tag: 'markdown',
+        content: truncateForStreaming(content) || '...',
+        element_id: 'main_content',
+    });
+    elements.push({
+        tag: 'markdown',
+        content: note || '',
+        text_size: 'notation',
+        element_id: 'note_area',
+    });
+    // 在处理中、思考中和流式输出状态时添加停止按钮
+    if ((status === 'processing' || status === 'thinking' || status === 'streaming') &&
+        cardId) {
+        elements.push({
+            tag: 'button',
+            text: { tag: 'plain_text', content: '⏹️ 停止' },
+            type: 'danger',
+            value: { action: 'stop', card_id: cardId },
+            element_id: 'action_stop',
+        });
+    }
+    const isActive = status === 'processing' || status === 'thinking' || status === 'streaming';
+    return {
+        schema: '2.0',
+        config: {
+            update_multi: true,
+            ...(isActive ? { streaming_mode: true } : {}),
+        },
+        header: {
+            template: HEADER_TEMPLATES[status],
+            title: { tag: 'plain_text', content: HEADER_TITLES[status] },
+        },
+        body: {
+            direction: 'vertical',
+            elements,
+        },
+    };
+}
+export function buildCardV2(options, cardId) {
+    return JSON.stringify(buildCardV2Object(options, cardId));
+}
+export function splitLongContent(text, maxLen = MAX_FEISHU_MESSAGE_LENGTH) {
+    return sharedSplitLongContent(text, maxLen);
+}

package/dist/feishu/cardkit-manager.d.ts

@@ -0,0 +1,19 @@
+/**
+ * CardKit 流式卡片管理 - 打字机效果
+ * 参考 cc-im: https://github.com/congqiu/cc-im
+ */
+export declare function stopCleanupTimer(): void;
+/** 创建 CardKit 卡片实例 */
+export declare function createCard(cardJson: string): Promise<string>;
+/** 启用流式模式 */
+export declare function enableStreaming(cardId: string): Promise<void>;
+/** 流式更新元素内容（打字机效果） */
+export declare function streamContent(cardId: string, elementId: string, content: string): Promise<void>;
+/** 全量更新卡片（完成/错误状态） */
+export declare function updateCardFull(cardId: string, cardJson: string): Promise<void>;
+/** 通过 card_id 发送卡片消息到聊天 */
+export declare function sendCardMessage(chatId: string, cardId: string): Promise<string>;
+/** 关闭流式模式 */
+export declare function disableStreaming(cardId: string): Promise<void>;
+export declare function markCompleted(cardId: string): void;
+export declare function destroySession(cardId: string): void;

package/dist/feishu/cardkit-manager.js

@@ -0,0 +1,243 @@
+/**
+ * CardKit 流式卡片管理 - 打字机效果
+ * 参考 cc-im: https://github.com/congqiu/cc-im
+ */
+import { getClient } from './client.js';
+import { createLogger } from '../logger.js';
+import { withRetry, NonRetryableError } from '../shared/retry.js';
+const log = createLogger('CardKit');
+const MAX_REENABLE_ATTEMPTS = 3;
+const SESSION_TTL_MS = 60 * 60 * 1000;
+const CLEANUP_INTERVAL_MS = 10 * 60 * 1000;
+const sessions = new Map();
+let cleanupTimer = null;
+function ensureCleanupTimer() {
+    if (cleanupTimer)
+        return;
+    cleanupTimer = setInterval(() => {
+        const now = Date.now();
+        for (const [id, s] of sessions) {
+            if (now - s.createdAt > SESSION_TTL_MS) {
+                sessions.delete(id);
+                log.info(`Auto-cleaned expired card session: ${id}`);
+            }
+        }
+    }, CLEANUP_INTERVAL_MS);
+    cleanupTimer.unref?.();
+}
+export function stopCleanupTimer() {
+    if (cleanupTimer) {
+        clearInterval(cleanupTimer);
+        cleanupTimer = null;
+    }
+}
+function nextSeq(cardId) {
+    const s = sessions.get(cardId);
+    if (!s)
+        return -1;
+    s.sequence += 1;
+    return s.sequence;
+}
+/** 创建 CardKit 卡片实例 */
+export async function createCard(cardJson) {
+    ensureCleanupTimer();
+    const client = getClient();
+    const res = await client.cardkit.v1.card.create({
+        data: { type: 'card_json', data: cardJson },
+    });
+    const cardId = res.data?.card_id;
+    if (!cardId) {
+        log.error('card.create response:', JSON.stringify(res, null, 2));
+        throw new Error(`card.create returned no card_id (code=${res.code}, msg=${res.msg})`);
+    }
+    sessions.set(cardId, {
+        cardId,
+        sequence: 0,
+        streamingEnabled: false,
+        completed: false,
+        createdAt: Date.now(),
+        reenableFailCount: 0,
+    });
+    log.debug(`Card created: ${cardId}`);
+    return cardId;
+}
+/** 启用流式模式 */
+export async function enableStreaming(cardId) {
+    await withRetry(async () => {
+        const s = sessions.get(cardId);
+        if (s?.completed)
+            return;
+        const client = getClient();
+        const res = await client.cardkit.v1.card.settings({
+            path: { card_id: cardId },
+            data: {
+                settings: JSON.stringify({ streaming_mode: true }),
+                sequence: nextSeq(cardId),
+            },
+        });
+        if (res?.code && res.code !== 0) {
+            if (res.code === 200400) {
+                log.warn(`enableStreaming rate limited: ${res.msg}`);
+                throw new NonRetryableError(`enableStreaming rate limited: code=${res.code}, msg=${res.msg}`);
+            }
+            log.error(`enableStreaming failed: code=${res.code}, msg=${res.msg}`);
+            throw new Error(`enableStreaming error: code=${res.code}, msg=${res.msg}`);
+        }
+        if (s)
+            s.streamingEnabled = true;
+        log.debug(`Streaming enabled for card ${cardId}`);
+    });
+}
+/** 流式更新元素内容（打字机效果） */
+export async function streamContent(cardId, elementId, content) {
+    const client = getClient();
+    const call = async (s) => {
+        return await client.cardkit.v1.cardElement.content({
+            path: { card_id: cardId, element_id: elementId },
+            data: { content, sequence: s },
+        });
+    };
+    const seq = nextSeq(cardId);
+    if (seq === -1)
+        return;
+    let res;
+    try {
+        res = await call(seq);
+    }
+    catch (err) {
+        const respData = err?.response?.data;
+        if (respData?.code === 99991400)
+            return;
+        log.warn(`streamContent exception: ${err?.message ?? err}`);
+        return;
+    }
+    const code = res?.code;
+    if (!code || code === 0) {
+        const s = sessions.get(cardId);
+        if (s)
+            s.reenableFailCount = 0;
+        return;
+    }
+    if (code === 200810)
+        return;
+    if (code === 300317)
+        return;
+    if (code === 200400)
+        return;
+    if (code === 200937)
+        return;
+    if (code === 200740)
+        return;
+    if (code === 200850 || code === 300309) {
+        const s = sessions.get(cardId);
+        if (!s || s.completed)
+            return;
+        if (s.reenableFailCount >= MAX_REENABLE_ATTEMPTS)
+            return;
+        log.warn(`Streaming closed/timeout (${code}) for card ${cardId}, re-enabling...`);
+        try {
+            await enableStreaming(cardId);
+            const s2 = sessions.get(cardId);
+            if (!s2 || s2.completed)
+                return;
+            const retryRes = await call(nextSeq(cardId));
+            if (retryRes?.code && retryRes.code !== 0) {
+                s.reenableFailCount++;
+                log.warn(`Retry still failed: code=${retryRes.code}, skipping (${s.reenableFailCount}/${MAX_REENABLE_ATTEMPTS})`);
+            }
+            else {
+                s.reenableFailCount = 0;
+            }
+        }
+        catch {
+            s.reenableFailCount++;
+            log.warn(`Re-enable failed for card ${cardId}, skipping (${s.reenableFailCount}/${MAX_REENABLE_ATTEMPTS})`);
+        }
+        return;
+    }
+    log.error(`streamContent failed: code=${code}, msg=${res.msg}`);
+}
+/** 全量更新卡片（完成/错误状态） */
+export async function updateCardFull(cardId, cardJson) {
+    await withRetry(async () => {
+        const client = getClient();
+        const res = await client.cardkit.v1.card.update({
+            path: { card_id: cardId },
+            data: {
+                card: { type: 'card_json', data: cardJson },
+                sequence: nextSeq(cardId),
+            },
+        });
+        const code = res?.code;
+        if (code && code !== 0) {
+            if (code === 200810 || code === 300317)
+                return;
+            log.error(`updateCardFull failed: code=${code}, msg=${res.msg}`);
+            throw new Error(`updateCardFull error: code=${code}, msg=${res.msg}`);
+        }
+        log.debug(`Card ${cardId} fully updated`);
+    });
+}
+/** 通过 card_id 发送卡片消息到聊天 */
+export async function sendCardMessage(chatId, cardId) {
+    const client = getClient();
+    const content = JSON.stringify({ type: 'card', data: { card_id: cardId } });
+    const res = await (client.im.v1?.message ?? client.im.message).create({
+        params: { receive_id_type: 'chat_id' },
+        data: {
+            receive_id: chatId,
+            content,
+            msg_type: 'interactive',
+        },
+    });
+    const messageId = res.data?.message_id ?? '';
+    log.debug(`Card message sent: messageId=${messageId}, cardId=${cardId}`);
+    return messageId;
+}
+/** 关闭流式模式 */
+export async function disableStreaming(cardId) {
+    const s = sessions.get(cardId);
+    if (!s || !s.streamingEnabled)
+        return;
+    s.completed = true;
+    try {
+        await withRetry(async () => {
+            const client = getClient();
+            const seq = nextSeq(cardId);
+            if (seq === -1)
+                return;
+            const res = await client.cardkit.v1.card.settings({
+                path: { card_id: cardId },
+                data: {
+                    settings: JSON.stringify({ streaming_mode: false }),
+                    sequence: seq,
+                },
+            });
+            if (res?.code && res.code !== 0) {
+                if (res.code === 200400) {
+                    throw new Error(`disableStreaming rate limited: code=${res.code}, msg=${res.msg}`);
+                }
+                log.warn(`disableStreaming failed: code=${res.code}, msg=${res.msg}`);
+            }
+            else {
+                s.streamingEnabled = false;
+                log.debug(`Streaming disabled for card ${cardId}`);
+            }
+        }, { maxRetries: 3, baseDelayMs: 500 });
+    }
+    catch (err) {
+        log.warn(`disableStreaming error for card ${cardId}:`, err);
+    }
+    finally {
+        s.streamingEnabled = false;
+    }
+}
+export function markCompleted(cardId) {
+    const s = sessions.get(cardId);
+    if (s)
+        s.completed = true;
+}
+export function destroySession(cardId) {
+    sessions.delete(cardId);
+    log.debug(`Session destroyed for card ${cardId}`);
+}

package/dist/feishu/event-handler.js

@@ -2,15 +2,17 @@ import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { AccessControl } from '../access/access-control.js';
 import { RequestQueue } from '../queue/request-queue.js';
-import { sendThinkingMessage, updateMessage, sendFinalMessages, sendTextReply, sendTextReplyByOpenId, startTypingLoop, sendImageReply, createFeishuButtonCard, sendModeCard, createFeishuModeCardReadOnly, delayUpdateCard, } from './message-sender.js';
+import { sendTextReply, sendTextReplyByOpenId, startTypingLoop, sendImageReply, createFeishuButtonCard, sendModeCard, createFeishuModeCardReadOnly, delayUpdateCard, sendThinkingCard, streamContentUpdate, sendFinalCards, sendErrorCard, } from './message-sender.js';
 import { registerPermissionSender, resolvePermissionById } from '../hook/permission-server.js';
 import { setPermissionMode } from '../permission-mode/session-mode.js';
 import { MODE_LABELS } from '../permission-mode/types.js';
 import { CommandHandler } from '../commands/handler.js';
 import { getAdapter } from '../adapters/registry.js';
 import { runAITask } from '../shared/ai-task.js';
+import { buildCardV2 } from './card-builder.js';
+import { disableStreaming, updateCardFull, destroySession } from './cardkit-manager.js';
 import { startTaskCleanup } from '../shared/task-cleanup.js';
-import { FEISHU_THROTTLE_MS, IMAGE_DIR } from '../constants.js';
+import { CARDKIT_THROTTLE_MS, IMAGE_DIR } from '../constants.js';
 import { setActiveChatId } from '../shared/active-chats.js';
 import { setChatUser } from '../shared/chat-user-map.js';
 import { createLogger } from '../logger.js';
@@ -127,34 +129,30 @@ export function setupFeishuHandlers(config, sessionManager) {
         const sessionId = convId ? sessionManager.getSessionIdForConv(userId, convId) : undefined;
         log.info(`[handleAIRequest] Running ${config.aiCommand} for user ${userId}, sessionId=${sessionId ?? 'new'}`);
         const toolId = config.aiCommand;
-        let msgId;
+        // 使用 CardKit 打字机效果（80ms 节流，约 12 次/秒，比 patch 5 QPS 更流畅）
+        let cardHandle;
         try {
-            msgId = await sendThinkingMessage(chatId, replyToMessageId, toolId);
+            cardHandle = await sendThinkingCard(chatId, toolId);
         }
         catch (err) {
-            log.error('Failed to send thinking message:', err);
+            log.error('Failed to send thinking card:', err);
             return;
         }
+        const { messageId: msgId, cardId } = cardHandle;
         const stopTyping = startTypingLoop(chatId);
-        const taskKey = `${userId}:${msgId}`;
+        const taskKey = `${userId}:${cardId}`;
+        const streamUpdate = (content, toolNote) => {
+            const note = toolNote ? '输出中...\n' + toolNote : '输出中...';
+            streamContentUpdate(cardId, content, note).catch((e) => log.debug('Stream update failed (will retry on next update):', e?.message ?? e));
+        };
         await runAITask({ config, sessionManager }, { userId, chatId, workDir, sessionId, convId, platform: 'feishu', taskKey }, prompt, toolAdapter, {
-            throttleMs: FEISHU_THROTTLE_MS,
-            minContentDeltaChars: 80, // 块级流式：内容增长≥80 字符才 patch，减少 API 调用
-            streamUpdate: async (content, toolNote) => {
-                const note = toolNote ? '输出中...\n' + toolNote : '输出中...';
-                try {
-                    await updateMessage(chatId, msgId, content, 'streaming', note, toolId);
-                }
-                catch (err) {
-                    log.debug('Stream update failed (will retry on next update):', err);
-                }
-            },
-            sendComplete: async (content, note) => {
-                // Use sendFinalMessages to handle the final result
-                await sendFinalMessages(chatId, msgId, content, note ?? '', toolId);
+            throttleMs: CARDKIT_THROTTLE_MS,
+            streamUpdate,
+            sendComplete: async (content, note, thinkingText) => {
+                await sendFinalCards(chatId, msgId, cardId, content, note ?? '', thinkingText);
             },
             sendError: async (error) => {
-                await updateMessage(chatId, msgId, `错误：${error}`, 'error', '执行失败', toolId);
+                await sendErrorCard(cardId, error);
             },
             extraCleanup: () => {
                 stopTyping();
@@ -163,6 +161,10 @@ export function setupFeishuHandlers(config, sessionManager) {
             onTaskReady: (state) => {
                 runningTasks.set(taskKey, state);
             },
+            onThinkingToText: (content) => {
+                const resetCard = buildCardV2({ content: content || '...', status: 'streaming' }, cardId);
+                updateCardFull(cardId, resetCard).catch((e) => log.warn('Thinking→text transition update failed:', e?.message ?? e));
+            },
             sendImage: (path) => sendImageReply(chatId, path),
         });
     }
@@ -255,6 +257,40 @@ export function setupFeishuHandlers(config, sessionManager) {
         const chatId = event?.context?.open_chat_id ?? event?.context?.chat_id ?? event?.context?.open_id ?? '';
         const userId = event?.sender?.sender_id?.open_id ?? event?.operator?.open_id ?? '';
         log.info(`[handleCardAction] chatId=${chatId}, userId=${userId}, actionValue=${JSON.stringify(actionValue)}`);
+        let actionData = null;
+        try {
+            let parsed = actionValue;
+            if (typeof parsed === 'string') {
+                parsed = JSON.parse(parsed);
+                if (typeof parsed === 'string')
+                    parsed = JSON.parse(parsed);
+            }
+            actionData = parsed;
+        }
+        catch {
+            /* ignore */
+        }
+        if (actionData?.action === 'stop' && actionData.card_id) {
+            const cardId = actionData.card_id;
+            const taskKey = `${userId}:${cardId}`;
+            const taskInfo = runningTasks.get(taskKey);
+            if (taskInfo) {
+                log.info(`User ${userId} stopped task for card ${cardId}`);
+                const stoppedContent = taskInfo.latestContent || '(任务已停止，暂无输出)';
+                runningTasks.delete(taskKey);
+                taskInfo.settle();
+                taskInfo.handle.abort();
+                const stoppedCard = buildCardV2({ content: stoppedContent, status: 'done', note: '⏹️ 已停止' });
+                disableStreaming(cardId)
+                    .then(() => updateCardFull(cardId, stoppedCard))
+                    .catch((e) => log.warn('Stop card update failed:', e?.message ?? e))
+                    .finally(() => destroySession(cardId));
+            }
+            else {
+                log.warn(`No running task found for key: ${taskKey}`);
+            }
+            return { toast: { type: 'success', content: '已停止' } };
+        }
         // 处理 mode 按钮（兼容 value 为对象或 JSON 字符串）
         const modeAv = parseActionValue(actionValue);
         if (modeAv?.action === 'mode' && modeAv.value) {

package/dist/feishu/message-sender.d.ts

@@ -1,3 +1,7 @@
+export interface CardHandle {
+    messageId: string;
+    cardId: string;
+}
 export type MessageStatus = 'thinking' | 'streaming' | 'done' | 'error';
 /**
  * Create Feishu card with action buttons
@@ -20,6 +24,14 @@ export declare function createFeishuModeCardReadOnly(currentMode: string): Recor
 export declare function delayUpdateCard(token: string, card: Record<string, unknown>, openIds?: string[]): Promise<void>;
 export declare function sendModeCard(chatId: string, _userId: string, currentMode: string): Promise<void>;
 export declare function sendThinkingMessage(chatId: string, replyToMessageId: string | undefined, toolId?: string): Promise<string>;
+/** CardKit 打字机：发送思考卡片并返回 cardId + messageId */
+export declare function sendThinkingCard(chatId: string, toolId?: string): Promise<CardHandle>;
+/** CardKit 流式更新（打字机效果） */
+export declare function streamContentUpdate(cardId: string, content: string, note?: string): Promise<void>;
+/** CardKit 完成：关闭流式、全量更新、溢出分片 */
+export declare function sendFinalCards(chatId: string, _messageId: string, cardId: string, fullContent: string, note: string, thinking?: string): Promise<void>;
+/** CardKit 错误卡片 */
+export declare function sendErrorCard(cardId: string, error: string): Promise<void>;
 export declare function updateMessage(chatId: string, messageId: string, content: string, status: MessageStatus, note?: string, toolId?: string): Promise<void>;
 export declare function sendFinalMessages(chatId: string, messageId: string, fullContent: string, note: string, toolId?: string): Promise<void>;
 export declare function sendTextReply(chatId: string, text: string): Promise<void>;

package/dist/feishu/message-sender.js

@@ -3,6 +3,8 @@ import { readFileSync } from 'node:fs';
 import { createLogger } from '../logger.js';
 import { splitLongContent } from '../shared/utils.js';
 import { MAX_FEISHU_MESSAGE_LENGTH } from '../constants.js';
+import { buildCardV2, splitLongContent as cardSplitLongContent, truncateForStreaming } from './card-builder.js';
+import { createCard, enableStreaming, sendCardMessage, streamContent as cardkitStreamContent, updateCardFull, markCompleted, disableStreaming, destroySession, } from './cardkit-manager.js';
 const log = createLogger('FeishuSender');
 const STATUS_CONFIG = {
     thinking: { icon: '🔵', template: 'blue', title: '思考中' },
@@ -253,6 +255,62 @@ export async function sendThinkingMessage(chatId, replyToMessageId, toolId = 'cl
         throw err;
     }
 }
+/** CardKit 打字机：发送思考卡片并返回 cardId + messageId */
+export async function sendThinkingCard(chatId, toolId = 'claude') {
+    const initialCard = buildCardV2({ content: '正在启动...', status: 'processing', note: '请稍候' });
+    const cardId = await createCard(initialCard);
+    const [, messageId] = await Promise.all([
+        enableStreaming(cardId),
+        sendCardMessage(chatId, cardId),
+    ]);
+    const cardWithButton = buildCardV2({ content: '等待 Claude 响应...', status: 'processing', note: '请稍候' }, cardId);
+    await updateCardFull(cardId, cardWithButton);
+    log.debug(`Processing card created: cardId=${cardId}, messageId=${messageId}`);
+    return { messageId, cardId };
+}
+/** CardKit 流式更新（打字机效果） */
+export async function streamContentUpdate(cardId, content, note) {
+    const truncated = truncateForStreaming(content) || '...';
+    const updates = [cardkitStreamContent(cardId, 'main_content', truncated)];
+    if (note)
+        updates.push(cardkitStreamContent(cardId, 'note_area', note));
+    await Promise.all(updates);
+}
+/** CardKit 完成：关闭流式、全量更新、溢出分片 */
+export async function sendFinalCards(chatId, _messageId, cardId, fullContent, note, thinking) {
+    const parts = cardSplitLongContent(fullContent);
+    markCompleted(cardId);
+    await disableStreaming(cardId);
+    const finalCard = buildCardV2({ content: parts[0], status: 'done', note, thinking }, cardId);
+    await updateCardFull(cardId, finalCard);
+    const client = getClient();
+    for (let i = 1; i < parts.length; i++) {
+        const overflowContent = `${parts[i]}\n\n_*(续 ${i + 1}/${parts.length})*_`;
+        const overflowCard = createFeishuCard(getToolTitle('claude', 'done'), overflowContent, 'done', note);
+        await client.im.message.create({
+            data: {
+                receive_id: chatId,
+                msg_type: 'interactive',
+                content: overflowCard,
+            },
+            params: { receive_id_type: 'chat_id' },
+        });
+    }
+    destroySession(cardId);
+}
+/** CardKit 错误卡片 */
+export async function sendErrorCard(cardId, error) {
+    markCompleted(cardId);
+    await disableStreaming(cardId);
+    try {
+        const errorCard = buildCardV2({ content: `错误：${error}`, status: 'error', note: '执行失败' });
+        await updateCardFull(cardId, errorCard);
+    }
+    catch (err) {
+        log.error('Failed to send error card:', err);
+    }
+    destroySession(cardId);
+}
 // Track if patch API is working for this session
 let patchApiWorking = true;
 let patchFailCount = 0;

package/dist/shared/retry.d.ts

@@ -0,0 +1,10 @@
+/** 抛出此错误时 withRetry 不再重试，直接穿透 */
+export declare class NonRetryableError extends Error {
+    constructor(message: string);
+}
+export interface RetryOptions {
+    maxRetries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+}
+export declare function withRetry<T>(fn: () => Promise<T>, opts?: RetryOptions): Promise<T>;

package/dist/shared/retry.js

@@ -0,0 +1,26 @@
+import { createLogger } from '../logger.js';
+const log = createLogger('Retry');
+/** 抛出此错误时 withRetry 不再重试，直接穿透 */
+export class NonRetryableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NonRetryableError';
+    }
+}
+export async function withRetry(fn, opts) {
+    const maxRetries = opts?.maxRetries ?? 3;
+    const baseDelay = opts?.baseDelayMs ?? 500;
+    const maxDelay = opts?.maxDelayMs ?? 5000;
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            if (err instanceof NonRetryableError || attempt >= maxRetries)
+                throw err;
+            const delay = Math.min(baseDelay * 2 ** attempt + Math.random() * 200, maxDelay);
+            log.warn(`Retry ${attempt + 1}/${maxRetries} after ${Math.round(delay)}ms: ${err?.message ?? err}`);
+            await new Promise((r) => setTimeout(r, delay));
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.2.4-beta.2",
+  "version": "1.3.0",
   "description": "Multi-platform IM bridge for AI CLI tools (Claude, Codex, Cursor)",
   "type": "module",
   "main": "dist/index.js",