evolclaw 2.8.3 → 3.0.0

package/dist/channels/dingtalk.js

@@ -1,6 +1,7 @@
 import { logger } from '../utils/logger.js';
-import { requireOptional } from '../utils/init-channel.js';
-import { normalizeChannelInstances, getChannelShowActivities } from '../config.js';
+import { requireOptional } from '../utils/npm-ops.js';
+import { normalizeChannelInstances, getChannelShowActivities } from '../utils/channel-helpers.js';
+import { formatItemsAsText } from '../core/message/items-formatter.js';
 // ── Webhook SSRF validation ────────────────────────────────────────────────────
 const WEBHOOK_RE = /^https:\/\/(api|oapi)\.dingtalk\.com\//;
 // ── DingtalkChannel ────────────────────────────────────────────────────────────
@@ -446,9 +447,46 @@ export class DingtalkChannelPlugin {
             });
             const adapter = {
                 channelName: inst.name,
-                sendText: (id, text) => channel.sendMessage(id, text),
-                sendFile: (id, filePath) => channel.sendFile(id, filePath),
-                sendImage: (id, png) => channel.sendImage(id, png),
+                capabilities: { file: true, image: true, interaction: false, markdown: true, thought: false, status: false },
+                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':
+                            await channel.sendMessage(channelId, payload.text);
+                            return;
+                        case 'result.file':
+                            await channel.sendFile(channelId, payload.filePath);
+                            return;
+                        case 'result.image':
+                            await channel.sendImage(channelId, payload.data);
+                            return;
+                        case 'activity.batch': {
+                            const text = formatItemsAsText(payload.items);
+                            if (text)
+                                await channel.sendMessage(channelId, text);
+                            return;
+                        }
+                        case 'interaction':
+                            if (payload.fallbackText)
+                                await channel.sendMessage(channelId, payload.fallbackText);
+                            return;
+                        case 'status.started':
+                        case 'status.completed':
+                        case 'status.interrupted':
+                        case 'status.error':
+                        case 'status.timeout':
+                        case 'custom':
+                            return;
+                        default:
+                            logger.warn(`[DingTalk] Unhandled payload kind: ${payload.kind}`);
+                    }
+                },
             };
             const policy = {
                 canSwitchProject: (_chatType, identity) => identity === 'owner' || identity === 'admin',
@@ -493,6 +531,21 @@ export class DingtalkChannelPlugin {
                 connect: () => channel.connect(),
                 disconnect: () => channel.disconnect(),
                 onProjectPathRequest: () => Promise.resolve(config.projects?.defaultPath || process.cwd()),
+                registerBridge(bridge, channelType) {
+                    bridge.register(adapter.channelName, (handler) => channel.onMessage(async (event) => {
+                        await handler({
+                            channel: adapter.channelName,
+                            channelType,
+                            channelId: event.channelId,
+                            content: event.content,
+                            images: event.images,
+                            chatType: event.chatType || 'private',
+                            peerId: event.peerId || '',
+                            peerName: event.peerName,
+                            messageId: event.messageId,
+                        });
+                    }), (channelId, text) => channel.sendMessage(channelId, text), adapter, channelType);
+                },
             });
         }
         return result;

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 事件直接获取）
@@ -278,11 +295,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 +350,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 +363,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 +663,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 +708,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() {
@@ -741,12 +838,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 +922,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 +940,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 +949,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 +961,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 +985,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 +1053,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 +1072,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 +1181,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 +1206,56 @@ 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': {
+                            const text = formatItemsAsText(payload.items);
+                            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 +1300,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;

package/dist/channels/qqbot.js

@@ -1,7 +1,8 @@
 import { logger } from '../utils/logger.js';
 import { markdownToPlainText } from '../utils/rich-content-renderer.js';
-import { requireOptional } from '../utils/init-channel.js';
-import { normalizeChannelInstances, getChannelShowActivities } from '../config.js';
+import { requireOptional } from '../utils/npm-ops.js';
+import { normalizeChannelInstances, getChannelShowActivities } from '../utils/channel-helpers.js';
+import { formatItemsAsText } from '../core/message/items-formatter.js';
 // ── QQBotChannel ────────────────────────────────────────────────────────────
 export class QQBotChannel {
     config;
@@ -245,11 +246,11 @@ export class QQBotChannel {
     async sendImage(chatId, png) {
         if (!this.client)
             return;
+        const fs = await import('fs');
+        const path = await import('path');
+        const os = await import('os');
+        const tmpPath = path.join(os.tmpdir(), `evolclaw-qqbot-${Date.now()}.png`);
         try {
-            const fs = await import('fs');
-            const path = await import('path');
-            const os = await import('os');
-            const tmpPath = path.join(os.tmpdir(), `evolclaw-qqbot-${Date.now()}.png`);
             fs.writeFileSync(tmpPath, png);
             const chatType = this.chatTypeCache.get(chatId);
             const msgId = this.msgIdCache.get(chatId);
@@ -260,14 +261,16 @@ export class QQBotChannel {
             else {
                 await this.client.sendPrivateImage(chatId, `file://${tmpPath}`, msgId);
             }
+        }
+        catch (error) {
+            logger.error(`[QQBot] sendImage failed for ${chatId}:`, error?.message || error);
+        }
+        finally {
             try {
                 fs.unlinkSync(tmpPath);
             }
             catch { /* ignore */ }
         }
-        catch (error) {
-            logger.error(`[QQBot] sendImage failed for ${chatId}:`, error?.message || error);
-        }
     }
     // ── Outbound: file ─────────────────────────────────────────────────────────
     async sendFile(chatId, filePath) {
@@ -331,9 +334,46 @@ export class QQBotChannelPlugin {
             });
             const adapter = {
                 channelName: inst.name,
-                sendText: (id, text) => channel.sendMessage(id, text),
-                sendFile: (id, filePath) => channel.sendFile(id, filePath),
-                sendImage: (id, png) => channel.sendImage(id, png),
+                capabilities: { file: true, image: true, interaction: false, markdown: true, thought: false, status: false },
+                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':
+                            await channel.sendMessage(channelId, payload.text);
+                            return;
+                        case 'result.file':
+                            await channel.sendFile(channelId, payload.filePath);
+                            return;
+                        case 'result.image':
+                            await channel.sendImage(channelId, payload.data);
+                            return;
+                        case 'activity.batch': {
+                            const text = formatItemsAsText(payload.items);
+                            if (text)
+                                await channel.sendMessage(channelId, text);
+                            return;
+                        }
+                        case 'interaction':
+                            if (payload.fallbackText)
+                                await channel.sendMessage(channelId, payload.fallbackText);
+                            return;
+                        case 'status.started':
+                        case 'status.completed':
+                        case 'status.interrupted':
+                        case 'status.error':
+                        case 'status.timeout':
+                        case 'custom':
+                            return;
+                        default:
+                            logger.warn(`[QQBot] Unhandled payload kind: ${payload.kind}`);
+                    }
+                },
             };
             const policy = {
                 canSwitchProject: (_chatType, identity) => identity === 'owner' || identity === 'admin',
@@ -378,6 +418,21 @@ export class QQBotChannelPlugin {
                 connect: () => channel.connect(),
                 disconnect: () => channel.disconnect(),
                 onProjectPathRequest: () => Promise.resolve(config.projects?.defaultPath || process.cwd()),
+                registerBridge(bridge, channelType) {
+                    bridge.register(adapter.channelName, (handler) => channel.onMessage(async (event) => {
+                        handler({
+                            channel: adapter.channelName,
+                            channelType,
+                            channelId: event.channelId,
+                            content: event.content,
+                            images: event.images,
+                            chatType: event.chatType || 'private',
+                            peerId: event.peerId || '',
+                            peerName: event.peerName,
+                            messageId: event.messageId,
+                        });
+                    }), (channelId, text) => channel.sendMessage(channelId, text), adapter, channelType);
+                },
             });
         }
         return result;