evolcore 0.0.8 → 0.0.9

package/dist/aun/msg/upload.js

@@ -4,37 +4,30 @@ import path from 'path';
 import { guessMime, formatSize } from '../../utils/media-cache.js';
 import { inferPayloadType, isValidPayloadType } from './payload-type.js';
 /** 单次上传最大大小（与 daemon sendFile 一致）。 */
-const MAX_FILE_SIZE = 10 * 1024 * 1024;
+export const MAX_AUN_ATTACHMENT_SIZE = 10 * 1024 * 1024;
 /** server 端 inline 上限错误的识别特征。优先匹配错误消息里的“inline 上限”字样。 */
 function isInlineLimitError(err) {
     const msg = err?.message ?? '';
     return /inline\s*上限|inline limit|create_upload_session/i.test(msg);
 }
 /**
- * 上传本地文件并构造发送用的 payload。
- *
- * 策略：先无脑 storage.put_object（内联 base64）。server 报“超过 inline 上限”
- * 时降级到 storage.create_upload_session + HTTP PUT + storage.complete_upload，
- * 此时通过 onProgress 上报字节级进度。
+ * 上传内存中的二进制内容并构造发送用的标准附件 payload。
  */
-export async function uploadFileAndBuildPayload(conn, ownerAid, filePath, opts) {
-    const absPath = path.resolve(filePath);
-    if (!fs.existsSync(absPath)) {
-        throw new Error(`文件不存在: ${absPath}`);
+export async function uploadBufferAndBuildPayload(conn, ownerAid, data, filename, opts) {
+    const safeFilename = path.basename(filename.trim());
+    if (!safeFilename || safeFilename === '.' || safeFilename === '..') {
+        throw new Error('文件名不能为空');
     }
-    const stat = fs.statSync(absPath);
-    if (stat.size === 0) {
-        throw new Error(`文件为空: ${absPath}`);
+    if (data.length === 0) {
+        throw new Error(`文件为空: ${safeFilename}`);
     }
-    if (stat.size > MAX_FILE_SIZE) {
-        throw new Error(`文件过大 (${formatSize(stat.size)}, 上限 ${formatSize(MAX_FILE_SIZE)}): ${absPath}`);
+    if (data.length > MAX_AUN_ATTACHMENT_SIZE) {
+        throw new Error(`文件过大 (${formatSize(data.length)}, 上限 ${formatSize(MAX_AUN_ATTACHMENT_SIZE)}): ${safeFilename}`);
     }
-    const filename = path.basename(absPath);
-    const fileData = fs.readFileSync(absPath);
-    const sha256 = crypto.createHash('sha256').update(fileData).digest('hex');
-    const contentType = opts?.contentType ?? guessMime(filename);
-    const objectKey = `shared/${crypto.randomUUID()}/${filename}`;
-    const total = stat.size;
+    const sha256 = crypto.createHash('sha256').update(data).digest('hex');
+    const contentType = opts?.contentType ?? guessMime(safeFilename);
+    const objectKey = `shared/${crypto.randomUUID()}/${safeFilename}`;
+    const total = data.length;
     const report = (phase, bytes) => opts?.onProgress?.({ phase, bytes, total });
     // 1. 先按 inline 走
     let inlineRejected = false;
@@ -42,7 +35,7 @@ export async function uploadFileAndBuildPayload(conn, ownerAid, filePath, opts)
         report('inline', 0);
         await conn.call('storage.put_object', {
             object_key: objectKey,
-            content: fileData.toString('base64'),
+            content: data.toString('base64'),
             content_type: contentType,
             is_private: false,
             overwrite: true,
@@ -70,10 +63,9 @@ export async function uploadFileAndBuildPayload(conn, ownerAid, filePath, opts)
         const PROGRESS_TICK_MS = 250;
         let lastBytes = 0;
         const tickerStart = Date.now();
-        // 简单的“估算”进度：实际上一次性发，但在等待响应期间按 elapsed 模拟字节数，让用户看到在跑
+        // 实际上一次性发送；等待响应期间按 2MB/s 估算进度，且不超过 99%。
         const ticker = setInterval(() => {
             const elapsed = Date.now() - tickerStart;
-            // 假设 2MB/s 估算；不超过 99%
             const estimated = Math.min(total - 1, Math.floor((elapsed / 1000) * 2 * 1024 * 1024));
             if (estimated > lastBytes) {
                 lastBytes = estimated;
@@ -84,7 +76,7 @@ export async function uploadFileAndBuildPayload(conn, ownerAid, filePath, opts)
         try {
             uploadResp = await fetch(uploadUrl, {
                 method: 'PUT',
-                body: new Blob([new Uint8Array(fileData)], { type: contentType }),
+                body: new Blob([new Uint8Array(data)], { type: contentType }),
                 headers: { 'Content-Type': contentType },
             });
         }
@@ -107,12 +99,11 @@ export async function uploadFileAndBuildPayload(conn, ownerAid, filePath, opts)
     const attachment = {
         owner_aid: ownerAid,
         object_key: objectKey,
-        filename,
+        filename: safeFilename,
         size_bytes: total,
         sha256,
         content_type: contentType,
     };
-    // 确定渲染类型
     let type;
     if (opts?.as) {
         if (!isValidPayloadType(opts.as)) {
@@ -121,7 +112,7 @@ export async function uploadFileAndBuildPayload(conn, ownerAid, filePath, opts)
         type = opts.as;
     }
     else {
-        type = inferPayloadType(filename);
+        type = inferPayloadType(safeFilename);
     }
     const payload = {
         type,
@@ -130,8 +121,31 @@ export async function uploadFileAndBuildPayload(conn, ownerAid, filePath, opts)
     if (opts?.text)
         payload.text = opts.text;
     else if (type === 'file')
-        payload.text = `📎 ${filename} (${formatSize(total)})`;
+        payload.text = `📎 ${safeFilename} (${formatSize(total)})`;
     if (type === 'voice' && opts?.transcript)
         payload.transcript = opts.transcript;
     return { payload, type, attachment };
 }
+/**
+ * 上传本地文件并构造发送用的 payload。
+ *
+ * 策略：先无脑 storage.put_object（内联 base64）。server 报“超过 inline 上限”
+ * 时降级到 storage.create_upload_session + HTTP PUT + storage.complete_upload，
+ * 此时通过 onProgress 上报字节级进度。
+ */
+export async function uploadFileAndBuildPayload(conn, ownerAid, filePath, opts) {
+    const absPath = path.resolve(filePath);
+    if (!fs.existsSync(absPath)) {
+        throw new Error(`文件不存在: ${absPath}`);
+    }
+    const stat = fs.statSync(absPath);
+    if (stat.size === 0) {
+        throw new Error(`文件为空: ${absPath}`);
+    }
+    if (stat.size > MAX_AUN_ATTACHMENT_SIZE) {
+        throw new Error(`文件过大 (${formatSize(stat.size)}, 上限 ${formatSize(MAX_AUN_ATTACHMENT_SIZE)}): ${absPath}`);
+    }
+    const filename = path.basename(absPath);
+    const fileData = fs.readFileSync(absPath);
+    return uploadBufferAndBuildPayload(conn, ownerAid, fileData, filename, opts);
+}

package/dist/aun/outbox.js

@@ -59,6 +59,7 @@ export function enqueue(aid, opts) {
         payload: opts.payload,
         text: opts.text,
         filePath: opts.filePath,
+        image: opts.image,
         logText: opts.logText,
         context: opts.context,
         ttl: opts.ttl ?? DEFAULT_TTL,
@@ -81,6 +82,16 @@ export function remove(aid, id) {
     const entries = readEntries(aid).filter(e => e.id !== id);
     writeEntries(aid, entries);
 }
+/** Replace an existing entry without consuming another outbox slot. */
+export function replace(aid, entry) {
+    const entries = readEntries(aid);
+    const index = entries.findIndex(candidate => candidate.id === entry.id);
+    if (index < 0)
+        return false;
+    entries[index] = entry;
+    writeEntries(aid, entries);
+    return true;
+}
 /** Remove durable interaction cards that were cancelled before delivery. */
 export function removeInteractionCards(aid, requestId) {
     const entries = readEntries(aid);
@@ -102,7 +113,11 @@ export function cleanup(aid) {
         writeEntries(aid, valid);
     return removed;
 }
-export async function drain(aid, sender) {
+// Each caller gets its own pass over the current disk state. This prevents
+// duplicate sends while allowing a later drain trigger to pick up entries
+// enqueued during an active pass.
+const activeDrainTails = new Map();
+async function drainOnce(aid, sender) {
     const entries = readEntries(aid);
     if (entries.length === 0)
         return { sent: 0, expired: 0, failed: 0 };
@@ -135,12 +150,40 @@ export async function drain(aid, sender) {
         }
     }
     const current = readEntries(aid);
-    const currentIds = new Set(current.map(e => e.id));
-    const retainedNewEntries = current.filter(e => !drainedIds.has(e.id));
-    const retainedFailedEntries = remaining.filter(e => currentIds.has(e.id));
-    writeEntries(aid, [...retainedFailedEntries, ...retainedNewEntries]);
+    const failedById = new Map(remaining.map(entry => [entry.id, entry]));
+    const retained = current.flatMap(entry => {
+        if (!drainedIds.has(entry.id))
+            return [entry];
+        const failedEntry = failedById.get(entry.id);
+        if (!failedEntry)
+            return [];
+        return [{
+                ...failedEntry,
+                ...entry,
+                attempts: failedEntry.attempts,
+                lastError: failedEntry.lastError,
+            }];
+    });
+    writeEntries(aid, retained);
     return { sent, expired, failed };
 }
+export async function drain(aid, sender) {
+    const previous = activeDrainTails.get(aid);
+    let releaseTurn;
+    const turn = new Promise(resolve => { releaseTurn = resolve; });
+    const tail = (previous ?? Promise.resolve()).then(() => turn);
+    activeDrainTails.set(aid, tail);
+    if (previous)
+        await previous;
+    try {
+        return await drainOnce(aid, sender);
+    }
+    finally {
+        releaseTurn();
+        if (activeDrainTails.get(aid) === tail)
+            activeDrainTails.delete(aid);
+    }
+}
 export function hasPending(aid) {
     const file = outboxFile(aid);
     if (!fs.existsSync(file))

package/dist/channels/aun.js

@@ -16,9 +16,8 @@ import { chatDirPath } from '../core/session/session-fs-store.js';
 import { appendHintAdd, appendHintRemove, parseInjectRequest } from '../core/message/pending-hints.js';
 import { appendAidLifecycle } from '../aun/aid/identity.js';
 import { getAidStore, loadClient, SLOT } from '../aun/aid/store.js';
-import { uploadFileAndBuildPayload } from '../aun/msg/upload.js';
+import { MAX_AUN_ATTACHMENT_SIZE, uploadBufferAndBuildPayload, uploadFileAndBuildPayload } from '../aun/msg/upload.js';
 import { loadAgent, saveAgent } from '../config-store.js';
-import { activeBaseagent } from '../core/model/config-scope.js';
 import { resolveEffective } from '../config/config-manager.js';
 import { isManagementRole } from '../config/builtin-roles.js';
 import { mentionModeToDispatch } from '../config/mention-mode.js';
@@ -36,6 +35,18 @@ import { refreshAgentDisplayName, resolveAgentDisplayName } from '../aun/aid/age
 import { readInstalledEvolcoreVersion } from '../utils/evolcore-version.js';
 export const AUN_HANDOFF_MARKER_FIELD = '_evolcore_handoff_id';
 const AUN_INTERACTION_CARD_TTL_MS = 24 * 60 * 60 * 1000;
+const IMAGE_MIME_TYPE = /^image\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/i;
+function normalizeImageMimeType(mimeType) {
+    const normalized = mimeType?.split(';', 1)[0].trim().toLowerCase();
+    if (!normalized)
+        return undefined;
+    if (!normalized.startsWith('image/'))
+        return undefined;
+    if (!IMAGE_MIME_TYPE.test(normalized)) {
+        throw new Error('result.image MIME type must be a valid image media type');
+    }
+    return normalized;
+}
 /**
  * 构造 connect extra_info：自描述本进程身份。
  *
@@ -360,10 +371,11 @@ export class AUNChannel {
                         || (channelId && !this.isGroupId(channelId) ? channelId : '')
                         || '';
                     if (cardInfo.isCommandCard) {
-                        // CommandCard：action_value 是完整 slash 命令，构造伪入站消息
-                        this.cardMessageIdMap.delete(cardMsgId);
+                        // CommandCard：action_value 是完整 slash 命令，构造伪入站消息。
+                        // 先完成点击者鉴权，再消费 mapping；否则群成员的一次误点会让发起者
+                        // 无法继续操作同一张卡片。
+                        const chatType = channelId ? (this.isGroupId(channelId) ? 'group' : 'private') : 'private';
                         if (this.messageHandler && actionValue.startsWith('/')) {
-                            const chatType = channelId ? (this.isGroupId(channelId) ? 'group' : 'private') : 'private';
                             // Initiator 校验：仅群聊需要（私聊信道一对一，点击者恒为对端 = initiator）。
                             // 身份只信认证信封提取的 cardClickerAid，非 payload 自报。
                             if (chatType === 'group' && !cardClickerAid) {
@@ -377,6 +389,9 @@ export class AUNChannel {
                                 this.notifyCardActionFailure(channelId, '⚠️ 仅卡片发起者可操作', cardClickerAid, threadId);
                                 return '';
                             }
+                            // 已通过鉴权并即将进入处理流程；此时才消费 mapping，避免非发起者
+                            // 或非法命令点击导致卡片提前失效。
+                            this.cardMessageIdMap.delete(cardMsgId);
                             Promise.resolve(this.messageHandler({
                                 channelId: channelId || '',
                                 channelType: 'aun',
@@ -580,6 +595,38 @@ export class AUNChannel {
                 parts.push('---');
                 return parts.join('\n');
             }
+            // 结构化 link/location 必须优先保留业务字段。部分客户端同时提供
+            // 顶层 text（仅供展示），若先返回该字段会丢失 URL、坐标和地址。
+            if (obj.type === 'link') {
+                const parts = [];
+                if (typeof obj.title === 'string' && obj.title)
+                    parts.push(`标题: ${obj.title}`);
+                if (typeof obj.description === 'string' && obj.description)
+                    parts.push(`描述: ${obj.description}`);
+                if (typeof obj.url === 'string' && obj.url)
+                    parts.push(`URL: ${obj.url}`);
+                if (text && !parts.includes(text))
+                    parts.push(text);
+                return parts.length > 0 ? parts.join('\n') : text || JSON.stringify(payload);
+            }
+            if (obj.type === 'location') {
+                const parts = [];
+                if (typeof obj.name === 'string' && obj.name)
+                    parts.push(`地点: ${obj.name}`);
+                if (typeof obj.address === 'string' && obj.address)
+                    parts.push(`地址: ${obj.address}`);
+                if (typeof obj.latitude === 'number' && Number.isFinite(obj.latitude))
+                    parts.push(`纬度: ${obj.latitude}`);
+                if (typeof obj.longitude === 'number' && Number.isFinite(obj.longitude))
+                    parts.push(`经度: ${obj.longitude}`);
+                if (typeof obj.precision_m === 'number' && Number.isFinite(obj.precision_m))
+                    parts.push(`精度: ${obj.precision_m}m`);
+                if (typeof obj.map_url === 'string' && obj.map_url)
+                    parts.push(`地图: ${obj.map_url}`);
+                if (text && !parts.includes(text))
+                    parts.push(text);
+                return parts.length > 0 ? parts.join('\n') : text || JSON.stringify(payload);
+            }
             if (typeof obj.text === 'string')
                 return text;
             return JSON.stringify(payload);
@@ -714,8 +761,11 @@ export class AUNChannel {
             this.messageSeqMap.delete(messageId);
     }
     shouldEncrypt(_peerId) {
-        // Default to plaintext; only encrypt when session is explicitly marked encrypted
-        return false;
+        return this.config.defaultEncrypt ?? true;
+    }
+    /** Effective channel default for callers that must persist a concrete transport choice. */
+    getDefaultEncrypt() {
+        return this.shouldEncrypt(this.config.aid);
     }
     _aid;
     _selfName; // 本地 agent.md 中的 name，首次 connect 时读取
@@ -1143,13 +1193,10 @@ EvolCore AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             await this.callAndTrace('message.send', {
                 to: owner,
                 payload: { type: 'text', text: welcomeText },
-                encrypt: true,
+                encrypt: this.shouldEncrypt(owner),
                 persist_required: true,
             });
             logger.info(`${this.logPrefix()} Welcome message sent to owner: ${owner}`);
-            // Send binding credential for Evol App to persist locally
-            // active_baseagent 经 config-scope 解析。
-            await this.sendBindingCredential(owner, agentDisplayName, activeBaseagent(aidName)).catch(e => logger.warn(`${this.logPrefix()} Binding credential failed: ${e}`));
             // Mark agent as initialized in config.json (replaces old agent.md frontmatter flag)
             try {
                 const fresh = loadAgent(aidName);
@@ -1167,17 +1214,6 @@ EvolCore AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             logger.warn(`${this.logPrefix()} Failed to send welcome message: ${e}`);
         }
     }
-    async sendBindingCredential(owner, name, baseagent) {
-        if (!this.client)
-            return;
-        await this.callAndTrace('message.send', {
-            to: owner,
-            payload: { type: 'binding', aid: this.config.aid, name, owner, baseagent },
-            encrypt: true,
-            persist_required: true,
-        });
-        logger.info(`${this.logPrefix()} Binding credential sent to owner: ${owner}`);
-    }
     // ── Event handlers ──────────────────────────────────────────
     /**
      * 统一处理入站附件：下载 → 图片识别+base64 注入 → 拼接文本。
@@ -1926,7 +1962,7 @@ EvolCore AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
     //
     // observable=true 时，Agent 收发的每条 AUN 消息（原始信封 + 解密后明文
     // payload）镜像一份给 owners[]。入站在所有过滤之前转发；出站在真实发送
-    // 成功后转发。外层一律明文。详见 docs/observer-mode-design.md。
+    // 成功后转发。Observer 使用 daemon 的全局 AUN 默认加密设置，业务合同保持不变。
     // observable / owners 不在此处缓存——由 daemon 注入 resolver，从 EvolAgent 的
     // in-memory merged config（启动/重启/热重载时统一更新的唯一缓存）读取，避免重复缓存。
     observerConfigResolver;
@@ -1989,7 +2025,7 @@ EvolCore AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
         this.emitForward('outbound', result, recipientOwners);
     }
     /**
-     * 实际投递 observer.forward 给每个 owner，外层一律明文。
+     * 实际投递 observer.forward 给每个 owner，使用 daemon 的全局 AUN 默认加密设置。
      * original 为 SDK 给到的原始对象（入站回调 data / 出站 SendResult），整体透传，
      * 不挑字段、不改字段——SDK 加任何字段都会自动一并转发给 owner。
      */
@@ -2000,9 +2036,10 @@ EvolCore AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             agent_aid: this.config.aid,
             original,
         };
+        const encrypt = this.shouldEncrypt('observer.forward');
         for (const ownerAid of owners) {
-            this.callAndTrace('message.send', { to: ownerAid, payload: forwardPayload, encrypt: false })
-                .catch(e => logger.debug(`${this.logPrefix()} observer.forward to ${ownerAid} failed: ${e}`));
+            this.callAndTrace('message.send', { to: ownerAid, payload: forwardPayload, encrypt })
+                .catch(e => logger.warn(`${this.logPrefix()} observer.forward send to ${ownerAid} failed: ${e}`));
         }
     }
     // ── 观察者插话（Observer Insert，v0.3 待用上下文提示） ──────────────
@@ -2012,7 +2049,7 @@ EvolCore AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
     // （不 dispatch、不跑 LLM、不回 owner）；下一条对端消息到达时由 message-processor
     // 回放消费、注入渲染层。action=add 加提示 / remove 撤销。
     // 详见 docs/observer-insert-design.md 第一部分。
-    /** 回 observer.inject.ack 给 owner（明文）。accepted 在成功写盘之后发出。 */
+    /** 回 observer.inject.ack 给 owner；加密使用 daemon 的全局 AUN 默认设置。 */
     emitInjectAck(ownerAid, injectId, data, error) {
         if (!this.connected || !this.client)
             return;
@@ -2023,8 +2060,8 @@ EvolCore AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             ackPayload.data = data;
         if (error)
             ackPayload.error = error;
-        this.callAndTrace('message.send', { to: ownerAid, payload: ackPayload, encrypt: false })
-            .catch(e => logger.debug(`${this.logPrefix()} observer.inject.ack to ${ownerAid} failed: ${e}`));
+        this.callAndTrace('message.send', { to: ownerAid, payload: ackPayload, encrypt: this.shouldEncrypt(ownerAid) })
+            .catch(e => logger.warn(`${this.logPrefix()} observer.inject.ack send to ${ownerAid} failed: ${e}`));
     }
     /** 处理 observer.inject：鉴权 + 校验 + 只落盘到 pending-hints（不触发处理、不回 owner）。 */
     handleObserverInject(fromAid, payload, displayName, peerType) {
@@ -2524,9 +2561,6 @@ EvolCore AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
         }
     }
     payloadByteLength(payload, logText) {
-        if (payload.type === 'image' && typeof payload.data_base64 === 'string') {
-            return Buffer.byteLength(payload.data_base64, 'utf-8');
-        }
         return Buffer.byteLength(logText, 'utf-8');
     }
     applyReplyContextToPayload(payload, context) {
@@ -2546,11 +2580,16 @@ EvolCore AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
         const timer = setTimeout(() => this.invalidatedInteractions.delete(interactionId), 24 * 60 * 60 * 1000);
         timer.unref?.();
     }
-    async recallInteractionCard(messageId) {
+    async recallInteractionCard(messageId, channelId) {
         if (!this.client || !this.connected)
             return false;
         try {
-            await this.callAndTrace('message.recall', { message_ids: [messageId] }, { silentError: true });
+            const isGroup = channelId ? this.isGroupId(channelId) : false;
+            const method = isGroup ? 'group.recall' : 'message.recall';
+            const params = isGroup
+                ? { group_id: channelId, message_ids: [messageId] }
+                : { message_ids: [messageId] };
+            await this.callAndTrace(method, params, { silentError: true });
             return true;
         }
         catch (error) {
@@ -2571,8 +2610,9 @@ EvolCore AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
         }
         const messageIds = [...(this.interactionCardMessageIds.get(interactionId) ?? [])];
         for (const messageId of messageIds) {
+            const channelId = this.cardMessageIdMap.get(messageId)?.channelId;
             this.forgetInteractionCard(messageId, interactionId);
-            await this.recallInteractionCard(messageId);
+            await this.recallInteractionCard(messageId, channelId);
         }
     }
     forgetInteractionCard(messageId, interactionId) {
@@ -2582,13 +2622,14 @@ EvolCore AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
         if (ids && ids.size === 0)
             this.interactionCardMessageIds.delete(interactionId);
     }
-    registerCardPostSend(messageId, action) {
+    registerCardPostSend(messageId, action, channelId) {
         if (action.type !== 'register_interaction_card')
             return;
         this.cardMessageIdMap.set(messageId, {
             requestId: action.requestId,
             isCommandCard: action.isCommandCard,
             initiatorAid: action.initiatorAid,
+            channelId,
         });
         this.ownedCardMsgIds.add(messageId);
         let messageIds = this.interactionCardMessageIds.get(action.requestId);
@@ -2614,14 +2655,14 @@ EvolCore AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
         const invalidationReason = this.invalidatedInteractions.get(action.requestId);
         if (invalidationReason) {
             this.cardMessageIdMap.delete(messageId);
-            void this.recallInteractionCard(messageId);
+            void this.recallInteractionCard(messageId, channelId);
         }
     }
     runPostSend(entry, messageId) {
         if (!entry.postSend)
             return;
         if (entry.postSend.type === 'register_interaction_card') {
-            this.registerCardPostSend(messageId, entry.postSend);
+            this.registerCardPostSend(messageId, entry.postSend, entry.channelId);
         }
     }
     async sendAunPayload(channelId, payload, context, label) {
@@ -2936,7 +2977,7 @@ EvolCore AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             finalPayload._evolcore_causation_ref = causationRef;
             registerAunCausation(causationRef, this.config.aid, args.to, outboundCausation);
         }
-        const encrypt = args.encrypt === true;
+        const encrypt = args.encrypt ?? this.shouldEncrypt(args.to);
         const sendParams = {
             to: args.to,
             payload: this.truncatePayloadIfNeeded(finalPayload, 'msg-send-ipc'),
@@ -3041,7 +3082,7 @@ EvolCore AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
         const finalPayload = this.stripUndefinedDeep({ ...args.payload });
         if (args.mentions?.length)
             finalPayload.mentions = args.mentions;
-        const encrypt = args.encrypt === true;
+        const encrypt = args.encrypt ?? this.shouldEncrypt(args.groupId);
         try {
             const result = await this.callAndTrace('group.send', {
                 group_id: args.groupId,
@@ -3534,6 +3575,117 @@ EvolCore AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             outbox.remove(this.config.aid, entry.id);
         }
     }
+    async sendImage(channelId, data, mimeType, alt, context) {
+        if (!Buffer.isBuffer(data)) {
+            throw new Error('result.image data must be a Buffer');
+        }
+        if (data.length === 0) {
+            throw new Error('result.image data cannot be empty');
+        }
+        if (data.length > MAX_AUN_ATTACHMENT_SIZE) {
+            throw new Error(`result.image is too large (${formatSize(data.length)}, max ${formatSize(MAX_AUN_ATTACHMENT_SIZE)})`);
+        }
+        let normalizedMimeType = normalizeImageMimeType(mimeType);
+        if (!normalizedMimeType) {
+            const { default: imageType } = await import('image-type');
+            const detected = await imageType(data).catch(() => undefined);
+            normalizedMimeType = detected?.mime;
+            if (!normalizedMimeType) {
+                throw new Error('result.image requires a valid image MIME type or recognizable image data');
+            }
+        }
+        const logText = alt ? `[image] ${alt}` : '[image]';
+        const entry = outbox.enqueue(this.config.aid, {
+            channelId,
+            type: 'image',
+            contentKind: 'image',
+            image: { dataBase64: data.toString('base64'), mimeType: normalizedMimeType, alt },
+            context,
+            logText,
+        });
+        logger.debug(`${this.logPrefix()} Outbox enqueued image: id=${entry.id} channel=${channelId} bytes=${data.length}`);
+        if (!this.connected || !this.client) {
+            logger.warn(`${this.logPrefix()} Not connected, image send queued in outbox (id=${entry.id}). Triggering reconnect.`);
+            if (!this.reconnectTimer && !this.client) {
+                this.initClient().catch(e => logger.error(`${this.logPrefix()} Reconnect from sendImage failed: ${e}`));
+            }
+            return;
+        }
+        const ok = await this.withOutboxInFlight(entry, () => this.deliverImageEntry(entry), false);
+        if (ok)
+            outbox.remove(this.config.aid, entry.id);
+    }
+    async buildUploadedImagePayload(data, mimeType, alt) {
+        if (!this.connected || !this.client) {
+            throw new Error('AUN channel is not connected; image cannot be uploaded');
+        }
+        let contentType = normalizeImageMimeType(mimeType);
+        let extension;
+        if (!contentType) {
+            const { default: imageType } = await import('image-type');
+            const detected = await imageType(data).catch(() => undefined);
+            contentType = detected?.mime;
+            extension = detected?.ext;
+        }
+        if (!contentType) {
+            throw new Error('result.image requires a valid image MIME type or recognizable image data');
+        }
+        if (!extension) {
+            const subtype = contentType.slice('image/'.length);
+            extension = subtype === 'jpeg'
+                ? 'jpg'
+                : subtype === 'svg+xml'
+                    ? 'svg'
+                    : subtype.replace(/[^a-z0-9]/g, '') || 'img';
+        }
+        const digest = crypto.createHash('sha256').update(data).digest('hex').slice(0, 12);
+        const filename = `image-${digest}.${extension}`;
+        const connection = {
+            call: (method, params) => this.callAndTrace(method, params),
+            close: async () => { },
+        };
+        const built = await uploadBufferAndBuildPayload(connection, this.config.aid, data, filename, { as: 'image', contentType });
+        const imagePayload = { ...built.payload };
+        setIfDefined(imagePayload, 'alt', alt);
+        return imagePayload;
+    }
+    async deliverImageEntry(entry) {
+        const image = entry.image;
+        if (!image || typeof image.dataBase64 !== 'string') {
+            logger.warn(`${this.logPrefix()} deliverImageEntry: missing image data (outbox id=${entry.id})`);
+            return true;
+        }
+        const data = Buffer.from(image.dataBase64, 'base64');
+        if (data.length === 0) {
+            logger.warn(`${this.logPrefix()} deliverImageEntry: invalid image data (outbox id=${entry.id})`);
+            return true;
+        }
+        const imagePayload = await this.buildUploadedImagePayload(data, image.mimeType, image.alt);
+        entry.type = 'payload';
+        entry.contentKind = 'image';
+        entry.payload = this.applyReplyContextToPayload(imagePayload, entry.context);
+        entry.logText ??= image.alt ? `[image] ${image.alt}` : '[image]';
+        delete entry.image;
+        // Persist the attachment reference before message.send. A failed send then
+        // retries the compact wire payload without re-uploading the same image.
+        let payloadEntry = entry;
+        if (!outbox.replace(this.config.aid, entry)) {
+            payloadEntry = outbox.enqueue(this.config.aid, {
+                channelId: entry.channelId,
+                type: 'payload',
+                contentKind: 'image',
+                payload: entry.payload,
+                context: entry.context,
+                logText: entry.logText,
+                ttl: entry.ttl,
+            });
+        }
+        const sent = await this.deliverPayloadEntry(payloadEntry);
+        if (sent.ok && payloadEntry.id !== entry.id) {
+            outbox.remove(this.config.aid, payloadEntry.id);
+        }
+        return sent.ok;
+    }
     async deliverFileEntry(entry) {
         const channelId = entry.channelId;
         const absPath = entry.filePath;
@@ -3720,6 +3872,9 @@ EvolCore AI Agent 网关，支持多项目会话管理和多 AI 后端切换。
             else if (entry.type === 'file') {
                 return this.withOutboxInFlight(entry, () => this.deliverFileEntry(entry), false);
             }
+            else if (entry.type === 'image') {
+                return this.withOutboxInFlight(entry, () => this.deliverImageEntry(entry), false);
+            }
             else if (entry.type === 'payload') {
                 const sent = await this.withOutboxInFlight(entry, () => this.deliverPayloadEntry(entry), { ok: false });
                 return sent.ok;
@@ -4026,6 +4181,7 @@ export class AUNChannelPlugin {
             aid,
             keystorePath: inst.keystorePath,
             gatewayUrl: inst.gatewayUrl,
+            defaultEncrypt: ctx.aunDefaultEncrypt,
             accessToken: inst.accessToken,
             flushDelay: inst.flushDelay,
             agentName: ctx.agentName,
@@ -4092,16 +4248,7 @@ export class AUNChannelPlugin {
                         return;
                     }
                     case 'result.image': {
-                        const buf = payload.data;
-                        const b64 = buf.toString('base64');
-                        const imagePayload = { type: 'image', data_base64: b64 };
-                        setIfDefined(imagePayload, 'alt', payload.alt);
-                        setIfDefined(imagePayload, 'mime_type', payload.mimeType);
-                        await channel.sendContentPayload(channelId, imagePayload, {
-                            contentKind: 'image',
-                            context: replyCtx,
-                            logText: payload.alt ? `[image] ${payload.alt}` : '[image]',
-                        });
+                        await channel.sendImage(channelId, payload.data, payload.mimeType, payload.alt, replyCtx);
                         return;
                     }
                     case 'activity.batch': {
@@ -4209,6 +4356,8 @@ export class AUNChannelPlugin {
                                 aunCard.text = card.body;
                                 setIfDefined(aunCard, 'format', card.bodyFormat);
                             }
+                            if (req.initiatorId && channel.isGroupId(channelId))
+                                aunCard.initiator = req.initiatorId;
                             if (replyCtx?.threadId)
                                 aunCard.thread_id = replyCtx.threadId;
                             await channel.sendContentPayload(channelId, aunCard, {