evolclaw 3.1.4 → 3.1.6

package/dist/channels/feishu.js

@@ -21,6 +21,7 @@ export class FeishuChannel {
     enableRichContent;
     // chatId → 该会话内仍 pending 的交互卡片 messageId 集合，用于作废
     pendingCardsByChat = new Map();
+    cardMetaStore = new CardMetaStore();
     constructor(config) {
         this.config = config;
         this.enableRichContent = config.enableRichContent ?? false; // 默认关闭
@@ -282,7 +283,8 @@ export class FeishuChannel {
                         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;
+                                // 直接发送合并转发时，parent_id 指向自己，引用解析会把相同内容填入 quotedText 导致重复，丢弃
+                                const finalContent = 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 });
                             }
@@ -320,76 +322,46 @@ export class FeishuChannel {
                         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: '⚠️ 仅卡片发起者可操作' },
-                                };
+                        const formValues = action.form_value || {};
+                        const decision = routeCardAction({ value, formValues, operatorId }, this.cardMetaStore);
+                        switch (decision.kind) {
+                            case 'ignore':
+                                return;
+                            case 'reject':
+                                return { toast: { type: 'warning', content: '⚠️ 仅卡片发起者可操作' } };
+                            case 'expired':
+                                return { toast: { type: 'warning', content: '⚠️ 卡片已失效，请重新发起' } };
+                            case 'show-input':
+                                return decision.card;
+                            case 'command': {
+                                logger.info(`[Feishu] CommandCard trigger: command=${decision.command}, operator=${operatorId}`);
+                                if (this.messageHandler) {
+                                    // 卡片回调不传 chatType——oc_ 前缀不区分群聊/单聊，
+                                    // 由 ensureSession 从已有 session 中继承正确的 chatType
+                                    await this.messageHandler({
+                                        channelId: chatId,
+                                        content: decision.command,
+                                        peerId: operatorId,
+                                        messageId: `card-trigger-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+                                        source: 'card-trigger',
+                                    });
+                                }
+                                if (chatId && cardMessageId)
+                                    this.untrackPendingCard(chatId, cardMessageId);
+                                this.cardMetaStore.markResolved(value._id);
+                                this.cardMetaStore.cleanup(value._id);
+                                return decision.card;
                             }
-                            logger.info(`[Feishu] CommandCard trigger: command=${value._command}, operator=${operatorId}`);
-                            if (this.messageHandler) {
-                                // 卡片回调不传 chatType——oc_ 前缀不区分群聊/单聊，
-                                // 由 ensureSession 从已有 session 中继承正确的 chatType
-                                await this.messageHandler({
-                                    channelId: chatId,
-                                    content: value._command,
-                                    peerId: operatorId,
-                                    messageId: `card-trigger-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-                                    source: 'card-trigger',
-                                });
+                            case 'respond': {
+                                logger.info(`[Feishu] Card action: id=${value._id}, action=${decision.response.action}`);
+                                this.interactionCallback?.(decision.response);
+                                if (chatId && cardMessageId)
+                                    this.untrackPendingCard(chatId, cardMessageId);
+                                this.cardMetaStore.markResolved(value._id);
+                                this.cardMetaStore.cleanup(value._id);
+                                return decision.card;
                             }
-                            // 点击后从作废集合移除——已 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 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}`);
-                            return;
-                        }
-                        // Form submit: `action.form_value` contains all field values from form container
-                        const formValues = action.form_value || {};
-                        const response = {
-                            type: 'interaction.response',
-                            id: requestId,
-                            action: value._action || 'submit',
-                            values: { ...formValues, ...value },
-                            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;
-                        const btnLabel = value._btn_label || '';
-                        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);
                     }
                     catch (err) {
                         logger.error('[Feishu] Failed to handle card action:', err);
@@ -542,10 +514,15 @@ export class FeishuChannel {
                 if (options.replyInThread) {
                     replyData.reply_in_thread = true;
                 }
-                await this.client.im.message.reply({
+                const replyRes = await this.client.im.message.reply({
                     path: { message_id: options.replyToMessageId },
                     data: replyData
                 });
+                if (options.replyInThread && options.onThreadCreated) {
+                    const newThreadId = replyRes?.data?.thread_id;
+                    if (newThreadId)
+                        options.onThreadCreated(newThreadId);
+                }
             }
             else {
                 await this.client.im.message.create({
@@ -562,21 +539,22 @@ export class FeishuChannel {
         }
         catch (error) {
             // 230011: 消息已被撤回，降级为普通消息重试
-            if (error.response?.data?.code === 230011 && options?.replyToMessageId) {
-                logger.warn('[Feishu] Message withdrawn (230011), retrying without reply');
+            // 99992354: message_id 不存在（合成 ID 或已过期），降级为普通消息
+            const errCode = error.response?.data?.code;
+            if ((errCode === 230011 || errCode === 99992354) && options?.replyToMessageId) {
+                logger.warn(`[Feishu] Reply target invalid (${errCode}), retrying without reply`);
                 return this.sendMessage(chatId, content, { ...options, replyToMessageId: undefined });
             }
             // 230025: 消息内容超长，截断后重试
-            if (error.response?.data?.code === 230025) {
+            if (errCode === 230025) {
                 logger.warn(`[Feishu] Message too long (230025, ${content.length} chars), truncating`);
                 const truncated = content.slice(0, 28000) + '\n\n⚠️ 消息过长，已截断';
                 return this.sendMessage(chatId, truncated, options);
             }
             const respData = error?.response?.data;
-            const code = respData?.code;
             logger.error('[Feishu] Failed to send message:', respData ? JSON.stringify(respData) : error?.message ?? error);
             // post 格式相关错误（400/230001）：降级为纯文本重试
-            if (!options?.forceText && (error?.response?.status === 400 || code === 230001)) {
+            if (!options?.forceText && (error?.response?.status === 400 || errCode === 230001)) {
                 logger.warn('[Feishu] Retrying as plain text (forceText)');
                 return this.sendMessage(chatId, content, { ...options, forceText: true });
             }
@@ -639,9 +617,10 @@ export class FeishuChannel {
             logger.info('[Feishu] File message sent successfully');
         }
         catch (error) {
-            // 230011: 消息已被撤回，降级为普通消息重试
-            if (error.response?.data?.code === 230011 && options?.replyToMessageId) {
-                logger.warn('[Feishu] Message withdrawn (230011), retrying file send without reply');
+            // 230011/99992354: reply target invalid, retry without reply
+            const errCode = error.response?.data?.code;
+            if ((errCode === 230011 || errCode === 99992354) && options?.replyToMessageId) {
+                logger.warn(`[Feishu] Reply target invalid (${errCode}), retrying file send without reply`);
                 return this.sendFile(chatId, filePath);
             }
             logger.error('[Feishu] Failed to send file:', error);
@@ -683,6 +662,7 @@ export class FeishuChannel {
             logger.debug('[Feishu] Image message sent successfully');
         }
         catch (error) {
+            // 99992354: reply target invalid — image cannot easily retry, just log
             logger.error('[Feishu] Failed to send image:', error);
             throw error;
         }
@@ -736,13 +716,18 @@ export class FeishuChannel {
             // seenThreads 无时间戳，仅限容量（话题持久存在，不按时间清理）
             if (this.seenThreads.size > 1000)
                 this.seenThreads.clear();
-            // 重写文件，去掉过期条目
-            if (this.config.seenMsgFile && this.seenMessages.size > 0) {
+            // 重写文件，去掉过期条目（仅在有记录被清理时才写）
+            if (cleaned > 0 && this.config.seenMsgFile) {
                 try {
-                    const lines = [...this.seenMessages.entries()]
-                        .map(([id, ts]) => JSON.stringify({ id, ts }))
-                        .join('\n') + '\n';
-                    fs.writeFileSync(this.config.seenMsgFile, lines);
+                    if (this.seenMessages.size === 0) {
+                        fs.unlinkSync(this.config.seenMsgFile);
+                    }
+                    else {
+                        const lines = [...this.seenMessages.entries()]
+                            .map(([id, ts]) => JSON.stringify({ id, ts }))
+                            .join('\n') + '\n';
+                        fs.writeFileSync(this.config.seenMsgFile, lines);
+                    }
                 }
                 catch { }
             }
@@ -981,12 +966,13 @@ export class FeishuChannel {
         if (!set || set.size === 0)
             return;
         const expiredCard = {
-            config: { wide_screen_mode: true, update_multi: true },
+            schema: '2.0',
+            config: { update_multi: true },
             header: {
                 template: 'grey',
                 title: { tag: 'plain_text', content: '已过期' },
             },
-            elements: [{ tag: 'markdown', content: '此卡片已过期，请查看最新卡片。' }],
+            body: { elements: [{ tag: 'markdown', content: '此卡片已过期，请查看最新卡片。' }] },
         };
         const ids = Array.from(set);
         this.pendingCardsByChat.delete(chatId);
@@ -1006,10 +992,8 @@ export class FeishuChannel {
     async sendInteraction(chatId, interaction, options) {
         if (!this.client)
             return false;
-        const card = buildInteractionCard(interaction);
-        if (!card)
-            return false;
-        // 在新卡发送前作废旧卡（PATCH 为"已过期"），避免历史卡片仍可点击
+        // 统一路径：schema 2.0 内联发送（im.message），不走 cardkit 实体
+        const card = buildCardV2(interaction);
         await this.invalidatePendingCards(chatId);
         try {
             let messageId;
@@ -1038,12 +1022,15 @@ export class FeishuChannel {
                 messageId = res?.data?.message_id;
             }
             logger.info(`[Feishu] Sent interaction card: ${interaction.id}, messageId=${messageId}`);
-            if (messageId)
+            if (messageId) {
                 this.trackPendingCard(chatId, messageId);
+                this.cardMetaStore.set(interaction.id, {
+                    interaction, chatId, messageId, resolved: false,
+                });
+            }
             return messageId || false;
         }
         catch (error) {
-            // 飞书 SDK 错误可能在 response.data、message 或 error 本身
             const respData = error?.response?.data;
             const detail = respData
                 ? JSON.stringify(respData)
@@ -1051,42 +1038,10 @@ export class FeishuChannel {
                     ? error.message
                     : JSON.stringify(error, Object.getOwnPropertyNames(error));
             logger.error(`[Feishu] Failed to send interaction card (id=${interaction.id}, replyTo=${options?.replyToMessageId || 'none'}): ${detail}`);
-            // 同时记录卡片内容以便调试
-            logger.debug(`[Feishu] Card payload for ${interaction.id}: ${JSON.stringify(buildInteractionCard(interaction))}`);
+            logger.debug(`[Feishu] Card payload for ${interaction.id}: ${JSON.stringify(card)}`);
             return false;
         }
     }
-    buildResolvedCard(cardTitle, response, cardBody, btnLabel) {
-        const action = response.action;
-        const labelMap = {
-            'allow': '✅ 已允许',
-            'always': '🔓 已设为始终允许',
-            'deny': '❌ 已拒绝',
-            'cancel': '取消',
-        };
-        const statusText = labelMap[action] || (btnLabel ? `✅ ${btnLabel}` : `✅ ${action}`);
-        const elements = [];
-        if (cardBody) {
-            elements.push({ tag: 'markdown', content: cardBody });
-        }
-        return {
-            toast: {
-                type: 'success',
-                content: statusText,
-            },
-            card: {
-                type: 'raw',
-                data: {
-                    config: { wide_screen_mode: true, update_multi: true },
-                    header: {
-                        template: action === 'deny' ? 'red' : 'green',
-                        title: { tag: 'plain_text', content: `${cardTitle} — ${statusText}` },
-                    },
-                    elements,
-                },
-            },
-        };
-    }
     addAckReaction(messageId) {
         if (!this.client)
             return;
@@ -1098,104 +1053,245 @@ export class FeishuChannel {
         }).catch(() => { });
     }
 }
-// ── 交互卡片构建工具 ──
-export function buildInteractionCard(interaction) {
-    const { kind } = interaction;
-    if (kind.kind === 'command-card') {
-        return buildCommandCardFeishu(kind, interaction.initiatorId);
+export class CardMetaStore {
+    map = new Map();
+    set(id, entry) {
+        this.map.set(id, entry);
+    }
+    get(id) {
+        return this.map.get(id);
+    }
+    markResolved(id) {
+        const entry = this.map.get(id);
+        if (entry)
+            entry.resolved = true;
+    }
+    markInputShown(id) {
+        const entry = this.map.get(id);
+        if (entry)
+            entry.inputShown = true;
     }
-    if (kind.kind === 'action') {
-        return buildActionCard(interaction.id, kind, interaction.initiatorId);
+    cleanup(id) {
+        this.map.delete(id);
     }
-    return null;
 }
-function buildCommandCardFeishu(card, initiatorId) {
-    const elements = [];
-    if (card.body) {
-        elements.push({ tag: 'markdown', content: card.body });
+// ── 统一卡片构建器（schema 2.0 内联）──
+/**
+ * 唯一卡片构建器。输入协议层 InteractionRequest，输出 schema 2.0 内联卡片 JSON。
+ * - command-card: 按钮 value 带 { _id, _command, _initiator }
+ * - action:       按钮 value 带 { _id, _action, _initiator }；checkers → form+checker；
+ *                 allowCustomInput → 「手动输入」按钮（form 容器外）
+ * @param opts.showInput  展开自定义输入框（用于 _show_input 回调返回整卡）
+ */
+export function buildCardV2(interaction, opts) {
+    const { kind } = interaction;
+    const id = interaction.id;
+    const initiatorId = interaction.initiatorId;
+    const title = kind.title;
+    const body = kind.body;
+    const formElements = [];
+    // Body markdown
+    if (body) {
+        formElements.push({ tag: 'markdown', content: body, element_id: 'body_md' });
+    }
+    // Checkers (action only)
+    if (kind.kind === 'action' && kind.checkers?.length) {
+        kind.checkers.forEach((chk, idx) => {
+            const text = chk.description ? `${chk.label} — ${chk.description}` : chk.label;
+            formElements.push({
+                tag: 'checker',
+                name: `opt_${idx}`,
+                checked: false,
+                text: { tag: 'plain_text', content: text },
+                element_id: `chk_${idx}`,
+            });
+        });
+        formElements.push({ tag: 'hr', element_id: 'hr_btns' });
     }
-    // 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 => {
+    // Buttons
+    const buttons = kind.buttons;
+    buttons.forEach((btn, idx) => {
         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,
-            },
+            action_type: 'form_submit',
+            name: `btn_${idx}`,
+            element_id: `btn_${idx}`,
+            value: kind.kind === 'command-card'
+                ? { _id: id, _command: btn.command, _initiator: initiatorId }
+                : { _id: id, _action: btn.key, _initiator: initiatorId },
         };
-        if (btn.disabled) {
+        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;
+        formElements.push(buttonEl);
     });
-    elements.push({ tag: 'action', actions: buttons });
+    // Custom input (action only)
+    const allowCustomInput = kind.kind === 'action' && kind.allowCustomInput;
+    const outerElements = [];
+    if (allowCustomInput && opts?.showInput) {
+        // 展开态：输入框 + 提交按钮内联进 form（整卡作为回调返回值替换，规避 200810）
+        formElements.push({ tag: 'hr', element_id: 'hr_input' }, {
+            tag: 'input',
+            name: 'custom_text',
+            element_id: 'input_custom',
+            placeholder: { tag: 'plain_text', content: '输入自定义回复...' },
+        }, {
+            tag: 'button',
+            text: { tag: 'plain_text', content: '✅ 提交输入' },
+            type: 'primary',
+            action_type: 'form_submit',
+            name: 'btn_submit_custom',
+            element_id: 'btn_submit_custom',
+            value: { _id: id, _action: '_custom_input', _initiator: initiatorId },
+        });
+    }
+    else if (allowCustomInput) {
+        // 初始态：「手动输入」按钮放在 form 容器外（form 内按钮须 form_submit，11310）
+        outerElements.push({
+            tag: 'button',
+            text: { tag: 'plain_text', content: '✏️ 手动输入' },
+            type: 'default',
+            element_id: 'btn_show_input',
+            value: { _id: id, _action: '_show_input', _initiator: initiatorId },
+        });
+    }
     return {
-        config: { wide_screen_mode: true, update_multi: true },
-        header: {
-            template: 'blue',
-            title: { tag: 'plain_text', content: card.title },
+        schema: '2.0',
+        config: { update_multi: true, streaming_mode: false },
+        header: { title: { tag: 'plain_text', content: title }, template: 'blue' },
+        body: {
+            elements: [
+                {
+                    tag: 'form',
+                    name: 'action_form',
+                    element_id: 'action_form',
+                    elements: formElements,
+                },
+                ...outerElements,
+            ],
         },
-        elements,
     };
 }
-export function buildActionCard(requestId, action, initiatorId) {
-    const elements = [];
-    // Body text
-    if (action.body) {
-        elements.push({ tag: 'markdown', content: action.body });
+/**
+ * 唯一 resolved 终态构建器（按钮禁用 + 结果展示 + checker 勾选汇总）。
+ * 作为飞书卡片回调的返回值下发，替换原卡片内容。
+ */
+export function buildResolvedV2(interaction, response) {
+    const action = response.action;
+    const kind = interaction.kind;
+    const labelMap = {
+        'allow': '✅ 已允许',
+        'always': '🔓 已设为始终允许',
+        'deny': '❌ 已拒绝',
+        'cancel': '取消',
+    };
+    const statusText = labelMap[action] || (/^\p{Emoji}/u.test(action) ? action : `✅ ${action}`);
+    const headerTemplate = action === 'deny' ? 'red' : 'green';
+    const headerTitle = `${kind.title} — ${statusText}`;
+    const bodyElements = [];
+    if (kind.body) {
+        bodyElements.push({ tag: 'markdown', content: kind.body });
+    }
+    // Checker summary from interaction.kind.checkers + response.values
+    if (kind.kind === 'action' && kind.checkers?.length && response.values) {
+        const lines = kind.checkers.map((chk, idx) => {
+            const checked = !!response.values[`opt_${idx}`];
+            return `${checked ? '☑' : '☐'} ${chk.label}`;
+        });
+        bodyElements.push({ tag: 'markdown', content: lines.join('\n') });
+    }
+    // CommandCard: 显示原有按钮列表（保留上下文）
+    if (kind.kind === 'command-card' && kind.buttons?.length) {
+        const lines = kind.buttons.map(btn => {
+            const prefix = btn.command === action ? '✓' : '•';
+            const cleanLabel = btn.label.replace(/^✓\s*/, '');
+            return `${prefix} ${cleanLabel}`;
+        });
+        bodyElements.push({ tag: 'markdown', content: lines.join('\n') });
     }
-    // Build full card body for resolved state: original body + button labels
-    const btnLabels = action.buttons.map(btn => btn.label).join('  ·  ');
-    const fullCardBody = [action.body, btnLabels].filter(Boolean).join('\n\n');
-    // Buttons row
-    const buttons = action.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: {
-                _request_id: requestId,
-                _action: btn.key,
-                _initiator: initiatorId,
-                _card_title: action.title,
-                _card_body: fullCardBody,
-                _btn_label: btn.label,
-            },
-        };
-        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: action.title },
+        toast: { type: 'success', content: statusText },
+        card: {
+            type: 'raw',
+            data: {
+                schema: '2.0',
+                config: { update_multi: true, streaming_mode: false },
+                header: {
+                    template: headerTemplate,
+                    title: { tag: 'plain_text', content: headerTitle },
+                },
+                body: { elements: bodyElements },
+            },
         },
-        elements,
     };
 }
+/**
+ * 卡片回调的纯路由决策。不产生副作用（除 store.markInputShown），返回决策对象供
+ * WS 回调执行器消费。元数据从 CardMetaStore 反查，value 只读 _id / _action / _command。
+ */
+export function routeCardAction(input, store) {
+    const { value, formValues, operatorId } = input;
+    const id = value._id;
+    if (!id)
+        return { kind: 'ignore' };
+    const entry = store.get(id);
+    const interaction = entry?.interaction;
+    const initiatorId = interaction?.initiatorId ?? value._initiator;
+    // initiator 校验
+    if (initiatorId && operatorId && operatorId !== initiatorId) {
+        return { kind: 'reject' };
+    }
+    // command-card：按钮直接触发命令
+    if (value._command) {
+        const synthetic = {
+            type: 'interaction.response', id, action: value._command, operatorId,
+        };
+        const card = interaction
+            ? buildResolvedV2(interaction, synthetic)
+            : buildResolvedV2({ type: 'interaction', id, channelId: '', sessionId: '',
+                kind: { kind: 'command-card', title: '操作', buttons: [] } }, synthetic);
+        return { kind: 'command', command: value._command, card };
+    }
+    // _show_input：点击「手动输入」→ 整卡替换为带输入框的版本（规避 200810）
+    if (value._action === '_show_input') {
+        if (!interaction)
+            return { kind: 'expired' };
+        store.markInputShown(id);
+        return {
+            kind: 'show-input',
+            card: { toast: { type: 'info', content: '请在下方输入' },
+                card: { type: 'raw', data: buildCardV2(interaction, { showInput: true }) } },
+        };
+    }
+    // 普通提交 / 自定义输入提交
+    const values = { ...formValues, ...value };
+    for (const k of Object.keys(values)) {
+        if (k.startsWith('_'))
+            delete values[k];
+    }
+    const response = {
+        type: 'interaction.response', id, action: value._action || 'submit', values, operatorId,
+    };
+    // _custom_input：把用户输入追加到 resolved 卡片正文
+    let resolvedInteraction = interaction;
+    if (interaction && response.action === '_custom_input' && formValues.custom_text) {
+        const newBody = [interaction.kind.body, `**输入内容：** ${formValues.custom_text}`]
+            .filter(Boolean).join('\n\n');
+        resolvedInteraction = { ...interaction, kind: { ...interaction.kind, body: newBody } };
+    }
+    const card = resolvedInteraction
+        ? buildResolvedV2(resolvedInteraction, response)
+        : buildResolvedV2({ type: 'interaction', id, channelId: '', sessionId: '',
+            kind: { kind: 'action', title: '操作', buttons: [] } }, response);
+    return { kind: 'respond', response, card };
+}
 function displayWidth(str) {
     let width = 0;
     for (const ch of str) {
@@ -1327,7 +1423,7 @@ export class FeishuChannelPlugin {
             const adapter = {
                 channelName: inst.name,
                 channelKey: inst.name,
-                capabilities: { file: true, image: true, interaction: true, markdown: true, thought: false, status: true },
+                capabilities: { file: true, image: true, interaction: true, markdown: true, thought: false, status: true, thread: true },
                 send: async (envelope, payload) => {
                     const ctx = envelope.replyContext;
                     const channelId = envelope.channelId;
@@ -1341,6 +1437,8 @@ export class FeishuChannelPlugin {
                             const sendCtx = { ...(ctx ?? {}) };
                             if (payload.kind === 'result.text' && payload.isFinal)
                                 sendCtx.title = '✅ 最终回复:';
+                            if (ctx?.metadata?.onThreadCreated)
+                                sendCtx.onThreadCreated = ctx.metadata.onThreadCreated;
                             await channel.sendMessage(channelId, payload.text, sendCtx);
                             return;
                         }
@@ -1367,9 +1465,12 @@ export class FeishuChannelPlugin {
                         case 'status.progress':
                             // Feishu 通过 acknowledge (✓ 表情) 表达状态，由 channel 自行处理
                             return;
-                        case 'interaction':
-                            await channel.sendInteraction(channelId, payload.interaction, ctx);
+                        case 'interaction': {
+                            const sent = await channel.sendInteraction(channelId, payload.interaction, ctx);
+                            if (!sent)
+                                throw new Error('sendInteraction returned false');
                             return;
+                        }
                         case 'custom':
                             // Feishu 不支持自定义 payload
                             return;
@@ -1425,6 +1526,7 @@ export class FeishuChannelPlugin {
                     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,
+                            selfAID: inst.agentName,
                             chatType: chatType || 'private',
                             peerId: peerId || '', peerName, messageId, mentions, threadId,
                             replyContext: threadId ? { replyToMessageId: rootId ?? threadId, replyInThread: true } : undefined,