@ryantest/openclaw-qqbot 1.6.6-alpha.4 → 1.6.7-beta.2

package/dist/src/message-queue.js

@@ -1,15 +1,97 @@
-// 消息队列配置
-const MESSAGE_QUEUE_SIZE = 1000;
-const PER_USER_QUEUE_SIZE = 20;
-const MAX_CONCURRENT_USERS = 10;
+// ── 消息队列默认配置 ──
+const DEFAULT_GLOBAL_QUEUE_SIZE = 1000;
+const DEFAULT_PER_PEER_QUEUE_SIZE = 20;
+const DEFAULT_GROUP_QUEUE_SIZE = 50;
+const DEFAULT_MAX_CONCURRENT_USERS = 10;
+// ── 群消息合并工具函数 ──
+/** 判断 peerId 是否属于群聊 */
+const isGroupPeer = (peerId) => peerId.startsWith("group:") || peerId.startsWith("guild:");
+/**
+ * 将多条群消息合并为一条，用于群聊场景下排队消息的批量处理。
+ * - content 拼接为多行，每行带发送者前缀
+ * - 附件合并
+ * - messageId / msgIdx / timestamp 取最后一条（用于回复引用）
+ * - mentions 合并去重
+ * - 如果有任意一条 @了你（is_you），合并结果也标记 @你
+ * - senderIsBot 只要有一条不是 bot 就算非 bot
+ */
+function mergeGroupMessages(batch) {
+    if (batch.length === 1)
+        return batch[0];
+    const last = batch[batch.length - 1];
+    const first = batch[0];
+    // 拼接内容：每条消息带发送者前缀
+    const mergedContent = batch
+        .map((m) => {
+        const name = m.senderName ?? m.senderId;
+        return `[${name}]: ${m.content}`;
+    })
+        .join("\n");
+    // 合并附件
+    const mergedAttachments = [];
+    for (const m of batch) {
+        if (m.attachments?.length) {
+            mergedAttachments.push(...m.attachments);
+        }
+    }
+    // 合并 mentions（去重 by member_openid/id）
+    const seenMentionIds = new Set();
+    const mergedMentions = [];
+    let hasAtYouEvent = false;
+    for (const m of batch) {
+        if (m.eventType === "GROUP_AT_MESSAGE_CREATE") {
+            hasAtYouEvent = true;
+        }
+        if (m.mentions) {
+            for (const mt of m.mentions) {
+                const key = mt.member_openid ?? mt.id ?? mt.user_openid ?? "";
+                if (key && seenMentionIds.has(key))
+                    continue;
+                if (key)
+                    seenMentionIds.add(key);
+                mergedMentions.push(mt);
+            }
+        }
+    }
+    // senderIsBot: 只要有一条来自非 bot 用户，就算非 bot
+    const allFromBot = batch.every((m) => m.senderIsBot);
+    return {
+        type: last.type,
+        senderId: last.senderId,
+        senderName: last.senderName,
+        senderIsBot: allFromBot,
+        content: mergedContent,
+        messageId: last.messageId,
+        timestamp: last.timestamp,
+        channelId: last.channelId,
+        guildId: last.guildId,
+        groupOpenid: last.groupOpenid,
+        attachments: mergedAttachments.length > 0 ? mergedAttachments : undefined,
+        refMsgIdx: first.refMsgIdx,
+        msgIdx: last.msgIdx,
+        eventType: hasAtYouEvent ? "GROUP_AT_MESSAGE_CREATE" : last.eventType,
+        mentions: mergedMentions.length > 0 ? mergedMentions : undefined,
+        messageScene: last.messageScene,
+        _mergedCount: batch.length,
+        _mergedMessages: batch.length > 1 ? batch : undefined,
+    };
+}
 /**
  * 创建按用户并发的消息队列（同用户串行，跨用户并行）
+ *
+ * 内置群消息增强：
+ * - 群聊 / 私聊使用不同队列上限
+ * - 群聊溢出时优先丢弃 bot 消息
+ * - drain 时自动合并群聊排队消息（斜杠命令单独处理）
  */
 export function createMessageQueue(ctx) {
     const { accountId, log } = ctx;
+    const globalQueueSize = ctx.globalQueueSize ?? DEFAULT_GLOBAL_QUEUE_SIZE;
+    const peerQueueSize = ctx.peerQueueSize ?? DEFAULT_PER_PEER_QUEUE_SIZE;
+    const groupQueueSize = ctx.groupQueueSize ?? DEFAULT_GROUP_QUEUE_SIZE;
+    const maxConcurrentUsers = ctx.maxConcurrentUsers ?? DEFAULT_MAX_CONCURRENT_USERS;
     const userQueues = new Map();
     const activeUsers = new Set();
-    let messagesProcessed = 0;
     let handleMessageFnRef = null;
     let totalEnqueued = 0;
     const getMessagePeerId = (msg) => {
@@ -19,11 +101,55 @@ export function createMessageQueue(ctx) {
             return `group:${msg.groupOpenid ?? "unknown"}`;
         return `dm:${msg.senderId}`;
     };
+    /** 从满队列中淘汰一条消息（群聊优先丢弃 bot 消息，否则丢弃最旧） */
+    const evictOne = (queue, isGroup) => {
+        if (isGroup) {
+            const botIdx = queue.findIndex(m => m.senderIsBot);
+            if (botIdx >= 0)
+                return queue.splice(botIdx, 1)[0];
+        }
+        return queue.shift();
+    };
+    /** 判断消息是否为斜杠指令 */
+    const isSlashCommand = (msg) => (msg.content ?? "").trim().startsWith("/");
+    /** 处理单条消息，捕获异常并记录日志 */
+    const processOne = async (msg, peerId, label) => {
+        try {
+            await handleMessageFnRef(msg);
+            return true;
+        }
+        catch (err) {
+            log?.error(`[qqbot:${accountId}] ${label} error for ${peerId}: ${err}`);
+            return false;
+        }
+    };
+    /** 批量处理群聊排队消息：斜杠指令逐条处理，普通消息合并后处理 */
+    const drainGroupBatch = async (all, peerId) => {
+        const commands = [];
+        const normal = [];
+        for (const m of all) {
+            (isSlashCommand(m) ? commands : normal).push(m);
+        }
+        // 指令消息逐条处理
+        for (const cmd of commands) {
+            log?.info(`[qqbot:${accountId}] Processing command independently for ${peerId}: ${(cmd.content ?? "").trim().slice(0, 50)}`);
+            await processOne(cmd, peerId, "Command processor");
+        }
+        // 普通消息合并后处理
+        if (normal.length > 0) {
+            const merged = mergeGroupMessages(normal);
+            if (normal.length > 1) {
+                log?.info(`[qqbot:${accountId}] Merged ${normal.length} queued group messages for ${peerId} into one`);
+            }
+            await processOne(merged, peerId, `Message processor (merged batch of ${normal.length})`);
+        }
+    };
+    /** 处理指定 peer 队列中的消息（串行） */
     const drainUserQueue = async (peerId) => {
         if (activeUsers.has(peerId))
             return;
-        if (activeUsers.size >= MAX_CONCURRENT_USERS) {
-            log?.info(`[qqbot:${accountId}] Max concurrent users (${MAX_CONCURRENT_USERS}) reached, ${peerId} will wait`);
+        if (activeUsers.size >= maxConcurrentUsers) {
+            log?.info(`[qqbot:${accountId}] Max concurrent users (${maxConcurrentUsers}) reached, ${peerId} will wait`);
             return;
         }
         const queue = userQueues.get(peerId);
@@ -32,26 +158,30 @@ export function createMessageQueue(ctx) {
             return;
         }
         activeUsers.add(peerId);
+        const isGroup = isGroupPeer(peerId);
         try {
             while (queue.length > 0 && !ctx.isAborted()) {
+                // 群聊排队 > 1 条：批量处理
+                if (isGroup && queue.length > 1 && handleMessageFnRef) {
+                    const all = queue.splice(0, queue.length);
+                    totalEnqueued = Math.max(0, totalEnqueued - all.length);
+                    await drainGroupBatch(all, peerId);
+                    continue;
+                }
+                // 非群聊 或 队列只剩 1 条：逐条处理
                 const msg = queue.shift();
                 totalEnqueued = Math.max(0, totalEnqueued - 1);
-                try {
-                    if (handleMessageFnRef) {
-                        await handleMessageFnRef(msg);
-                        messagesProcessed++;
-                    }
-                }
-                catch (err) {
-                    log?.error(`[qqbot:${accountId}] Message processor error for ${peerId}: ${err}`);
+                if (handleMessageFnRef) {
+                    await processOne(msg, peerId, "Message processor");
                 }
             }
         }
         finally {
             activeUsers.delete(peerId);
             userQueues.delete(peerId);
+            // 尽量填满并发槽位
             for (const [waitingPeerId, waitingQueue] of userQueues) {
-                if (activeUsers.size >= MAX_CONCURRENT_USERS)
+                if (activeUsers.size >= maxConcurrentUsers)
                     break;
                 if (waitingQueue.length > 0 && !activeUsers.has(waitingPeerId)) {
                     drainUserQueue(waitingPeerId);
@@ -61,26 +191,38 @@ export function createMessageQueue(ctx) {
     };
     const enqueue = (msg) => {
         const peerId = getMessagePeerId(msg);
+        const isGroup = isGroupPeer(peerId);
         let queue = userQueues.get(peerId);
         if (!queue) {
             queue = [];
             userQueues.set(peerId, queue);
         }
-        if (queue.length >= PER_USER_QUEUE_SIZE) {
-            const dropped = queue.shift();
-            log?.error(`[qqbot:${accountId}] Per-user queue full for ${peerId}, dropping oldest message ${dropped?.messageId}`);
+        // 群聊和非群聊使用不同的队列上限
+        const maxSize = isGroup ? groupQueueSize : peerQueueSize;
+        // 队列溢出：淘汰一条旧消息
+        if (queue.length >= maxSize) {
+            const dropped = evictOne(queue, isGroup);
+            totalEnqueued = Math.max(0, totalEnqueued - 1);
+            if (isGroup && dropped?.senderIsBot) {
+                log?.info(`[qqbot:${accountId}] Queue full for ${peerId}, dropping bot message ${dropped.messageId}`);
+            }
+            else {
+                log?.error(`[qqbot:${accountId}] Queue full for ${peerId}, dropping oldest message ${dropped?.messageId}`);
+            }
         }
+        // 全局总量保护
         totalEnqueued++;
-        if (totalEnqueued > MESSAGE_QUEUE_SIZE) {
+        if (totalEnqueued > globalQueueSize) {
             log?.error(`[qqbot:${accountId}] Global queue limit reached (${totalEnqueued}), message from ${peerId} may be delayed`);
         }
         queue.push(msg);
         log?.debug?.(`[qqbot:${accountId}] Message enqueued for ${peerId}, user queue: ${queue.length}, active users: ${activeUsers.size}`);
+        // 如果该用户没有正在处理的消息，立即启动处理
         drainUserQueue(peerId);
     };
     const startProcessor = (handleMessageFn) => {
         handleMessageFnRef = handleMessageFn;
-        log?.info(`[qqbot:${accountId}] Message processor started (per-user concurrency, max ${MAX_CONCURRENT_USERS} users)`);
+        log?.info(`[qqbot:${accountId}] Message processor started (per-user concurrency, max ${maxConcurrentUsers} users)`);
     };
     const getSnapshot = (senderPeerId) => {
         let totalPending = 0;
@@ -91,7 +233,7 @@ export function createMessageQueue(ctx) {
         return {
             totalPending,
             activeUsers: activeUsers.size,
-            maxConcurrentUsers: MAX_CONCURRENT_USERS,
+            maxConcurrentUsers,
             senderPending: senderQueue ? senderQueue.length : 0,
         };
     };

package/dist/src/outbound.d.ts

@@ -75,7 +75,7 @@ export interface MediaTargetContext {
     logPrefix?: string;
 }
 /**
- * sendPhoto — 发送图片消息（对齐 Telegram sendPhoto）
+ * sendPhoto — 发送图片消息
  *
  * 支持三种来源：
  * - 本地文件路径 → 分片上传
@@ -86,7 +86,7 @@ export declare function sendPhoto(ctx: MediaTargetContext, imagePath: string,
 /** 原始来源 URL（仅 fallback 路径使用，记录到引用索引） */
 sourceUrl?: string): Promise<OutboundResult>;
 /**
- * sendVoice — 发送语音消息（对齐 Telegram sendVoice）
+ * sendVoice — 发送语音消息
  *
  * 支持本地音频文件和公网 URL：
  * - urlDirectUpload=true + 公网URL：先直传平台，失败后下载到本地再转码重试
@@ -101,13 +101,13 @@ directUploadFormats?: string[],
 /** 是否启用转码（默认 true），false 时非原生格式直接返回错误 */
 transcodeEnabled?: boolean): Promise<OutboundResult>;
 /**
- * sendVideoMsg — 发送视频消息（对齐 Telegram sendVideo）
+ * sendVideoMsg — 发送视频消息
  *
  * 支持公网 URL（urlDirectUpload 控制直传或下载，失败自动 fallback）和本地文件路径。
  */
 export declare function sendVideoMsg(ctx: MediaTargetContext, videoPath: string): Promise<OutboundResult>;
 /**
- * sendDocument — 发送文件消息（对齐 Telegram sendDocument）
+ * sendDocument — 发送文件消息
  *
  * 支持本地文件路径和公网 URL（urlDirectUpload 控制直传或下载，失败自动 fallback）。
  */

package/dist/src/outbound.js

@@ -8,7 +8,7 @@ import { decodeCronPayload } from "./utils/payload.js";
 import { getAccessToken, sendC2CMessage, sendChannelMessage, sendGroupMessage, sendProactiveC2CMessage, sendProactiveGroupMessage, sendC2CMediaMessage, sendGroupMediaMessage, MediaFileType, } from "./api.js";
 import { isAudioFile, audioFileToSilkFile, waitForFile, shouldTranscodeVoice } from "./utils/audio-convert.js";
 import { fileExistsAsync, formatFileSize, getMaxUploadSize, getFileTypeName, getFileSizeAsync } from "./utils/file-utils.js";
-import { chunkedUploadC2C, chunkedUploadGroup } from "./utils/chunked-upload.js";
+import { chunkedUploadC2C, chunkedUploadGroup, UploadDailyLimitExceededError } from "./utils/chunked-upload.js";
 import { isLocalPath as isLocalFilePath, normalizePath, getQQBotMediaDir } from "./utils/platform.js";
 import { downloadFile } from "./image-server.js";
 import { parseMediaTagsToSendQueue, executeSendQueue } from "./utils/media-send.js";
@@ -181,7 +181,7 @@ async function getToken(account) {
     return getAccessToken(account.appId, account.clientSecret);
 }
 /**
- * sendPhoto — 发送图片消息（对齐 Telegram sendPhoto）
+ * sendPhoto — 发送图片消息
  *
  * 支持三种来源：
  * - 本地文件路径 → 分片上传
@@ -262,7 +262,7 @@ sourceUrl) {
     return { channel: "qqbot", error: `不支持的图片来源: ${mediaPath.slice(0, 50)}` };
 }
 /**
- * sendVoice — 发送语音消息（对齐 Telegram sendVoice）
+ * sendVoice — 发送语音消息
  *
  * 支持本地音频文件和公网 URL：
  * - urlDirectUpload=true + 公网URL：先直传平台，失败后下载到本地再转码重试
@@ -328,7 +328,7 @@ async function sendVoiceFromLocal(ctx, mediaPath, directUploadFormats, transcode
     }
 }
 /**
- * sendVideoMsg — 发送视频消息（对齐 Telegram sendVideo）
+ * sendVideoMsg — 发送视频消息
  *
  * 支持公网 URL（urlDirectUpload 控制直传或下载，失败自动 fallback）和本地文件路径。
  */
@@ -393,6 +393,12 @@ sendMeta) {
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             console.error(`${prefix} ${callerName}: c2c chunked upload failed: ${msg}`);
+            if (err instanceof UploadDailyLimitExceededError) {
+                const dir = path.dirname(err.filePath);
+                const name = path.basename(err.filePath);
+                const size = formatFileSize(err.fileSize);
+                return { channel: "qqbot", error: `QQBot每天发送文件有累计2G的限制，如果着急的话，可以直接来我的主机copy下载，文件目录\`${dir}/${name}\`（${size}）` };
+            }
             return { channel: "qqbot", error: `文件发送失败，请稍后重试。` };
         }
     }
@@ -412,6 +418,12 @@ sendMeta) {
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             console.error(`${prefix} ${callerName}: group chunked upload failed: ${msg}`);
+            if (err instanceof UploadDailyLimitExceededError) {
+                const dir = path.dirname(err.filePath);
+                const name = path.basename(err.filePath);
+                const size = formatFileSize(err.fileSize);
+                return { channel: "qqbot", error: `QQBot每天发送文件有累计2G的限制，如果着急的话，可以直接来我的主机copy下载，文件目录\`${dir}/${name}\`（${size}）` };
+            }
             return { channel: "qqbot", error: `文件发送失败，请稍后重试。` };
         }
     }
@@ -425,7 +437,7 @@ async function sendVideoFromLocal(ctx, mediaPath, prefix, sourceUrl) {
     return chunkedUploadAndSend(ctx, mediaPath, MediaFileType.VIDEO, prefix, "sendVideoMsg", { mediaType: "video", mediaLocalPath: mediaPath, ...(sourceUrl ? { mediaUrl: sourceUrl } : {}) });
 }
 /**
- * sendDocument — 发送文件消息（对齐 Telegram sendDocument）
+ * sendDocument — 发送文件消息
  *
  * 支持本地文件路径和公网 URL（urlDirectUpload 控制直传或下载，失败自动 fallback）。
  */
@@ -612,7 +624,7 @@ export async function sendText(ctx) {
         });
         return lastResult;
     }
-    // ============ 主动消息校验（参考 Telegram 机制） ============
+    // ============ 主动消息校验 ============
     // 如果是主动消息（无 replyToId 或降级后），必须有消息内容
     if (!replyToId) {
         if (!text || text.trim().length === 0) {

package/dist/src/ref-index-store.js

@@ -15,6 +15,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { getQQBotDataDir } from "./utils/platform.js";
+import { formatAttachmentTags } from "./group-history.js";
 // ============ 配置 ============
 const STORAGE_DIR = getQQBotDataDir("data");
 const REF_INDEX_FILE = path.join(STORAGE_DIR, "ref-index.jsonl");
@@ -220,34 +221,10 @@ export function formatRefEntryForAgent(entry) {
     if (entry.content.trim()) {
         parts.push(entry.content);
     }
-    // 附件描述
-    if (entry.attachments?.length) {
-        for (const att of entry.attachments) {
-            const sourceHint = att.localPath ? ` (${att.localPath})` : att.url ? ` (${att.url})` : "";
-            switch (att.type) {
-                case "image":
-                    parts.push(`[图片${att.filename ? `: ${att.filename}` : ""}${sourceHint}]`);
-                    break;
-                case "voice":
-                    if (att.transcript) {
-                        const sourceMap = { stt: "本地识别", asr: "官方识别", tts: "TTS原文", fallback: "兜底文案" };
-                        const sourceTag = att.transcriptSource ? ` - ${sourceMap[att.transcriptSource] || att.transcriptSource}` : "";
-                        parts.push(`[语音消息（内容: "${att.transcript}"${sourceTag}）${sourceHint}]`);
-                    }
-                    else {
-                        parts.push(`[语音消息${sourceHint}]`);
-                    }
-                    break;
-                case "video":
-                    parts.push(`[视频${att.filename ? `: ${att.filename}` : ""}${sourceHint}]`);
-                    break;
-                case "file":
-                    parts.push(`[文件${att.filename ? `: ${att.filename}` : ""}${sourceHint}]`);
-                    break;
-                default:
-                    parts.push(`[附件${att.filename ? `: ${att.filename}` : ""}${sourceHint}]`);
-            }
-        }
+    // 附件描述（委托 formatAttachmentTags 统一格式化）
+    const attachmentDesc = formatAttachmentTags(entry.attachments);
+    if (attachmentDesc) {
+        parts.push(attachmentDesc);
     }
     return parts.join(" ") || "[空消息]";
 }

package/dist/src/request-context.d.ts

@@ -1,6 +1,8 @@
 export interface RequestContext {
     /** 投递目标地址，如 qqbot:c2c:xxx 或 qqbot:group:xxx */
     target: string;
+    /** 当前请求的 QQBot 账户 ID（多账户场景） */
+    accountId?: string;
 }
 /**
  * 在请求级作用域中执行回调。
@@ -16,3 +18,8 @@ export declare function getRequestContext(): RequestContext | undefined;
  * 便捷方法，等价于 getRequestContext()?.target。
  */
 export declare function getRequestTarget(): string | undefined;
+/**
+ * 获取当前请求的账户 ID。
+ * 便捷方法，等价于 getRequestContext()?.accountId。
+ */
+export declare function getRequestAccountId(): string | undefined;

package/dist/src/request-context.js

@@ -28,3 +28,10 @@ export function getRequestContext() {
 export function getRequestTarget() {
     return asyncLocalStorage.getStore()?.target;
 }
+/**
+ * 获取当前请求的账户 ID。
+ * 便捷方法，等价于 getRequestContext()?.accountId。
+ */
+export function getRequestAccountId() {
+    return asyncLocalStorage.getStore()?.accountId;
+}

package/dist/src/slash-commands.d.ts

@@ -11,6 +11,12 @@
  *   从而计算「开平→插件」和「插件处理」两段耗时
  */
 import type { QQBotAccountConfig } from "./types.js";
+export declare function getFrameworkVersion(): string;
+/**
+ * 解析框架版本字符串中的日期版本号
+ * 输入示例: "OpenClaw 2026.3.13 (61d171a)" → "2026.3.13"
+ */
+export declare function parseFrameworkDateVersion(versionStr: string): string | null;
 /** 斜杠指令上下文（消息元数据 + 运行时状态） */
 export interface SlashCommandContext {
     /** 消息类型 */

package/dist/src/slash-commands.js

@@ -23,7 +23,7 @@ const require = createRequire(import.meta.url);
 let PLUGIN_VERSION = getPackageVersion(import.meta.url);
 // 获取 openclaw 框架版本（缓存结果，只执行一次）
 let _frameworkVersion = null;
-function getFrameworkVersion() {
+export function getFrameworkVersion() {
     if (_frameworkVersion !== null)
         return _frameworkVersion;
     try {
@@ -80,7 +80,7 @@ const UPGRADE_REQUIREMENTS = {
  * 解析框架版本字符串中的日期版本号
  * 输入示例: "OpenClaw 2026.3.13 (61d171a)" → "2026.3.13"
  */
-function parseFrameworkDateVersion(versionStr) {
+export function parseFrameworkDateVersion(versionStr) {
     const m = versionStr.match(/(\d{4}\.\d{1,2}\.\d{1,2})/);
     return m ? m[1] : null;
 }
@@ -790,7 +790,7 @@ registerCommand({
     ].join("\n"),
     handler: async (ctx) => {
         const url = ctx.accountConfig?.upgradeUrl || DEFAULT_UPGRADE_URL;
-        const upgradeMode = ctx.accountConfig?.upgradeMode || "doc";
+        const upgradeMode = ctx.accountConfig?.upgradeMode || "hot-reload";
         const args = ctx.args.trim();
         const info = await getUpdateInfo();
         const GITHUB_URL = "https://github.com/tencent-connect/openclaw-qqbot/";

package/dist/src/tools/remind.js

@@ -1,4 +1,4 @@
-import { getRequestTarget } from "../request-context.js";
+import { getRequestTarget, getRequestAccountId } from "../request-context.js";
 // ========== JSON Schema ==========
 const RemindSchema = {
     type: "object",
@@ -100,7 +100,7 @@ function generateJobName(content) {
 /**
  * 构建一次性提醒的 cron 工具参数
  */
-function buildOnceJob(params, delayMs, to) {
+function buildOnceJob(params, delayMs, to, accountId) {
     const atMs = Date.now() + delayMs;
     const content = params.content;
     const name = params.name || generateJobName(content);
@@ -115,9 +115,12 @@ function buildOnceJob(params, delayMs, to) {
             payload: {
                 kind: "agentTurn",
                 message: buildReminderPrompt(content),
-                deliver: true,
+            },
+            delivery: {
+                mode: "announce",
                 channel: "qqbot",
                 to,
+                accountId,
             },
         },
     };
@@ -125,7 +128,7 @@ function buildOnceJob(params, delayMs, to) {
 /**
  * 构建周期提醒的 cron 工具参数
  */
-function buildCronJob(params, to) {
+function buildCronJob(params, to, accountId) {
     const content = params.content;
     const name = params.name || generateJobName(content);
     const tz = params.timezone || "Asia/Shanghai";
@@ -139,9 +142,12 @@ function buildCronJob(params, to) {
             payload: {
                 kind: "agentTurn",
                 message: buildReminderPrompt(content),
-                deliver: true,
+            },
+            delivery: {
+                mode: "announce",
                 channel: "qqbot",
                 to,
+                accountId,
             },
         },
     };
@@ -211,15 +217,17 @@ export function registerRemindTool(api) {
             if (!resolvedTo) {
                 return json({ error: "action=add 时无法确定投递目标地址。请稍后重试。" });
             }
+            // 从请求上下文获取当前账户 ID（多账户场景），fallback 到 "default"
+            const resolvedAccountId = getRequestAccountId() || "default";
             if (!p.time) {
                 return json({ error: "action=add 时 time（时间）为必填参数。示例：\"5m\"、\"1h30m\"、\"0 8 * * *\"" });
             }
             // 判断是 cron 表达式还是相对时间
             if (isCronExpression(p.time)) {
                 // 周期提醒
-                const cronJob = buildCronJob(p, resolvedTo);
+                const cronJob = buildCronJob(p, resolvedTo, resolvedAccountId);
                 return json({
-                    _instruction: "请立即使用 cron 工具执行以下参数，然后回复用户提醒已设置",
+                    _instruction: "请立即使用 cron 工具，将 cronParams 的值原样作为参数传入（不要修改或省略任何字段，特别是 delivery.accountId），然后回复用户提醒已设置",
                     cronParams: cronJob,
                     summary: `⏰ 周期提醒: "${p.content}" (${p.time}, tz=${p.timezone || "Asia/Shanghai"})`,
                 });
@@ -236,9 +244,9 @@ export function registerRemindTool(api) {
             if (delayMs < 30_000) {
                 return json({ error: "提醒时间不能少于 30 秒" });
             }
-            const onceJob = buildOnceJob(p, delayMs, resolvedTo);
+            const onceJob = buildOnceJob(p, delayMs, resolvedTo, resolvedAccountId);
             return json({
-                _instruction: "请立即使用 cron 工具执行以下参数，然后回复用户提醒已设置",
+                _instruction: "请立即使用 cron 工具，将 cronParams 的值原样作为参数传入（不要修改或省略任何字段，特别是 delivery.accountId），然后回复用户提醒已设置",
                 cronParams: onceJob,
                 summary: `⏰ ${formatDelay(delayMs)}后提醒: "${p.content}"`,
             });