evolcore 0.0.19 → 0.0.21

package/dist/aun/msg/history.js

@@ -1,29 +1,16 @@
 import path from 'path';
 import { isValidAid } from '../aid/identity.js';
 import { isTransientProtocolMessage, messageLogPath } from '../../core/message/message-log.js';
-import { chatDirPath, readAllJsonlLines, readJsonFile, readLastJsonlLine } from '../../core/session/session-fs-store.js';
+import { chatDirPath, readAllJsonlLines, readJsonFile, readLastJsonlLine, scanChatDirs, scanMetaFiles } from '../../core/session/session-fs-store.js';
+import { tryParseChannelKey } from '../../core/channel-loader.js';
 import { resolvePaths } from '../../paths.js';
 const DEFAULT_LIMIT = 50;
 export const MAX_MSG_HISTORY_LIMIT = 500;
 const SESSION_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,255}$/;
-const CHANNELS = new Set(['aun', 'feishu', 'wechat', 'dingtalk', 'qqbot', 'wecom']);
 export function msgHistory(args, options = {}) {
     if (!isValidAid(args.from)) {
         return error('INVALID_SELF_AID', `无效 self AID: ${args.from}`);
     }
-    const channel = args.channel ?? 'aun';
-    if (!CHANNELS.has(channel)) {
-        return error('INVALID_CHANNEL', `不支持的 channel: ${String(args.channel)}`);
-    }
-    if (channel === 'aun' && !isValidAid(args.target)) {
-        return error('INVALID_TARGET_AID', `无效 target AID: ${args.target}`);
-    }
-    if (channel !== 'aun' && !isSafeChannelPeerId(args.target)) {
-        return error('INVALID_TARGET_ID', `无效 ${channel} 对端 ID`);
-    }
-    if (args.channelName !== undefined && !isSafeChannelName(args.channelName)) {
-        return error('INVALID_CHANNEL_NAME', '无效 channel 实例名');
-    }
     const limit = args.limit ?? DEFAULT_LIMIT;
     if (!Number.isInteger(limit) || limit < 1 || limit > MAX_MSG_HISTORY_LIMIT) {
         return error('INVALID_LIMIT', `limit 必须是 1-${MAX_MSG_HISTORY_LIMIT} 的整数`);
@@ -42,36 +29,167 @@ export function msgHistory(args, options = {}) {
         return error('INVALID_TIME_RANGE', 'after 必须早于 before');
     }
     const sessionsDir = options.sessionsDir ?? resolvePaths().sessionsDir;
-    const chatDir = chatDirPath(sessionsDir, channel, args.target, args.from, channel === 'aun' && !args.channelName ? undefined : `${channel}#${args.from}#${args.channelName ?? 'main'}`);
-    const resolvedSession = resolveSessionFilter(chatDir, args.from, args.target, channel, args.session ?? 'latest');
+    if (args.channelKey !== undefined || args.peerId !== undefined) {
+        return msgHistoryByChannelPeer(args, { sessionsDir, limit, direction });
+    }
+    return msgHistoryByLegacyRoute(args, { sessionsDir, limit, direction });
+}
+function msgHistoryByLegacyRoute(args, options) {
+    const channel = args.channel ?? 'aun';
+    const target = args.target;
+    if (!isSafeChannelType(channel)) {
+        return error('INVALID_CHANNEL', `无效 channel: ${String(args.channel)}`);
+    }
+    if (!target)
+        return error('INVALID_TARGET_ID', '缺少 target ID');
+    if (channel === 'aun' && !isValidAid(target)) {
+        return error('INVALID_TARGET_AID', `无效 target AID: ${target}`);
+    }
+    if (channel !== 'aun' && !isSafeChannelPeerId(target)) {
+        return error('INVALID_TARGET_ID', `无效 ${channel} 对端 ID`);
+    }
+    if (args.channelName !== undefined && !isSafeChannelName(args.channelName)) {
+        return error('INVALID_CHANNEL_NAME', '无效 channel 实例名');
+    }
+    const chatDir = chatDirPath(options.sessionsDir, channel, target, args.from, channel === 'aun' && !args.channelName ? undefined : `${channel}#${args.from}#${args.channelName ?? 'main'}`);
+    const resolvedSession = resolveLegacySessionFilter(chatDir, args.from, target, channel, args.session ?? 'latest');
     if (!resolvedSession.ok)
         return resolvedSession;
-    let entries;
+    return readHistoryScopes({
+        args,
+        scopes: [{
+                chatDir,
+                ...(resolvedSession.sessionId ? { sessionIds: [resolvedSession.sessionId] } : {}),
+            }],
+        target,
+        limit: options.limit,
+        direction: options.direction,
+    });
+}
+function msgHistoryByChannelPeer(args, options) {
+    if (!args.channelKey || !args.peerId) {
+        return error('INVALID_CHANNEL_SELECTOR', '--channel-key 与 --peer-id 必须同时提供');
+    }
+    if (args.target !== undefined || args.channel !== undefined || args.channelName !== undefined) {
+        return error('INVALID_CHANNEL_SELECTOR', '使用 --channel-key/--peer-id 时不能同时指定 target、--channel 或 --channel-name');
+    }
+    if (!isSafeChannelPeerId(args.peerId)) {
+        return error('INVALID_PEER_ID', '无效 peer ID');
+    }
+    const channel = tryParseChannelKey(args.channelKey);
+    if (!channel || !isSafeChannelType(channel.type) || !isSafeChannelName(channel.name)) {
+        return error('INVALID_CHANNEL_KEY', 'channelKey 必须是完整且安全的 <type>#<selfAID>#<instance>');
+    }
+    if (channel.type === 'aun' || channel.type === 'daemon') {
+        return error('INVALID_CHANNEL_SELECTOR', `${channel.type} history 不支持 --channel-key/--peer-id 定位`);
+    }
+    if (channel.selfAID !== args.from) {
+        return error('SESSION_SCOPE_MISMATCH', 'channelKey 中的 self AID 必须与 from 一致');
+    }
+    const requested = args.session ?? 'latest';
+    if (requested !== 'latest' && requested !== 'all' && !SESSION_ID_RE.test(requested)) {
+        return error('INVALID_SESSION_ID', `无效 session ID: ${requested}`);
+    }
+    const scopesByChatDir = new Map();
+    let latest;
+    let requestedSessionWasOutOfScope = false;
+    for (const entry of scanChatDirs(options.sessionsDir)) {
+        if (entry.selfAID !== args.from
+            || entry.channelType !== channel.type
+            || entry.channelKey !== args.channelKey) {
+            continue;
+        }
+        const candidates = readPersistedSessions(entry.dirPath);
+        for (const session of candidates) {
+            if (!session.id || !SESSION_ID_RE.test(session.id))
+                continue;
+            const belongsToPeer = nonAunSessionBelongsToPeer(session, args.from, args.channelKey, channel.type, args.peerId);
+            if (requested === 'all') {
+                if (!belongsToPeer)
+                    continue;
+                addScopeSession(scopesByChatDir, entry.dirPath, session.id);
+                continue;
+            }
+            if (requested === 'latest') {
+                if (!belongsToPeer)
+                    continue;
+                if (!latest || compareSessionRecency(session, entry.dirPath, latest.session, latest.chatDir) > 0) {
+                    latest = { chatDir: entry.dirPath, session };
+                }
+                continue;
+            }
+            if (session.id !== requested)
+                continue;
+            if (!belongsToPeer) {
+                requestedSessionWasOutOfScope = true;
+                continue;
+            }
+            addScopeSession(scopesByChatDir, entry.dirPath, session.id);
+        }
+    }
+    if (requested === 'latest') {
+        if (latest)
+            addScopeSession(scopesByChatDir, latest.chatDir, latest.session.id);
+        else
+            return error('LATEST_SESSION_NOT_FOUND', '该 channelKey/peerId 对暂无最新会话');
+    }
+    const scopes = [...scopesByChatDir.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([chatDir, sessionIds]) => ({ chatDir, sessionIds: [...sessionIds].sort() }));
+    if (requested !== 'latest' && requested !== 'all' && scopes.length === 0) {
+        if (requestedSessionWasOutOfScope) {
+            return error('SESSION_SCOPE_MISMATCH', '指定会话不属于该 channelKey/peerId 对');
+        }
+        return error('SESSION_NOT_FOUND', `在该 channelKey/peerId 对中找不到会话: ${requested}`);
+    }
+    return readHistoryScopes({
+        args,
+        scopes,
+        target: args.peerId,
+        channelKey: args.channelKey,
+        peerId: args.peerId,
+        limit: options.limit,
+        direction: options.direction,
+    });
+}
+function readHistoryScopes(input) {
+    const entries = [];
     try {
-        entries = readAllJsonlLines(messageLogPath(chatDir));
+        input.scopes.forEach((scope, scopeIndex) => {
+            const sessionIds = scope.sessionIds ? new Set(scope.sessionIds) : undefined;
+            for (const entry of readAllJsonlLines(messageLogPath(scope.chatDir))) {
+                entries.push({ entry, sessionIds, scope: scopeIndex });
+            }
+        });
     }
     catch (cause) {
         return error('HISTORY_READ_FAILED', cause instanceof Error ? cause.message : String(cause));
     }
     const messages = entries
-        .filter(entry => isMessageLogEntry(entry))
-        .filter(entry => !isTransientProtocolMessage(entry))
-        .filter(entry => resolvedSession.sessionId === undefined || entry.sessionId === resolvedSession.sessionId)
-        .filter(entry => direction === 'all' || entry.dir === direction)
-        .filter(entry => args.after === undefined || entry.ts > args.after)
-        .filter(entry => args.before === undefined || entry.ts < args.before)
-        .sort((left, right) => left.ts - right.ts)
-        .slice(-limit);
+        .filter(({ entry }) => isMessageLogEntry(entry))
+        .filter(({ entry }) => !isTransientProtocolMessage(entry))
+        .filter(({ entry, sessionIds }) => sessionIds === undefined
+        || (typeof entry.sessionId === 'string' && sessionIds.has(entry.sessionId)))
+        .filter(({ entry }) => input.direction === 'all' || entry.dir === input.direction)
+        .filter(({ entry }) => input.args.after === undefined || entry.ts > input.args.after)
+        .filter(({ entry }) => input.args.before === undefined || entry.ts < input.args.before)
+        .sort((left, right) => left.entry.ts - right.entry.ts || left.scope - right.scope)
+        .slice(-input.limit)
+        .map(({ entry }) => entry);
+    const sessionIds = [...new Set(input.scopes.flatMap(scope => scope.sessionIds ?? []))];
     return {
         ok: true,
-        self_aid: args.from,
-        target_aid: args.target,
-        session_id: resolvedSession.sessionId,
+        self_aid: input.args.from,
+        target_aid: input.target,
+        ...(input.channelKey ? { channel_key: input.channelKey } : {}),
+        ...(input.peerId ? { peer_id: input.peerId } : {}),
+        ...(sessionIds.length === 1 ? { session_id: sessionIds[0] } : {}),
+        ...(sessionIds.length > 1 ? { session_ids: sessionIds } : {}),
         count: messages.length,
         messages,
     };
 }
-function resolveSessionFilter(chatDir, selfAid, targetAid, channel, requested) {
+function resolveLegacySessionFilter(chatDir, selfAid, targetId, channel, requested) {
     if (requested === 'all')
         return { ok: true };
     if (requested === 'latest') {
@@ -79,7 +197,7 @@ function resolveSessionFilter(chatDir, selfAid, targetAid, channel, requested) {
         if (!active?.id) {
             return error('LATEST_SESSION_NOT_FOUND', '该 AID 对暂无最新会话');
         }
-        if (!sessionBelongsToPair(active, selfAid, targetAid, channel)) {
+        if (!legacySessionBelongsToRoute(active, selfAid, targetId, channel)) {
             return error('SESSION_SCOPE_MISMATCH', 'active.json 不属于指定 AID 对');
         }
         return { ok: true, sessionId: active.id };
@@ -89,7 +207,7 @@ function resolveSessionFilter(chatDir, selfAid, targetAid, channel, requested) {
     }
     const active = readJsonFile(path.join(chatDir, 'active.json'));
     if (active?.id === requested) {
-        if (!sessionBelongsToPair(active, selfAid, targetAid, channel)) {
+        if (!legacySessionBelongsToRoute(active, selfAid, targetId, channel)) {
             return error('SESSION_SCOPE_MISMATCH', '指定会话不属于该 AID 对');
         }
         return { ok: true, sessionId: requested };
@@ -101,23 +219,82 @@ function resolveSessionFilter(chatDir, selfAid, targetAid, channel, requested) {
         const session = readLastJsonlLine(sessionPath);
         if (!session || session.id !== requested)
             continue;
-        if (!sessionBelongsToPair(session, selfAid, targetAid, channel)) {
+        if (!legacySessionBelongsToRoute(session, selfAid, targetId, channel)) {
             return error('SESSION_SCOPE_MISMATCH', '指定会话不属于该 AID 对');
         }
         return { ok: true, sessionId: requested };
     }
     return error('SESSION_NOT_FOUND', `在该 AID 对中找不到会话: ${requested}`);
 }
-function sessionBelongsToPair(session, selfAid, targetAid, channel) {
+function legacySessionBelongsToRoute(session, selfAid, targetId, channel) {
     if (session.channelType && session.channelType !== channel)
         return false;
-    if (session.channelId && session.channelId !== targetAid)
+    if (session.channelId && session.channelId !== targetId)
         return false;
     const storedSelfAid = session.selfAID ?? session.selfId;
     if (storedSelfAid && storedSelfAid !== selfAid)
         return false;
     return true;
 }
+function nonAunSessionBelongsToPeer(session, selfAid, channelKey, channelType, peerId) {
+    if (session.channelType !== channelType)
+        return false;
+    const storedSelfAid = session.selfAID ?? session.selfId;
+    if (storedSelfAid !== selfAid)
+        return false;
+    // The canonical chat directory is the authoritative channel-instance
+    // binding. Older metadata may retain a pre-migration `channel` key (for
+    // example `...#feishu` after the directory moved to `...#main`); only an
+    // explicitly persisted metadata.channelKey can contradict the directory.
+    if (session.metadata?.channelKey !== undefined && session.metadata.channelKey !== channelKey)
+        return false;
+    return session.metadata?.peerId === peerId;
+}
+/**
+ * `active.json` is only a cache. Session JSONL files are the authoritative
+ * history index, including archived and topic sessions, so selector reads
+ * inspect all three locations before deciding which message IDs are in scope.
+ */
+function readPersistedSessions(chatDir) {
+    const byId = new Map();
+    const add = (session) => {
+        if (!session?.id || !SESSION_ID_RE.test(session.id))
+            return;
+        const current = byId.get(session.id);
+        if (!current || compareSessionRecency(session, chatDir, current, chatDir) > 0) {
+            byId.set(session.id, session);
+        }
+    };
+    add(readJsonFile(path.join(chatDir, 'active.json')));
+    for (const metadataDir of [chatDir, path.join(chatDir, '_threads')]) {
+        for (const fileName of scanMetaFiles(metadataDir)) {
+            add(readLastJsonlLine(path.join(metadataDir, fileName)));
+        }
+    }
+    return [...byId.values()];
+}
+function addScopeSession(scopes, chatDir, sessionId) {
+    const sessionIds = scopes.get(chatDir) ?? new Set();
+    sessionIds.add(sessionId);
+    scopes.set(chatDir, sessionIds);
+}
+function compareSessionRecency(left, leftChatDir, right, rightChatDir) {
+    const leftTime = Number.isFinite(left.updatedAt) ? left.updatedAt : left.createdAt ?? 0;
+    const rightTime = Number.isFinite(right.updatedAt) ? right.updatedAt : right.createdAt ?? 0;
+    if (leftTime !== rightTime)
+        return leftTime - rightTime;
+    const leftId = left.id ?? '';
+    const rightId = right.id ?? '';
+    if (leftId !== rightId)
+        return leftId.localeCompare(rightId);
+    return leftChatDir.localeCompare(rightChatDir);
+}
+function isSafeChannelType(value) {
+    return typeof value === 'string'
+        && value.trim().length > 0
+        && value.length <= 128
+        && !/[\u0000-\u001f\u007f#\/\\]/.test(value);
+}
 function isSafeChannelPeerId(value) {
     return typeof value === 'string'
         && value.trim().length > 0

package/dist/aun/msg/managed-operation.js

@@ -5,6 +5,7 @@ import { msgOnline } from './p2p.js';
 import { resolveRoot } from '../../paths.js';
 import { isExplicitGroupId } from '../group-identity.js';
 import { isValidAid } from '../aid/validation.js';
+import { tryParseChannelKey } from '../../core/channel-loader.js';
 import { downloadGroupFsBytes } from '../group-fs-download.js';
 import { groupBan, groupBanlist, groupCreate, groupDissolve, groupInfo, groupInvite, groupJoin, groupKick, groupLeave, groupList, groupMembers, groupOnline, groupPull, groupAck, groupResume, groupRules, groupRulesFileGet, groupRulesFilePublish, groupRulesFileSet, groupSetRole, groupSuspend, groupTransferOwner, groupUnban, groupUpdate, groupUpdateRules, } from './group.js';
 /** Rules uploaded by a managed task are carried as bounded UTF-8 content. */
@@ -415,7 +416,7 @@ export class ManagedMsgOperationError extends Error {
     }
 }
 const HISTORY_VALUE_FLAGS = new Set([
-    '--session', '--limit', '--before', '--after', '--direction', '--format',
+    '--session', '--limit', '--before', '--after', '--direction', '--format', '--channel-key', '--peer-id',
 ]);
 function failMsg(code, reason) {
     return { ok: false, code, reason };
@@ -431,7 +432,8 @@ function parseTime(value) {
     const timestamp = Date.parse(trimmed);
     return Number.isFinite(timestamp) ? timestamp : undefined;
 }
-/** Parse the daemon-owned, private-relation msg read grammar. */
+/** Parse the daemon-owned msg read grammar. AUN keeps positional peer AIDs;
+ * non-AUN history is selected by its canonical channel key and native peer ID. */
 export function resolveManagedMsgOperation(argv) {
     const raw = argv[0] === 'msg' ? argv.slice(1) : argv;
     const kind = raw[0];
@@ -439,12 +441,12 @@ export function resolveManagedMsgOperation(argv) {
         return failMsg('NOT_ALLOWED', `unsupported managed msg command: ${kind || '<missing>'}`);
     }
     const from = String(raw[1] || '').replace(/^@/, '');
-    const target = String(raw[2] || '').replace(/^@/, '');
     if (!isValidAid(from))
         return failMsg('INVALID_AID', `invalid from AID: ${from || '<missing>'}`);
-    if (!isValidAid(target))
-        return failMsg('INVALID_AID', `invalid target AID: ${target || '<missing>'}`);
     if (kind === 'online') {
+        const target = String(raw[2] || '').replace(/^@/, '');
+        if (!isValidAid(target))
+            return failMsg('INVALID_AID', `invalid target AID: ${target || '<missing>'}`);
         const allowed = new Set(['--format']);
         let format;
         for (let index = 3; index < raw.length; index++) {
@@ -470,9 +472,14 @@ export function resolveManagedMsgOperation(argv) {
             },
         };
     }
+    const positionals = [];
     const values = new Map();
-    for (let index = 3; index < raw.length; index++) {
+    for (let index = 2; index < raw.length; index++) {
         const flag = raw[index];
+        if (!flag.startsWith('--')) {
+            positionals.push(flag);
+            continue;
+        }
         if (flag === '--aun-path' || flag === '--app' || flag === '--channel' || flag === '--channel-name') {
             return failMsg('NOT_ALLOWED', `${flag} is not allowed for managed msg history`);
         }
@@ -485,6 +492,29 @@ export function resolveManagedMsgOperation(argv) {
             return failMsg('INVALID_ARGUMENT', `${flag} requires a value`);
         values.set(flag, value);
     }
+    if (positionals.length > 1)
+        return failMsg('INVALID_ARGUMENT', 'managed msg history accepts at most one positional target');
+    const channelKey = values.get('--channel-key');
+    const peerId = values.get('--peer-id');
+    if ((channelKey === undefined) !== (peerId === undefined)) {
+        return failMsg('INVALID_ARGUMENT', '--channel-key and --peer-id must be provided together');
+    }
+    if (channelKey !== undefined) {
+        if (positionals.length !== 0) {
+            return failMsg('INVALID_ARGUMENT', '--channel-key/--peer-id cannot be combined with a positional target');
+        }
+        const parsedChannelKey = tryParseChannelKey(channelKey);
+        if (!parsedChannelKey || parsedChannelKey.selfAID !== from || parsedChannelKey.type === 'aun' || parsedChannelKey.type === 'daemon') {
+            return failMsg('INVALID_ARGUMENT', '--channel-key must be a non-AUN channel key belonging to from AID');
+        }
+        if (!peerId?.trim())
+            return failMsg('INVALID_ARGUMENT', '--peer-id must be non-empty');
+    }
+    else {
+        const target = String(positionals[0] || '').replace(/^@/, '');
+        if (!isValidAid(target))
+            return failMsg('INVALID_AID', `invalid target AID: ${target || '<missing>'}`);
+    }
     const format = values.get('--format');
     if (format !== undefined && format !== 'text' && format !== 'json') {
         return failMsg('INVALID_ARGUMENT', '--format only supports text|json');
@@ -509,14 +539,31 @@ export function resolveManagedMsgOperation(argv) {
     if (before !== undefined && after !== undefined && after >= before) {
         return failMsg('INVALID_ARGUMENT', '--after must be earlier than --before');
     }
+    const target = channelKey === undefined ? String(positionals[0] || '').replace(/^@/, '') : undefined;
+    const canonicalArgv = ['msg', kind, from];
+    if (target !== undefined)
+        canonicalArgv.push(target);
+    else
+        canonicalArgv.push('--channel-key', channelKey, '--peer-id', peerId);
+    if (values.has('--session'))
+        canonicalArgv.push('--session', values.get('--session'));
+    if (values.has('--limit'))
+        canonicalArgv.push('--limit', values.get('--limit'));
+    if (values.has('--before'))
+        canonicalArgv.push('--before', values.get('--before'));
+    if (values.has('--after'))
+        canonicalArgv.push('--after', values.get('--after'));
+    if (values.has('--direction'))
+        canonicalArgv.push('--direction', values.get('--direction'));
     return {
         ok: true,
         command: {
             kind,
             operationId: 'ec.msg.history',
-            canonicalArgv: ['msg', kind, from, target],
+            canonicalArgv,
             from,
-            target,
+            ...(target !== undefined ? { target } : {}),
+            ...(channelKey !== undefined ? { channelKey, peerId } : {}),
             session: values.get('--session'),
             limit,
             before,
@@ -531,7 +578,9 @@ export async function executeManagedMsgOperation(command) {
         ? msgHistory({
             from: command.from,
             target: command.target,
-            channel: 'aun',
+            ...(command.channelKey
+                ? { channelKey: command.channelKey, peerId: command.peerId }
+                : { target: command.target, channel: 'aun' }),
             session: command.session,
             limit: command.limit,
             before: command.before,

package/dist/aun/msg/p2p.js

@@ -214,6 +214,11 @@ async function appendMsgSendOutboundLog(args, result, opts) {
 }
 export async function msgSend(args) {
     const runtimeContext = await readBestTaskRuntimeContext();
+    // Contact admission is a daemon-owned policy for managed Agent tasks. A
+    // non-managed CLI caller may use any valid AUN sender identity and must not
+    // require an unrelated local Agent config (for example codex.agentid.cn).
+    // Managed sends are forced through tryDaemonMsgSend(), where the daemon
+    // checks the authoritative Contact Book before opening the AUN route.
     let conn;
     try {
         let payload;
@@ -289,24 +294,34 @@ export async function msgSend(args) {
         const encrypt = resolveAunMessageEncrypt(args.encrypt);
         const sendParams = { to: args.to, payload, encrypt };
         const result = await conn.call('message.send', sendParams);
+        const messageId = typeof result?.message_id === 'string' && result.message_id.trim()
+            ? result.message_id
+            : typeof result?.message?.message_id === 'string' && result.message.message_id.trim()
+                ? result.message.message_id
+                : undefined;
+        if (!messageId) {
+            return {
+                ok: false,
+                error: 'message.send returned no message_id',
+                code: 'MISSING_MESSAGE_ID',
+            };
+        }
         // 5. 写出方向 jsonl（与 daemon 一致格式，标记 source）
         // source 标记：
         // - 'cli': 用户手动调用 ec msg send
         // - 'msg': agent 在会话中调用 ec msg send
-        if (result?.message_id) {
-            try {
-                await appendMsgSendOutboundLog(args, { ok: true, message_id: result.message_id }, {
-                    payload,
-                    runtimeContext,
-                    chatmode,
-                    encrypt,
-                });
-            }
-            catch { }
+        try {
+            await appendMsgSendOutboundLog(args, { ok: true, message_id: messageId }, {
+                payload,
+                runtimeContext,
+                chatmode,
+                encrypt,
+            });
         }
+        catch { }
         return {
             ok: true,
-            message_id: result?.message_id,
+            message_id: messageId,
             seq: result?.seq,
             timestamp: result?.timestamp,
             status: result?.status,