evolcore 0.0.1 → 0.0.2

package/dist/channels/dingtalk.js

@@ -0,0 +1,649 @@
+import { randomInt } from 'crypto';
+import { logger } from '../utils/logger.js';
+import { requireOptional } from '../utils/npm-ops.js';
+import { middleOutputModePolicy, resolveShowActivities, showActivitiesPolicy } from '../core/channel-loader.js';
+import { formatItemsAsText } from '../core/message/items-formatter.js';
+import { initWelcomeManager, sendWelcomeIfNeeded } from '../utils/welcome.js';
+import { isValidAid } from '../aun/aid/validation.js';
+import { bindContactAlias } from '../config/contact-book.js';
+export const DINGTALK_BIND_CODE_TTL_MS = 10 * 60 * 1000;
+export const DINGTALK_BIND_MAX_FAILED_ATTEMPTS = 5;
+const pendingContactBinds = new Map();
+export function registerPendingDingtalkContactBind(req) {
+    const selfAid = String(req.selfAid || '').trim();
+    const channelName = String(req.channelName || '').trim();
+    const primaryId = String(req.primaryId || '').trim();
+    const now = req.now ?? Date.now();
+    const code = req.code ? String(req.code).trim() : generateDingtalkBindCode();
+    if (!isValidAid(selfAid))
+        return { ok: false, error: `invalid selfAid: ${req.selfAid}` };
+    if (!channelName)
+        return { ok: false, error: 'missing channelName' };
+    if (!isValidAid(primaryId))
+        return { ok: false, error: `invalid primaryId: ${req.primaryId}` };
+    if (!/^\d{6}$/.test(code))
+        return { ok: false, error: 'binding code must be 6 digits' };
+    const key = pendingBindKey(selfAid, channelName);
+    const replaced = pendingContactBinds.has(key);
+    const item = {
+        selfAid,
+        channelName,
+        primaryId,
+        code,
+        createdAt: now,
+        expiresAt: now + DINGTALK_BIND_CODE_TTL_MS,
+        failedAttempts: 0,
+        maxFailedAttempts: DINGTALK_BIND_MAX_FAILED_ATTEMPTS,
+    };
+    pendingContactBinds.set(key, item);
+    return { ok: true, code, expiresAt: item.expiresAt, replaced };
+}
+export function handlePendingDingtalkContactBindMessage(ctx) {
+    if (ctx.channelType !== 'dingtalk')
+        return { handled: false };
+    const selfAid = String(ctx.selfAid || '').trim();
+    const channelName = String(ctx.channelName || '').trim();
+    if (!selfAid || !channelName)
+        return { handled: false };
+    const key = pendingBindKey(selfAid, channelName);
+    const item = pendingContactBinds.get(key);
+    if (!item)
+        return { handled: false };
+    const now = ctx.now ?? Date.now();
+    if (now >= item.expiresAt) {
+        pendingContactBinds.delete(key);
+        return {
+            handled: true,
+            status: 'expired',
+            remainingAttempts: 0,
+            reply: '钉钉身份绑定码已超时，本次绑定失败。请重新执行 ec init dingtalk 并再次扫码绑定。',
+        };
+    }
+    if (ctx.chatType !== 'private')
+        return { handled: false };
+    const input = String(ctx.content ?? '').trim();
+    if (!/^\d+$/.test(input) || !/^\d{6}$/.test(input)) {
+        return {
+            handled: true,
+            status: 'format',
+            reply: '请直接发送 6 位数字绑定码。格式错误不计入错误次数。',
+            remainingAttempts: item.maxFailedAttempts - item.failedAttempts,
+        };
+    }
+    if (input !== item.code) {
+        item.failedAttempts += 1;
+        const remaining = Math.max(0, item.maxFailedAttempts - item.failedAttempts);
+        if (remaining === 0) {
+            pendingContactBinds.delete(key);
+            return {
+                handled: true,
+                status: 'failed',
+                remainingAttempts: 0,
+                reply: '绑定码错误次数已达上限，本次钉钉身份绑定失败。请重新执行 ec init dingtalk 并再次扫码绑定。',
+            };
+        }
+        return {
+            handled: true,
+            status: 'wrong-code',
+            remainingAttempts: remaining,
+            reply: `绑定码错误，请重新发送 6 位数字绑定码。剩余 ${remaining} 次机会。`,
+        };
+    }
+    const actorId = String(ctx.actorId || '').trim();
+    if (!actorId) {
+        return {
+            handled: true,
+            status: 'missing-actor',
+            remainingAttempts: item.maxFailedAttempts - item.failedAttempts,
+            reply: '无法识别当前钉钉发送者身份，未建立绑定。请重新发送绑定码或重新执行绑定流程。',
+        };
+    }
+    try {
+        bindContactAlias(item.selfAid, item.primaryId, 'dingtalk', actorId, item.channelName);
+        pendingContactBinds.delete(key);
+        return {
+            handled: true,
+            status: 'bound',
+            reply: `钉钉身份绑定成功：dingtalk:${actorId} -> ${item.primaryId}`,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            handled: true,
+            status: 'write-failed',
+            remainingAttempts: item.maxFailedAttempts - item.failedAttempts,
+            reply: `钉钉身份绑定写入失败：${message}`,
+        };
+    }
+}
+export function getPendingDingtalkContactBind(selfAid, channelName) {
+    const item = pendingContactBinds.get(pendingBindKey(selfAid, channelName));
+    return item ? { ...item } : null;
+}
+export function clearPendingDingtalkContactBinds() {
+    pendingContactBinds.clear();
+}
+function generateDingtalkBindCode() {
+    return String(randomInt(0, 1_000_000)).padStart(6, '0');
+}
+function pendingBindKey(selfAid, channelName) {
+    return `${String(selfAid || '').trim()}\u0000${String(channelName || '').trim()}`;
+}
+// ── Webhook SSRF validation ────────────────────────────────────────────────────
+const WEBHOOK_RE = /^https:\/\/(api|oapi)\.dingtalk\.com\//;
+// ── DingtalkChannel ────────────────────────────────────────────────────────────
+export class DingtalkChannel {
+    agentAid;
+    channelName;
+    config;
+    client = null;
+    connected = false;
+    messageHandler = null;
+    recallHandler;
+    webhookCache = new Map();
+    conversationIdCache = new Map();
+    senderStaffIdCache = new Map();
+    seenMessages = new Map();
+    cleanupInterval = null;
+    projectPathProvider = null;
+    // Welcome message manager
+    welcomeManager;
+    constructor(config, agentAid, channelName) {
+        this.agentAid = agentAid;
+        this.channelName = channelName;
+        this.config = config;
+        // 初始化 welcomeManager（使用共享帮助函数）
+        if (agentAid && channelName) {
+            this.welcomeManager = initWelcomeManager('dingtalk', agentAid, channelName);
+        }
+    }
+    // ── Public helpers (testable) ──────────────────────────────────────────────
+    isValidWebhook(url) {
+        if (!url)
+            return false;
+        return WEBHOOK_RE.test(url);
+    }
+    isDuplicate(msgId) {
+        if (this.seenMessages.has(msgId))
+            return true;
+        this.seenMessages.set(msgId, Date.now());
+        return false;
+    }
+    resolveChatId(conversationType, conversationId, senderId) {
+        return conversationType === '2' ? conversationId : senderId;
+    }
+    shouldProcessGroupMessage(conversationId, isInAtList) {
+        if (this.config.requireMention === false)
+            return true;
+        if (this.config.freeResponseChats?.includes(conversationId))
+            return true;
+        return isInAtList;
+    }
+    extractText(content) {
+        if (!content)
+            return '';
+        const text = content.text;
+        if (typeof text === 'string')
+            return text.trim();
+        if (text && typeof text === 'object' && typeof text.content === 'string')
+            return text.content.trim();
+        return '';
+    }
+    // ── Lifecycle ──────────────────────────────────────────────────────────────
+    async connect() {
+        const { clientId, clientSecret } = this.config;
+        if (!clientId || !clientSecret || clientId.includes('your-') || clientSecret.includes('your-')) {
+            throw new Error('DingTalk clientId/clientSecret not configured');
+        }
+        const { DWClient, TOPIC_ROBOT } = await requireOptional('dingtalk-stream');
+        this.client = new DWClient({ clientId, clientSecret });
+        this.client.registerCallbackListener(TOPIC_ROBOT, async (msg) => {
+            await this.handleIncoming(msg);
+        });
+        await this.client.connect();
+        this.connected = true;
+        // Hourly cleanup of old dedup entries
+        this.cleanupInterval = setInterval(() => {
+            const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+            for (const [id, ts] of this.seenMessages) {
+                if (ts < cutoff)
+                    this.seenMessages.delete(id);
+            }
+        }, 60 * 60 * 1000);
+        logger.info('[DingTalk] Connected via Stream Mode');
+    }
+    async disconnect() {
+        this.connected = false;
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        if (this.client) {
+            try {
+                this.client.disconnect();
+            }
+            catch { /* ignore */ }
+            this.client = null;
+        }
+        logger.info('[DingTalk] Disconnected');
+    }
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    onRecall(handler) {
+        this.recallHandler = handler;
+    }
+    // ── Inbound message handling ───────────────────────────────────────────────
+    async handleIncoming(msg) {
+        try {
+            const data = typeof msg.data === 'string' ? JSON.parse(msg.data) : msg.data;
+            const msgId = data.msgId;
+            const conversationType = data.conversationType;
+            const conversationId = data.conversationId;
+            const senderId = data.senderStaffId || data.senderId;
+            const senderNick = data.senderNick;
+            const sessionWebhook = data.sessionWebhook;
+            const msgtype = data.msgtype;
+            // Dedup
+            if (msgId && this.isDuplicate(msgId)) {
+                logger.debug(`[DingTalk] Duplicate message skipped: ${msgId}`);
+                return;
+            }
+            const chatId = this.resolveChatId(conversationType, conversationId, senderId);
+            const chatType = conversationType === '2' ? 'group' : 'private';
+            // Cache sender info for Open API sends
+            if (senderId)
+                this.senderStaffIdCache.set(chatId, senderId);
+            if (conversationId)
+                this.conversationIdCache.set(chatId, conversationId);
+            // Group gate
+            if (conversationType === '2') {
+                const isInAtList = !!(data.isInAtList || (data.atUsers && data.atUsers.length > 0));
+                if (!this.shouldProcessGroupMessage(conversationId, isInAtList)) {
+                    logger.debug(`[DingTalk] Group message ignored (not mentioned): ${msgId}`);
+                    return;
+                }
+            }
+            // Webhook cache (SSRF validated)
+            if (sessionWebhook && this.isValidWebhook(sessionWebhook)) {
+                this.webhookCache.set(chatId, sessionWebhook);
+            }
+            // ACK to prevent 60s retry
+            if (this.client && msg.headers?.messageId) {
+                try {
+                    this.client.socketCallBackResponse(msg.headers.messageId, { response: JSON.stringify({ status: 'OK' }) });
+                }
+                catch (e) {
+                    logger.warn('[DingTalk] ACK failed:', e);
+                }
+            }
+            // Dispatch by msgtype
+            if (!this.messageHandler)
+                return;
+            // 首次交互欢迎消息（使用共享帮助函数）
+            await sendWelcomeIfNeeded(this.welcomeManager, senderId, chatId, (id, text) => this.sendMessage(id, text), 'DingTalk');
+            if (msgtype === 'text' || !msgtype) {
+                const text = this.extractText(data);
+                if (!text)
+                    return;
+                await this.messageHandler({
+                    channelId: chatId, content: text, chatType,
+                    peerId: senderId || '', peerName: senderNick, messageId: msgId,
+                });
+            }
+            else if (msgtype === 'picture' || msgtype === 'image') {
+                await this.handleImageMessage(data, chatId, chatType, senderId, senderNick, msgId);
+            }
+            else if (msgtype === 'file') {
+                await this.handleFileMessage(data, chatId, chatType, senderId, senderNick, msgId);
+            }
+            else if (msgtype === 'richText') {
+                await this.handleRichTextMessage(data, chatId, chatType, senderId, senderNick, msgId);
+            }
+            else {
+                await this.messageHandler({
+                    channelId: chatId,
+                    content: `[不支持的消息类型: ${msgtype}]`,
+                    chatType, peerId: senderId || '', peerName: senderNick, messageId: msgId,
+                });
+            }
+        }
+        catch (error) {
+            logger.error('[DingTalk] Failed to process incoming message:', error);
+        }
+    }
+    // ── Inbound media handling ─────────────────────────────────────────────────
+    async handleImageMessage(data, chatId, chatType, senderId, senderNick, msgId) {
+        const content = typeof data.content === 'string' ? JSON.parse(data.content) : (data.content || {});
+        const downloadUrl = content.downloadUrl || content.downloadCode;
+        if (!downloadUrl) {
+            logger.warn('[DingTalk] Image message without downloadUrl');
+            await this.messageHandler({
+                channelId: chatId, content: '[图片下载失败：缺少下载链接]',
+                chatType, peerId: senderId || '', peerName: senderNick, messageId: msgId,
+            });
+            return;
+        }
+        try {
+            const { safeFetch, validateImage } = await import('../utils/media-cache.js');
+            const buffer = await safeFetch(downloadUrl, { skipSsrfCheck: true });
+            const result = await validateImage(buffer);
+            if (result.mime) {
+                await this.messageHandler({
+                    channelId: chatId,
+                    content: '用户发送了一张图片，请分析这张图片的内容。',
+                    chatType, peerId: senderId || '', peerName: senderNick, messageId: msgId,
+                    images: [{ data: buffer.toString('base64'), mimeType: result.mime }],
+                });
+            }
+            else {
+                logger.warn(`[DingTalk] Image validation failed: ${!result.mime && 'reason' in result ? result.reason : 'unknown'}`);
+                await this.messageHandler({
+                    channelId: chatId, content: '[图片验证失败]',
+                    chatType, peerId: senderId || '', peerName: senderNick, messageId: msgId,
+                });
+            }
+        }
+        catch (error) {
+            logger.error('[DingTalk] Failed to download image:', error);
+            await this.messageHandler({
+                channelId: chatId, content: '[图片下载失败]',
+                chatType, peerId: senderId || '', peerName: senderNick, messageId: msgId,
+            });
+        }
+    }
+    async handleFileMessage(data, chatId, chatType, senderId, senderNick, msgId) {
+        const content = typeof data.content === 'string' ? JSON.parse(data.content) : (data.content || {});
+        const downloadUrl = content.downloadUrl || content.downloadCode;
+        const fileName = content.fileName || 'unknown';
+        if (!downloadUrl) {
+            logger.warn('[DingTalk] File message without downloadUrl');
+            await this.messageHandler({
+                channelId: chatId, content: `[文件下载失败：缺少下载链接] ${fileName}`,
+                chatType, peerId: senderId || '', peerName: senderNick, messageId: msgId,
+            });
+            return;
+        }
+        try {
+            const { safeFetch, saveToUploads, sanitizeFileName } = await import('../utils/media-cache.js');
+            const projectPath = this.projectPathProvider
+                ? await this.projectPathProvider(chatId)
+                : process.cwd();
+            const buffer = await safeFetch(downloadUrl, { skipSsrfCheck: true });
+            const { filePath } = saveToUploads(buffer, sanitizeFileName(fileName), projectPath);
+            await this.messageHandler({
+                channelId: chatId,
+                content: `用户发送了文件：${fileName}\n文件已保存到：${filePath}\n请使用 Read 工具读取并分析文件内容。`,
+                chatType, peerId: senderId || '', peerName: senderNick, messageId: msgId,
+            });
+        }
+        catch (error) {
+            logger.error('[DingTalk] Failed to download file:', error);
+            await this.messageHandler({
+                channelId: chatId, content: `[文件下载失败] ${fileName}`,
+                chatType, peerId: senderId || '', peerName: senderNick, messageId: msgId,
+            });
+        }
+    }
+    async handleRichTextMessage(data, chatId, chatType, senderId, senderNick, msgId) {
+        const content = typeof data.content === 'string' ? JSON.parse(data.content) : (data.content || {});
+        const richText = content.richText;
+        if (!Array.isArray(richText)) {
+            await this.messageHandler({
+                channelId: chatId, content: '[不支持的富文本格式]',
+                chatType, peerId: senderId || '', peerName: senderNick, messageId: msgId,
+            });
+            return;
+        }
+        let text = '';
+        const images = [];
+        for (const item of richText) {
+            if (item.type === 'text' && item.text) {
+                text += item.text;
+            }
+            else if (item.type === 'picture' && item.downloadUrl) {
+                try {
+                    const { safeFetch, validateImage } = await import('../utils/media-cache.js');
+                    const buffer = await safeFetch(item.downloadUrl, { skipSsrfCheck: true });
+                    const result = await validateImage(buffer);
+                    if (result.mime) {
+                        images.push({ data: buffer.toString('base64'), mimeType: result.mime });
+                    }
+                }
+                catch (error) {
+                    logger.warn('[DingTalk] Failed to download richText image:', error);
+                }
+            }
+        }
+        const prompt = text.trim() || (images.length > 0 ? '用户发送了一张图片，请分析这张图片的内容。' : '[空消息]');
+        await this.messageHandler({
+            channelId: chatId, content: prompt, chatType,
+            peerId: senderId || '', peerName: senderNick, messageId: msgId,
+            images: images.length > 0 ? images : undefined,
+        });
+    }
+    // ── Outbound: text via sessionWebhook ──────────────────────────────────────
+    async sendMessage(chatId, content) {
+        const webhook = this.webhookCache.get(chatId);
+        if (!webhook) {
+            logger.warn(`[DingTalk] No webhook cached for chatId: ${chatId}, message dropped`);
+            return;
+        }
+        try {
+            const token = await this.client?.getAccessToken();
+            const response = await fetch(webhook, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-acs-dingtalk-access-token': token || '',
+                },
+                body: JSON.stringify({
+                    msgtype: 'markdown',
+                    markdown: { title: 'Bot', text: content },
+                }),
+                signal: AbortSignal.timeout(15_000),
+            });
+            if (!response.ok) {
+                const body = await response.text().catch(() => '');
+                logger.error(`[DingTalk] sendMessage failed for ${chatId}: ${response.status} ${body}`);
+            }
+        }
+        catch (error) {
+            logger.error(`[DingTalk] sendMessage failed for ${chatId}:`, error.message);
+        }
+    }
+    // ── Outbound: image via Open API ───────────────────────────────────────────
+    async sendImage(chatId, png) {
+        try {
+            const token = await this.client?.getAccessToken();
+            if (!token) {
+                logger.warn('[DingTalk] No access token for sendImage');
+                return;
+            }
+            // Step 1: Upload media
+            const FormData = (await requireOptional('form-data')).default;
+            const form = new FormData();
+            form.append('type', 'image');
+            form.append('media', png, { filename: 'image.png', contentType: 'image/png' });
+            const uploadRes = await fetch(`https://oapi.dingtalk.com/media/upload?access_token=${token}`, { method: 'POST', body: form, signal: AbortSignal.timeout(30_000) });
+            const uploadData = await uploadRes.json();
+            const mediaId = uploadData?.media_id;
+            if (!mediaId) {
+                logger.error('[DingTalk] Media upload failed:', uploadData);
+                return;
+            }
+            // Step 2: Send via robot API
+            await this.sendRobotMessage(chatId, token, 'sampleImageMsg', JSON.stringify({ photoURL: `@${mediaId}` }));
+        }
+        catch (error) {
+            logger.error(`[DingTalk] sendImage failed for ${chatId}:`, error.message);
+        }
+    }
+    // ── Outbound: file via Open API ────────────────────────────────────────────
+    async sendFile(chatId, filePath) {
+        try {
+            // Detect image files → route to sendImage (same pattern as Feishu)
+            const fs = await import('fs');
+            const path = await import('path');
+            const header = Buffer.alloc(12);
+            const fd = fs.openSync(filePath, 'r');
+            fs.readSync(fd, header, 0, 12, 0);
+            fs.closeSync(fd);
+            const { fileTypeFromBuffer } = await import('file-type');
+            const ftype = await fileTypeFromBuffer(header);
+            if (ftype && ftype.mime.startsWith('image/')) {
+                const buf = fs.readFileSync(filePath);
+                return this.sendImage(chatId, buf);
+            }
+            const token = await this.client?.getAccessToken();
+            if (!token) {
+                logger.warn('[DingTalk] No access token for sendFile');
+                return;
+            }
+            // Step 1: Upload media
+            const FormData = (await requireOptional('form-data')).default;
+            const form = new FormData();
+            form.append('type', 'file');
+            form.append('media', fs.createReadStream(filePath), { filename: path.basename(filePath) });
+            const uploadRes = await fetch(`https://oapi.dingtalk.com/media/upload?access_token=${token}`, { method: 'POST', body: form, signal: AbortSignal.timeout(60_000) });
+            const uploadData = await uploadRes.json();
+            const mediaId = uploadData?.media_id;
+            if (!mediaId) {
+                logger.error('[DingTalk] File upload failed:', uploadData);
+                return;
+            }
+            // Step 2: Send via robot API
+            const fileName = path.basename(filePath);
+            const fileType = path.extname(filePath).replace('.', '') || 'file';
+            await this.sendRobotMessage(chatId, token, 'sampleFile', JSON.stringify({ mediaId: `@${mediaId}`, fileName, fileType }));
+        }
+        catch (error) {
+            logger.error(`[DingTalk] sendFile failed for ${chatId}:`, error.message);
+        }
+    }
+    // ── Robot message send helper (group vs DM) ────────────────────────────────
+    async sendRobotMessage(chatId, token, msgKey, msgParam) {
+        const headers = { 'x-acs-dingtalk-access-token': token, 'Content-Type': 'application/json' };
+        const { clientId } = this.config;
+        // Group chatId = conversationId, DM chatId = senderId
+        const cachedConvId = this.conversationIdCache.get(chatId);
+        const staffId = this.senderStaffIdCache.get(chatId);
+        if (cachedConvId === chatId) {
+            // Group: chatId is the conversationId
+            const res = await fetch('https://api.dingtalk.com/v1.0/robot/groupMessages/send', {
+                method: 'POST', headers,
+                body: JSON.stringify({ msgKey, msgParam, openConversationId: chatId, robotCode: clientId }),
+                signal: AbortSignal.timeout(15_000),
+            });
+            if (!res.ok)
+                logger.error(`[DingTalk] Group robot send failed: ${res.status}`);
+        }
+        else if (staffId) {
+            // DM: use senderStaffId
+            const res = await fetch('https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend', {
+                method: 'POST', headers,
+                body: JSON.stringify({ msgKey, msgParam, userIds: [staffId], robotCode: clientId }),
+                signal: AbortSignal.timeout(15_000),
+            });
+            if (!res.ok)
+                logger.error(`[DingTalk] DM robot send failed: ${res.status}`);
+        }
+        else {
+            logger.warn(`[DingTalk] Cannot send robot message: no conversation/staff ID cached for ${chatId}`);
+        }
+    }
+}
+// ── Plugin ─────────────────────────────────────────────────────────────────────
+function isValidCredential(value) {
+    return !!value && !value.includes('your-') && !value.includes('placeholder');
+}
+export class DingtalkChannelPlugin {
+    name = 'dingtalk';
+    async createInstance(inst, ctx) {
+        if (inst.enabled === false)
+            return null;
+        if (!isValidCredential(inst.clientId) || !isValidCredential(inst.clientSecret))
+            return null;
+        const channel = new DingtalkChannel({
+            clientId: inst.clientId,
+            clientSecret: inst.clientSecret,
+            requireMention: inst.requireMention,
+            freeResponseChats: inst.freeResponseChats,
+        }, ctx.agentName, inst.name);
+        const mode = resolveShowActivities(inst);
+        const adapter = {
+            channelName: inst.name,
+            channelKey: inst.name,
+            capabilities: { file: true, image: true, interaction: false, markdown: true, thought: false, status: false, thread: false, authenticatedApproval: true },
+            send: async (envelope, payload) => {
+                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 filtered = payload.items.filter((i) => !(i.kind === 'tool_result' && i.ok));
+                        const text = formatItemsAsText(filtered);
+                        if (text)
+                            await channel.sendMessage(channelId, text);
+                        return;
+                    }
+                    case 'status.requires_action':
+                        await channel.sendMessage(channelId, '等待 owner 审批');
+                        return;
+                    case 'status.error':
+                        if (payload.metadata?.message)
+                            await channel.sendMessage(channelId, payload.metadata.message);
+                        return;
+                    case 'interaction':
+                        if (payload.fallbackText)
+                            await channel.sendMessage(channelId, payload.fallbackText);
+                        return;
+                    default: return;
+                }
+            },
+        };
+        const policy = {
+            canSwitchProject: (_, identity) => identity === 'owner' || identity === 'admin',
+            canListProjects: (_, identity) => identity === 'owner' || identity === 'admin',
+            canCreateSession: () => true,
+            canDeleteSession: () => true,
+            canImportCliSession: (_, identity) => identity === 'owner' || identity === 'admin',
+            messagePrefix: (chatType, peerName) => (chatType === 'group' && peerName) ? `[${peerName}] ` : '',
+            showMiddleResult: (chatType, identity) => showActivitiesPolicy(mode, chatType, identity),
+            middleOutputMode: (chatType, identity) => middleOutputModePolicy(mode, chatType, identity),
+            showIdleMonitor: (chatType, identity) => showActivitiesPolicy(mode, chatType, identity),
+            accumulateErrors: () => true,
+        };
+        return {
+            channelType: 'dingtalk', adapter, channel,
+            policy,
+            options: { fileMarkerPattern: /\[SEND_FILE:(?:(\w+):)?([^\]]+)\]/g, supportsImages: true, flushDelay: inst.flushDelay },
+            connect: () => channel.connect(),
+            disconnect: () => channel.disconnect(),
+            onProjectPathRequest: () => Promise.resolve(ctx.defaultProjectPath),
+            registerBridge(bridge, channelType) {
+                bridge.register(adapter.channelName, (handler) => channel.onMessage(async (event) => {
+                    await handler({
+                        channel: adapter.channelName, channelType, channelId: event.channelId,
+                        selfAID: ctx.agentName, 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);
+            },
+        };
+    }
+}