evolclaw 2.8.3 → 3.1.0

package/dist/channels/feishu.js

@@ -4,6 +4,7 @@ import imageType from 'image-type';
 import { sanitizeFileName, saveToUploads, validateImage } from '../utils/media-cache.js';
 import { logger } from '../utils/logger.js';
 import { hasRichContent, renderAllRichContent, checkDependencies } from '../utils/rich-content-renderer.js';
+import { formatItemsAsText } from '../core/message/items-formatter.js';
 export class FeishuChannel {
     config;
     client = null;
@@ -18,6 +19,8 @@ export class FeishuChannel {
     interactionCallback;
     connected = false;
     enableRichContent;
+    // chatId → 该会话内仍 pending 的交互卡片 messageId 集合，用于作废
+    pendingCardsByChat = new Map();
     constructor(config) {
         this.config = config;
         this.enableRichContent = config.enableRichContent ?? false; // 默认关闭
@@ -40,7 +43,9 @@ export class FeishuChannel {
         if (this.config.appId.startsWith('YOUR_') || this.config.appSecret.startsWith('YOUR_')) {
             throw new Error('Feishu credentials not configured (placeholder values detected)');
         }
-        const { requireOptional } = await import('../utils/init-channel.js');
+        // 加载持久化的已处理消息 ID，防止重启后 Feishu 重推同一条消息
+        this.loadSeenMessages();
+        const { requireOptional } = await import('../utils/npm-ops.js');
         const lark = await requireOptional('@larksuiteoapi/node-sdk');
         try {
             this.client = new lark.Client({
@@ -57,6 +62,18 @@ export class FeishuChannel {
                         return;
                     }
                     this.markSeen(msg.message_id);
+                    // 丢弃飞书服务端积压超过 5 分钟才下发的消息：上游观察到 65 分钟级延迟下发的
+                    // 历史消息（含 /restart 这类破坏性命令），无差别接收会导致非预期重启。
+                    // create_time 是 ms 字符串。
+                    {
+                        const createTimeMs = Number(msg.create_time ?? 0);
+                        const ageMs = Date.now() - createTimeMs;
+                        const STALE_THRESHOLD_MS = 5 * 60 * 1000;
+                        if (createTimeMs > 0 && ageMs > STALE_THRESHOLD_MS) {
+                            logger.warn(`[Feishu] Dropping stale message: id=${msg.message_id} type=${msg.message_type} age=${Math.round(ageMs / 1000)}s create_time=${createTimeMs}`);
+                            return;
+                        }
+                    }
                     if (!this.messageHandler)
                         return;
                     // 提取 chatType（从 SDK 事件直接获取）
@@ -65,8 +82,6 @@ export class FeishuChannel {
                     if (msg.thread_id) {
                         logger.info('[Feishu] Thread message, thread_id:', msg.thread_id, 'root_id:', msg.root_id);
                     }
-                    // [DEBUG] 临时：记录所有消息的 root_id/thread_id，用于排查图片回复带引用问题
-                    logger.info('[Feishu][DEBUG] msg_type:', msg.message_type, 'root_id:', msg.root_id ?? '(empty)', 'thread_id:', msg.thread_id ?? '(empty)', 'parent_id:', msg.parent_id ?? '(empty)');
                     // 提取 @ 提及列表（排除机器人自身）
                     const mentions = (msg.mentions || []).map((m) => ({
                         userId: m.id?.open_id || '',
@@ -164,6 +179,16 @@ export class FeishuChannel {
                                         quotedText = `> 以下是引用的原消息\n> ================\n> [文件消息]\n> ================\n\n`;
                                     }
                                 }
+                                else if (quotedMsgType === 'merge_forward') {
+                                    const { text: mergedText, images: mergedImages } = await this.extractMergeForwardContent(msg.parent_id, msg.chat_id);
+                                    if (mergedText) {
+                                        quotedText = `> 以下是引用的原消息\n> ================\n> [合并转发消息]\n> ================\n\n${mergedText}\n\n`;
+                                        quotedImages.push(...mergedImages);
+                                    }
+                                    else {
+                                        quotedText = `> 以下是引用的原消息\n> ================\n> [合并转发消息]\n> ================\n\n`;
+                                    }
+                                }
                                 else {
                                     quotedText = `> 以下是引用的原消息\n> ================\n> [${quotedMsgType}消息]\n> ================\n\n`;
                                 }
@@ -172,6 +197,7 @@ export class FeishuChannel {
                                 logger.warn({ err }, '[Feishu] Failed to fetch quoted message');
                             }
                         }
+                        logger.info(`[Feishu] Incoming message_type=${msg.message_type} content=${msg.content?.substring(0, 200)}`);
                         // 处理文本消息
                         if (msg.message_type === 'text') {
                             const parsed = JSON.parse(msg.content);
@@ -252,6 +278,19 @@ export class FeishuChannel {
                             const allImages = [...quotedImages, ...postImages];
                             await this.messageHandler({ channelId: msg.chat_id, content: finalContent, images: allImages.length > 0 ? allImages : undefined, peerId, peerName, messageId: msg.message_id, threadId, rootId, chatType });
                         }
+                        // 处理合并转发消息
+                        else if (msg.message_type === 'merge_forward') {
+                            const { text: mergedText, images: mergedImages } = await this.extractMergeForwardContent(msg.message_id, msg.chat_id);
+                            if (mergedText) {
+                                const finalContent = quotedText + mergedText;
+                                const allImages = [...quotedImages, ...mergedImages];
+                                await this.messageHandler({ channelId: msg.chat_id, content: finalContent, images: allImages.length > 0 ? allImages : undefined, peerId, peerName, messageId: msg.message_id, threadId, rootId, chatType });
+                            }
+                            else {
+                                const prompt = quotedText + '[合并转发消息解析失败]';
+                                await this.messageHandler({ channelId: msg.chat_id, content: prompt, images: quotedImages.length > 0 ? quotedImages : undefined, peerId, peerName, messageId: msg.message_id, threadId, rootId, chatType });
+                            }
+                        }
                         // 处理其他类型消息
                         else {
                             logger.debug('[Feishu] Unsupported message type:', msg.message_type);
@@ -278,11 +317,49 @@ export class FeishuChannel {
                         if (!action?.value)
                             return;
                         const value = action.value;
+                        const operatorId = data.operator?.open_id;
+                        const chatId = data.context?.open_chat_id || data.open_chat_id;
+                        const cardMessageId = data.open_message_id || data.context?.open_message_id;
+                        // ── CommandCard 分支：按钮直接触发命令 ──
+                        if (value._command) {
+                            if (value._initiator && operatorId && operatorId !== value._initiator) {
+                                return {
+                                    toast: { type: 'warning', content: '⚠️ 仅卡片发起者可操作' },
+                                };
+                            }
+                            logger.info(`[Feishu] CommandCard trigger: command=${value._command}, operator=${operatorId}`);
+                            if (this.messageHandler) {
+                                // Feishu chatId 前缀：oc_ = group chat，ou_ = private user open_id
+                                const chatType = typeof chatId === 'string' && chatId.startsWith('oc_') ? 'group' : 'private';
+                                await this.messageHandler({
+                                    channelId: chatId,
+                                    content: value._command,
+                                    chatType,
+                                    peerId: operatorId,
+                                    messageId: `card-trigger-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+                                    source: 'card-trigger',
+                                });
+                            }
+                            // 点击后从作废集合移除——已 resolved 的卡片不再被新卡片到来时 PATCH
+                            if (chatId && cardMessageId)
+                                this.untrackPendingCard(chatId, cardMessageId);
+                            const cardTitle = value._card_title || '操作';
+                            const btnLabel = value._btn_label || value._command;
+                            const cardBody = value._card_body || '';
+                            return this.buildResolvedCard(cardTitle, { type: 'interaction.response', id: '', action: value._command, operatorId }, cardBody, btnLabel);
+                        }
+                        // ── ActionInteraction 分支 ──
                         const requestId = value._request_id;
                         if (!requestId) {
-                            logger.debug('[Feishu] Card action without _request_id, ignoring');
+                            logger.debug('[Feishu] Card action without _request_id or _command, ignoring');
                             return;
                         }
+                        // initiator 校验
+                        if (value._initiator && operatorId && operatorId !== value._initiator) {
+                            return {
+                                toast: { type: 'warning', content: '⚠️ 仅卡片发起者可操作' },
+                            };
+                        }
                         // Legacy field change (non-form select_static with _field_key): ignore silently
                         if (value._field_key) {
                             logger.debug(`[Feishu] Legacy field change: requestId=${requestId}, field=${value._field_key}`);
@@ -295,11 +372,12 @@ export class FeishuChannel {
                             id: requestId,
                             action: value._action || 'submit',
                             values: { ...formValues, ...value },
-                            operatorId: data.operator?.open_id,
+                            operatorId,
                         };
                         // Remove internal fields from values
                         delete response.values._request_id;
                         delete response.values._action;
+                        delete response.values._initiator;
                         delete response.values._card_title;
                         const cardBody = value._card_body || '';
                         delete response.values._card_body;
@@ -307,6 +385,9 @@ export class FeishuChannel {
                         delete response.values._btn_label;
                         logger.info(`[Feishu] Card action: requestId=${requestId}, action=${response.action}, values=${JSON.stringify(response.values)}`);
                         this.interactionCallback?.(response);
+                        // 点击后从作废集合移除——已 resolved 的卡片不再被新卡片到来时 PATCH
+                        if (chatId && cardMessageId)
+                            this.untrackPendingCard(chatId, cardMessageId);
                         // Return updated card (buttons disabled + result shown)
                         const cardTitle = value._card_title || '操作';
                         return this.buildResolvedCard(cardTitle, response, cardBody, btnLabel);
@@ -604,7 +685,35 @@ export class FeishuChannel {
         return this.seenMessages.has(msgId);
     }
     markSeen(msgId) {
-        this.seenMessages.set(msgId, Date.now());
+        const now = Date.now();
+        this.seenMessages.set(msgId, now);
+        // 持久化到文件，供重启后去重
+        if (this.config.seenMsgFile) {
+            try {
+                fs.appendFileSync(this.config.seenMsgFile, JSON.stringify({ id: msgId, ts: now }) + '\n');
+            }
+            catch { }
+        }
+    }
+    loadSeenMessages() {
+        if (!this.config.seenMsgFile)
+            return;
+        try {
+            if (!fs.existsSync(this.config.seenMsgFile))
+                return;
+            const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+            const lines = fs.readFileSync(this.config.seenMsgFile, 'utf-8').split('\n').filter(Boolean);
+            for (const line of lines) {
+                try {
+                    const { id, ts } = JSON.parse(line);
+                    if (ts > cutoff)
+                        this.seenMessages.set(id, ts);
+                }
+                catch { }
+            }
+            logger.info(`[Feishu] Loaded ${this.seenMessages.size} seen message ID(s) from disk`);
+        }
+        catch { }
     }
     startCleanupTask() {
         this.cleanupInterval = setInterval(() => {
@@ -621,6 +730,16 @@ export class FeishuChannel {
             // seenThreads 无时间戳，仅限容量（话题持久存在，不按时间清理）
             if (this.seenThreads.size > 1000)
                 this.seenThreads.clear();
+            // 重写文件，去掉过期条目
+            if (this.config.seenMsgFile && this.seenMessages.size > 0) {
+                try {
+                    const lines = [...this.seenMessages.entries()]
+                        .map(([id, ts]) => JSON.stringify({ id, ts }))
+                        .join('\n') + '\n';
+                    fs.writeFileSync(this.config.seenMsgFile, lines);
+                }
+                catch { }
+            }
         }, 60 * 60 * 1000);
     }
     async disconnect() {
@@ -705,6 +824,94 @@ export class FeishuChannel {
             return null;
         }
     }
+    /**
+     * 提取合并转发消息的子消息内容。
+     * 调用 im.message.get 获取子消息列表，逐条解析 text/image/post/file 类型。
+     */
+    async extractMergeForwardContent(messageId, chatId) {
+        const empty = { text: '', images: [] };
+        if (!this.client)
+            return empty;
+        try {
+            const res = await this.client.im.message.get({
+                path: { message_id: messageId }
+            });
+            const items = res.data?.items;
+            if (!items || items.length === 0) {
+                logger.warn('[Feishu] merge_forward: no sub-messages found');
+                return empty;
+            }
+            logger.info(`[Feishu] merge_forward: ${items.length} sub-messages`);
+            const projectPath = this.projectPathProvider
+                ? await this.projectPathProvider(chatId)
+                : process.cwd();
+            const textParts = [];
+            const images = [];
+            const MAX_IMAGES = 10;
+            textParts.push('以下是用户转发的合并消息：\n---');
+            for (const item of items) {
+                const msgType = item.msg_type;
+                const content = item.body?.content;
+                if (!content)
+                    continue;
+                try {
+                    if (msgType === 'text') {
+                        const parsed = JSON.parse(content);
+                        textParts.push(parsed.text || '');
+                    }
+                    else if (msgType === 'post') {
+                        const parsed = JSON.parse(content);
+                        let text = '';
+                        const postContent = parsed.zh_cn?.content || parsed.en_us?.content || parsed.content;
+                        if (postContent) {
+                            for (const line of postContent) {
+                                for (const elem of line) {
+                                    if (elem.tag === 'img' && elem.image_key && item.message_id && images.length < MAX_IMAGES) {
+                                        const imageData = await this.downloadAndSaveImage(elem.image_key, chatId, item.message_id, projectPath);
+                                        if (imageData)
+                                            images.push(imageData);
+                                    }
+                                    else if (elem.text) {
+                                        text += elem.text;
+                                    }
+                                }
+                                text += '\n';
+                            }
+                        }
+                        const title = parsed.zh_cn?.title || parsed.en_us?.title || parsed.title;
+                        textParts.push(title ? `${title}\n${text.trim()}` : text.trim());
+                    }
+                    else if (msgType === 'image' && item.message_id) {
+                        const parsed = JSON.parse(content);
+                        if (parsed.image_key && images.length < MAX_IMAGES) {
+                            const imageData = await this.downloadAndSaveImage(parsed.image_key, chatId, item.message_id, projectPath);
+                            if (imageData) {
+                                images.push(imageData);
+                                textParts.push('[图片]');
+                            }
+                        }
+                    }
+                    else if (msgType === 'file') {
+                        const parsed = JSON.parse(content);
+                        textParts.push(`[文件: ${parsed.file_name || 'unknown'}]`);
+                    }
+                    else {
+                        textParts.push(`[${msgType}]`);
+                    }
+                }
+                catch (parseErr) {
+                    logger.debug('[Feishu] merge_forward: failed to parse sub-message:', parseErr);
+                    textParts.push(`[${msgType}: 解析失败]`);
+                }
+            }
+            textParts.push('---');
+            return { text: textParts.join('\n'), images };
+        }
+        catch (error) {
+            logger.error('[Feishu] Failed to extract merge_forward content:', error);
+            return empty;
+        }
+    }
     async downloadFile(fileKey, fileName, messageId, projectPath) {
         if (!this.client)
             return null;
@@ -741,12 +948,63 @@ export class FeishuChannel {
             return null;
         }
     }
+    /** 跟踪 pending 交互卡片，等待后续作废 */
+    trackPendingCard(chatId, messageId) {
+        let set = this.pendingCardsByChat.get(chatId);
+        if (!set) {
+            set = new Set();
+            this.pendingCardsByChat.set(chatId, set);
+        }
+        set.add(messageId);
+    }
+    /** 卡片已 resolved（用户点击了按钮，飞书已用回调返回值替换卡片），从作废集合移除 */
+    untrackPendingCard(chatId, messageId) {
+        const set = this.pendingCardsByChat.get(chatId);
+        if (!set)
+            return;
+        set.delete(messageId);
+        if (set.size === 0)
+            this.pendingCardsByChat.delete(chatId);
+    }
+    /**
+     * 作废 chatId 下所有未被点击的旧卡片：PATCH 为"已过期"灰色卡片。
+     * 卡片需在 config 中声明 update_multi: true 才能被 PATCH。
+     */
+    async invalidatePendingCards(chatId) {
+        const set = this.pendingCardsByChat.get(chatId);
+        if (!set || set.size === 0)
+            return;
+        const expiredCard = {
+            config: { wide_screen_mode: true, update_multi: true },
+            header: {
+                template: 'grey',
+                title: { tag: 'plain_text', content: '已过期' },
+            },
+            elements: [{ tag: 'markdown', content: '此卡片已过期，请查看最新卡片。' }],
+        };
+        const ids = Array.from(set);
+        this.pendingCardsByChat.delete(chatId);
+        await Promise.all(ids.map(async (msgId) => {
+            try {
+                await this.client.im.message.patch({
+                    path: { message_id: msgId },
+                    data: { content: JSON.stringify(expiredCard) },
+                });
+            }
+            catch (err) {
+                const detail = err?.response?.data ?? err?.message ?? err;
+                logger.debug(`[Feishu] Patch expired card failed (msgId=${msgId}): ${typeof detail === 'string' ? detail : JSON.stringify(detail)}`);
+            }
+        }));
+    }
     async sendInteraction(chatId, interaction, options) {
         if (!this.client)
             return false;
         const card = buildInteractionCard(interaction);
         if (!card)
             return false;
+        // 在新卡发送前作废旧卡（PATCH 为"已过期"），避免历史卡片仍可点击
+        await this.invalidatePendingCards(chatId);
         try {
             let messageId;
             if (options?.replyToMessageId) {
@@ -774,6 +1032,8 @@ export class FeishuChannel {
                 messageId = res?.data?.message_id;
             }
             logger.info(`[Feishu] Sent interaction card: ${interaction.id}, messageId=${messageId}`);
+            if (messageId)
+                this.trackPendingCard(chatId, messageId);
             return messageId || false;
         }
         catch (error) {
@@ -790,19 +1050,6 @@ export class FeishuChannel {
             return false;
         }
     }
-    async patchInteractionCard(messageId, card) {
-        if (!this.client)
-            return;
-        try {
-            await this.client.im.message.patch({
-                path: { message_id: messageId },
-                data: { content: JSON.stringify(card) },
-            });
-        }
-        catch (error) {
-            logger.warn(`[Feishu] Failed to patch card ${messageId}:`, error?.response?.data || error?.message);
-        }
-    }
     buildResolvedCard(cardTitle, response, cardBody, btnLabel) {
         const action = response.action;
         const labelMap = {
@@ -812,7 +1059,6 @@ export class FeishuChannel {
             'cancel': '取消',
         };
         const statusText = labelMap[action] || (btnLabel ? `✅ ${btnLabel}` : `✅ ${action}`);
-        // Build elements: original body only
         const elements = [];
         if (cardBody) {
             elements.push({ tag: 'markdown', content: cardBody });
@@ -825,7 +1071,7 @@ export class FeishuChannel {
             card: {
                 type: 'raw',
                 data: {
-                    config: { wide_screen_mode: true },
+                    config: { wide_screen_mode: true, update_multi: true },
                     header: {
                         template: action === 'deny' ? 'red' : 'green',
                         title: { tag: 'plain_text', content: `${cardTitle} — ${statusText}` },
@@ -849,12 +1095,57 @@ export class FeishuChannel {
 // ── 交互卡片构建工具 ──
 export function buildInteractionCard(interaction) {
     const { kind } = interaction;
+    if (kind.kind === 'command-card') {
+        return buildCommandCardFeishu(kind, interaction.initiatorId);
+    }
     if (kind.kind === 'action') {
-        return buildActionCard(interaction.id, kind);
+        return buildActionCard(interaction.id, kind, interaction.initiatorId);
     }
     return null;
 }
-export function buildActionCard(requestId, action) {
+function buildCommandCardFeishu(card, initiatorId) {
+    const elements = [];
+    if (card.body) {
+        elements.push({ tag: 'markdown', content: card.body });
+    }
+    // Build full card body for resolved state: original body + button labels
+    const btnLabels = card.buttons.map(btn => btn.label).join('  ·  ');
+    const fullCardBody = [card.body, btnLabels].filter(Boolean).join('\n\n');
+    const buttons = card.buttons.map(btn => {
+        const buttonEl = {
+            tag: 'button',
+            text: { tag: 'plain_text', content: btn.label },
+            type: btn.style === 'danger' ? 'danger' : btn.style === 'primary' ? 'primary' : 'default',
+            value: {
+                _command: btn.command,
+                _initiator: initiatorId,
+                _card_title: card.title,
+                _card_body: fullCardBody,
+                _btn_label: btn.label,
+            },
+        };
+        if (btn.disabled) {
+            buttonEl.disabled = true;
+        }
+        if (btn.confirm) {
+            buttonEl.confirm = {
+                title: { tag: 'plain_text', content: btn.confirm.title },
+                text: { tag: 'plain_text', content: btn.confirm.body },
+            };
+        }
+        return buttonEl;
+    });
+    elements.push({ tag: 'action', actions: buttons });
+    return {
+        config: { wide_screen_mode: true, update_multi: true },
+        header: {
+            template: 'blue',
+            title: { tag: 'plain_text', content: card.title },
+        },
+        elements,
+    };
+}
+export function buildActionCard(requestId, action, initiatorId) {
     const elements = [];
     // Body text
     if (action.body) {
@@ -872,6 +1163,7 @@ export function buildActionCard(requestId, action) {
             value: {
                 _request_id: requestId,
                 _action: btn.key,
+                _initiator: initiatorId,
                 _card_title: action.title,
                 _card_body: fullCardBody,
                 _btn_label: btn.label,
@@ -890,7 +1182,7 @@ export function buildActionCard(requestId, action) {
         actions: buttons,
     });
     return {
-        config: { wide_screen_mode: true },
+        config: { wide_screen_mode: true, update_multi: true },
         header: {
             template: 'blue',
             title: { tag: 'plain_text', content: action.title },
@@ -999,7 +1291,8 @@ export function hasMarkdownSyntax(text) {
     ];
     return markdownPatterns.some(pattern => pattern.test(text));
 }
-import { normalizeChannelInstances, getChannelShowActivities } from '../config.js';
+import { normalizeChannelInstances, getChannelShowActivities } from '../utils/channel-helpers.js';
+import { resolvePaths } from '../paths.js';
 export class FeishuChannelPlugin {
     name = 'feishu';
     isEnabled(config) {
@@ -1023,16 +1316,59 @@ export class FeishuChannelPlugin {
                 appId: inst.appId,
                 appSecret: inst.appSecret,
                 enableRichContent: config.enableRichContent,
+                seenMsgFile: path.join(resolvePaths().dataDir, `feishu-seen-${inst.name}.jsonl`),
             });
             const adapter = {
                 channelName: inst.name,
-                sendText: (id, text, context) => channel.sendMessage(id, text, context),
-                sendFile: (id, filePath, context) => channel.sendFile(id, filePath, context),
-                sendImage: (id, png, context) => channel.sendImage(id, png, context),
-                acknowledge: (messageId) => { channel.addAckReaction(messageId); return Promise.resolve(); },
-                sendInteraction: (id, interaction, context) => channel.sendInteraction(id, interaction, context),
-                patchInteractionCard: (messageId, card) => channel.patchInteractionCard(messageId, card),
-                onInteraction: (callback) => channel.onInteraction(callback),
+                capabilities: { file: true, image: true, interaction: true, markdown: true, thought: false, status: true },
+                send: async (envelope, payload) => {
+                    const ctx = envelope.replyContext;
+                    const channelId = envelope.channelId;
+                    switch (payload.kind) {
+                        case 'result.text':
+                        case 'command.result':
+                        case 'command.error':
+                        case 'system.notice':
+                        case 'system.error':
+                        case 'result.error': {
+                            const sendCtx = { ...(ctx ?? {}) };
+                            if (payload.kind === 'result.text' && payload.isFinal)
+                                sendCtx.title = '✅ 最终回复:';
+                            await channel.sendMessage(channelId, payload.text, sendCtx);
+                            return;
+                        }
+                        case 'result.file':
+                            await channel.sendFile(channelId, payload.filePath, ctx);
+                            return;
+                        case 'result.image':
+                            await channel.sendImage(channelId, payload.data, ctx);
+                            return;
+                        case 'activity.batch': {
+                            // Feishu 不发送成功的 tool_result（信息密度低，刷屏）
+                            const filtered = payload.items.filter((i) => !(i.kind === 'tool_result' && i.ok));
+                            const text = formatItemsAsText(filtered);
+                            if (text) {
+                                await channel.sendMessage(channelId, text, ctx);
+                            }
+                            return;
+                        }
+                        case 'status.started':
+                        case 'status.completed':
+                        case 'status.interrupted':
+                        case 'status.error':
+                        case 'status.timeout':
+                            // Feishu 通过 acknowledge (✓ 表情) 表达状态，由 channel 自行处理
+                            return;
+                        case 'interaction':
+                            await channel.sendInteraction(channelId, payload.interaction, ctx);
+                            return;
+                        case 'custom':
+                            // Feishu 不支持自定义 payload
+                            return;
+                        default:
+                            logger.warn(`[Feishu] Unhandled payload kind: ${payload.kind}`);
+                    }
+                }, acknowledge: (messageId) => { channel.addAckReaction(messageId); return Promise.resolve(); }, onInteraction: (callback) => channel.onInteraction(callback),
             };
             const policy = {
                 canSwitchProject: (chatType, identity) => identity === 'owner' || identity === 'admin',
@@ -1077,6 +1413,19 @@ export class FeishuChannelPlugin {
                 connect: () => channel.connect(),
                 disconnect: () => channel.disconnect(),
                 onProjectPathRequest: (channelId) => Promise.resolve(config.projects?.defaultPath || process.cwd()),
+                registerBridge(bridge, channelType) {
+                    bridge.register(adapter.channelName, (handler) => channel.onMessage(async ({ channelId: chatId, content, images, peerId, peerName, messageId, mentions, threadId, rootId, chatType, source }) => {
+                        await handler({
+                            channel: adapter.channelName, channelType, channelId: chatId, content, images, chatType,
+                            peerId: peerId || '', peerName, messageId, mentions, threadId,
+                            replyContext: threadId ? { replyToMessageId: rootId ?? threadId, replyInThread: true } : undefined,
+                            source,
+                        });
+                    }), (channelId, text, replyContext) => channel.sendMessage(channelId, text, {
+                        replyToMessageId: replyContext?.replyToMessageId,
+                        replyInThread: replyContext?.replyInThread,
+                    }), adapter, channelType);
+                },
             });
         }
         return result;