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

package/src/message-queue.ts

@@ -1,9 +1,10 @@
 import type { QueueSnapshot } from "./slash-commands.js";
 
-// 消息队列配置
-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;
 
 /**
  * 消息队列项类型（用于异步处理消息，防止阻塞心跳）
@@ -23,6 +24,18 @@ export interface QueuedMessage {
   refMsgIdx?: string;
   /** 当前消息自身的 refIdx（供将来被引用） */
   msgIdx?: string;
+  /** 事件类型（如 GROUP_AT_MESSAGE_CREATE），用于群消息合并时判断是否有 @ */
+  eventType?: string;
+  /** 发送者是否为机器人 */
+  senderIsBot?: boolean;
+  /** @ 提及列表（群消息合并时需要去重合并） */
+  mentions?: Array<{ scope?: "all" | "single"; id?: string; user_openid?: string; member_openid?: string; username?: string; bot?: boolean; is_you?: boolean }>;
+  /** 消息场景（来源、扩展字段） */
+  messageScene?: { source?: string; ext?: string[] };
+  /** 群消息合并标记：记录合并了多少条原始消息 */
+  _mergedCount?: number;
+  /** 合并前的原始消息列表（用于 gateway 侧逐条格式化信封） */
+  _mergedMessages?: QueuedMessage[];
 }
 
 export interface MessageQueueContext {
@@ -34,6 +47,14 @@ export interface MessageQueueContext {
   };
   /** 外部提供的 abort 状态检查 */
   isAborted: () => boolean;
+  /** 群聊队列上限（默认 50） */
+  groupQueueSize?: number;
+  /** 私聊/DM 队列上限（默认 20） */
+  peerQueueSize?: number;
+  /** 全局队列总量上限（默认 1000） */
+  globalQueueSize?: number;
+  /** 最大并发处理用户数（默认 10） */
+  maxConcurrentUsers?: number;
 }
 
 export interface MessageQueue {
@@ -47,15 +68,103 @@ export interface MessageQueue {
   executeImmediate: (msg: QueuedMessage) => void;
 }
 
+// ── 群消息合并工具函数 ──
+
+/** 判断 peerId 是否属于群聊 */
+const isGroupPeer = (peerId: string): boolean =>
+  peerId.startsWith("group:") || peerId.startsWith("guild:");
+
+/**
+ * 将多条群消息合并为一条，用于群聊场景下排队消息的批量处理。
+ * - content 拼接为多行，每行带发送者前缀
+ * - 附件合并
+ * - messageId / msgIdx / timestamp 取最后一条（用于回复引用）
+ * - mentions 合并去重
+ * - 如果有任意一条 @了你（is_you），合并结果也标记 @你
+ * - senderIsBot 只要有一条不是 bot 就算非 bot
+ */
+function mergeGroupMessages(batch: QueuedMessage[]): QueuedMessage {
+  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: QueuedMessage["attachments"] = [];
+  for (const m of batch) {
+    if (m.attachments?.length) {
+      mergedAttachments.push(...m.attachments);
+    }
+  }
+
+  // 合并 mentions（去重 by member_openid/id）
+  const seenMentionIds = new Set<string>();
+  const mergedMentions: NonNullable<QueuedMessage["mentions"]> = [];
+  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: MessageQueueContext): MessageQueue {
   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<string, QueuedMessage[]>();
   const activeUsers = new Set<string>();
-  let messagesProcessed = 0;
   let handleMessageFnRef: ((msg: QueuedMessage) => Promise<void>) | null = null;
   let totalEnqueued = 0;
 
@@ -65,10 +174,63 @@ export function createMessageQueue(ctx: MessageQueueContext): MessageQueue {
     return `dm:${msg.senderId}`;
   };
 
+  /** 从满队列中淘汰一条消息（群聊优先丢弃 bot 消息，否则丢弃最旧） */
+  const evictOne = (queue: QueuedMessage[], isGroup: boolean): QueuedMessage | undefined => {
+    if (isGroup) {
+      const botIdx = queue.findIndex(m => m.senderIsBot);
+      if (botIdx >= 0) return queue.splice(botIdx, 1)[0];
+    }
+    return queue.shift();
+  };
+
+  /** 判断消息是否为斜杠指令 */
+  const isSlashCommand = (msg: QueuedMessage): boolean =>
+    (msg.content ?? "").trim().startsWith("/");
+
+  /** 处理单条消息，捕获异常并记录日志 */
+  const processOne = async (
+    msg: QueuedMessage,
+    peerId: string,
+    label: string,
+  ): Promise<boolean> => {
+    try {
+      await handleMessageFnRef!(msg);
+      return true;
+    } catch (err) {
+      log?.error(`[qqbot:${accountId}] ${label} error for ${peerId}: ${err}`);
+      return false;
+    }
+  };
+
+  /** 批量处理群聊排队消息：斜杠指令逐条处理，普通消息合并后处理 */
+  const drainGroupBatch = async (all: QueuedMessage[], peerId: string): Promise<void> => {
+    const commands: QueuedMessage[] = [];
+    const normal: QueuedMessage[] = [];
+    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: string): Promise<void> => {
     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;
     }
 
@@ -79,25 +241,31 @@ export function createMessageQueue(ctx: MessageQueueContext): MessageQueue {
     }
 
     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) break;
+        if (activeUsers.size >= maxConcurrentUsers) break;
         if (waitingQueue.length > 0 && !activeUsers.has(waitingPeerId)) {
           drainUserQueue(waitingPeerId);
         }
@@ -107,31 +275,43 @@ export function createMessageQueue(ctx: MessageQueueContext): MessageQueue {
 
   const enqueue = (msg: QueuedMessage): void => {
     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: (msg: QueuedMessage) => Promise<void>): void => {
     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: string): QueueSnapshot => {
@@ -143,7 +323,7 @@ export function createMessageQueue(ctx: MessageQueueContext): MessageQueue {
     return {
       totalPending,
       activeUsers: activeUsers.size,
-      maxConcurrentUsers: MAX_CONCURRENT_USERS,
+      maxConcurrentUsers,
       senderPending: senderQueue ? senderQueue.length : 0,
     };
   };

package/src/openclaw-plugin-sdk.d.ts

@@ -362,6 +362,35 @@ declare module "openclaw/plugin-sdk" {
     [key: string]: unknown;
   }
 
+  // ============ 群消息适配器 ============
+
+  /** 群消息策略适配器（resolveRequireMention / resolveToolPolicy / resolveGroupIntroHint） */
+  export interface ChannelGroupAdapter {
+    /** 是否需要 @机器人才响应 */
+    resolveRequireMention?: (ctx: { cfg: OpenClawConfig; accountId?: string; groupId: string }) => boolean;
+    /** 群聊 AI 工具使用范围 */
+    resolveToolPolicy?: (ctx: { cfg: OpenClawConfig; accountId?: string; groupId: string; senderId?: string }) => "full" | "restricted" | "none";
+    /** 平台特有的群聊行为提示 */
+    resolveGroupIntroHint?: (ctx: { cfg: OpenClawConfig; accountId?: string; groupId: string }) => string | undefined;
+    /** 其他适配器方法 */
+    [key: string]: unknown;
+  }
+
+  /** @mention 检测与清理适配器（stripMentionText / detectWasMentioned） */
+  export interface ChannelMentionAdapter {
+    /** 清理 @mention 文本：平台格式→可读格式，去除 @机器人自身 */
+    stripMentionText?: (text: string, mentions?: Array<{ member_openid?: string; nickname?: string; is_you?: boolean }>) => string;
+    /** 检测当前消息是否 @了机器人 */
+    detectWasMentioned?: (ctx: {
+      eventType?: string;
+      mentions?: Array<{ is_you?: boolean; bot?: boolean }>;
+      content?: string;
+      mentionPatterns?: string[];
+    }) => boolean;
+    /** 其他适配器方法 */
+    [key: string]: unknown;
+  }
+
   /**
    * 频道插件接口（泛型）
    */
@@ -388,6 +417,10 @@ declare module "openclaw/plugin-sdk" {
     outbound?: ChannelPluginOutbound;
     /** Gateway 配置 */
     gateway?: ChannelPluginGateway<TAccount>;
+    /** 群消息策略适配器 */
+    groups?: ChannelGroupAdapter;
+    /** @mention 检测与清理适配器 */
+    mentions?: ChannelMentionAdapter;
     /** 启动函数 */
     start?: (runtime: PluginRuntime) => void | Promise<void>;
     /** 停止函数 */
@@ -512,6 +545,38 @@ declare module "openclaw/plugin-sdk" {
     allowTopLevel?: boolean;
   }): OpenClawConfig;
 
+  // ============ 群访问策略引擎（核心框架标准） ============
+
+  /** 群组访问策略类型："open" | "disabled" | "allowlist" */
+  export type GroupPolicy = "open" | "disabled" | "allowlist";
+
+  /** 基于白名单匹配的群访问决策原因 */
+  export type MatchedGroupAccessReason =
+    | "allowed"
+    | "disabled"
+    | "missing_match_input"
+    | "empty_allowlist"
+    | "not_allowlisted";
+
+  /** 基于白名单匹配的群访问决策结果 */
+  export type MatchedGroupAccessDecision = {
+    allowed: boolean;
+    groupPolicy: GroupPolicy;
+    reason: MatchedGroupAccessReason;
+  };
+
+  /**
+   * 核心框架标准群访问策略评估引擎（基于 policy + allowlist 匹配）
+   * @see openclaw/src/plugin-sdk/group-access.ts
+   */
+  export function evaluateMatchedGroupAccessForPolicy(params: {
+    groupPolicy: GroupPolicy;
+    allowlistConfigured: boolean;
+    allowlistMatched: boolean;
+    requireMatchInput?: boolean;
+    hasMatchInput?: boolean;
+  }): MatchedGroupAccessDecision;
+
   // ============ 其他导出 ============
 
   /** 默认账户 ID 常量 */

package/src/outbound.ts

@@ -20,7 +20,7 @@ import {
 } 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, type MediaSendContext } from "./utils/media-send.js";
@@ -274,7 +274,7 @@ async function getToken(account: ResolvedQQBotAccount): Promise<string> {
 }
 
 /**
- * sendPhoto — 发送图片消息（对齐 Telegram sendPhoto）
+ * sendPhoto — 发送图片消息
  * 
  * 支持三种来源：
  * - 本地文件路径 → 分片上传
@@ -365,7 +365,7 @@ export async function sendPhoto(
 }
 
 /**
- * sendVoice — 发送语音消息（对齐 Telegram sendVoice）
+ * sendVoice — 发送语音消息
  * 
  * 支持本地音频文件和公网 URL：
  * - urlDirectUpload=true + 公网URL：先直传平台，失败后下载到本地再转码重试
@@ -452,7 +452,7 @@ async function sendVoiceFromLocal(
 }
 
 /**
- * sendVideoMsg — 发送视频消息（对齐 Telegram sendVideo）
+ * sendVideoMsg — 发送视频消息
  * 
  * 支持公网 URL（urlDirectUpload 控制直传或下载，失败自动 fallback）和本地文件路径。
  */
@@ -533,6 +533,12 @@ async function chunkedUploadAndSend(
     } 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: `文件发送失败，请稍后重试。` };
     }
   }
@@ -556,6 +562,12 @@ async function chunkedUploadAndSend(
     } 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: `文件发送失败，请稍后重试。` };
     }
   }
@@ -573,7 +585,7 @@ async function sendVideoFromLocal(ctx: MediaTargetContext, mediaPath: string, pr
 }
 
 /**
- * sendDocument — 发送文件消息（对齐 Telegram sendDocument）
+ * sendDocument — 发送文件消息
  * 
  * 支持本地文件路径和公网 URL（urlDirectUpload 控制直传或下载，失败自动 fallback）。
  */
@@ -785,7 +797,7 @@ export async function sendText(ctx: OutboundContext): Promise<OutboundResult> {
     return lastResult;
   }
 
-  // ============ 主动消息校验（参考 Telegram 机制） ============
+  // ============ 主动消息校验 ============
   // 如果是主动消息（无 replyToId 或降级后），必须有消息内容
   if (!replyToId) {
     if (!text || text.trim().length === 0) {

package/src/ref-index-store.ts

@@ -16,6 +16,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { getQQBotDataDir } from "./utils/platform.js";
+import { formatAttachmentTags } from "./group-history.js";
 
 // ============ 存储的消息摘要 ============
 
@@ -297,33 +298,10 @@ export function formatRefEntryForAgent(entry: RefIndexEntry): string {
     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/src/request-context.ts

@@ -11,6 +11,8 @@ import { AsyncLocalStorage } from "node:async_hooks";
 export interface RequestContext {
   /** 投递目标地址，如 qqbot:c2c:xxx 或 qqbot:group:xxx */
   target: string;
+  /** 当前请求的 QQBot 账户 ID（多账户场景） */
+  accountId?: string;
 }
 
 const asyncLocalStorage = new AsyncLocalStorage<RequestContext>();
@@ -37,3 +39,11 @@ export function getRequestContext(): RequestContext | undefined {
 export function getRequestTarget(): string | undefined {
   return asyncLocalStorage.getStore()?.target;
 }
+
+/**
+ * 获取当前请求的账户 ID。
+ * 便捷方法，等价于 getRequestContext()?.accountId。
+ */
+export function getRequestAccountId(): string | undefined {
+  return asyncLocalStorage.getStore()?.accountId;
+}

package/src/slash-commands.ts

@@ -27,7 +27,7 @@ let PLUGIN_VERSION = getPackageVersion(import.meta.url);
 
 // 获取 openclaw 框架版本（缓存结果，只执行一次）
 let _frameworkVersion: string | null = null;
-function getFrameworkVersion(): string {
+export function getFrameworkVersion(): string {
   if (_frameworkVersion !== null) return _frameworkVersion;
   try {
     // 先尝试 PATH 中的 CLI
@@ -90,7 +90,7 @@ interface UpgradeCompatResult {
  * 解析框架版本字符串中的日期版本号
  * 输入示例: "OpenClaw 2026.3.13 (61d171a)" → "2026.3.13"
  */
-function parseFrameworkDateVersion(versionStr: string): string | null {
+export function parseFrameworkDateVersion(versionStr: string): string | null {
   const m = versionStr.match(/(\d{4}\.\d{1,2}\.\d{1,2})/);
   return m ? m[1] : null;
 }
@@ -898,7 +898,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();
 

package/src/tools/remind.ts

@@ -1,5 +1,5 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-import { getRequestTarget } from "../request-context.js";
+import { getRequestTarget, getRequestAccountId } from "../request-context.js";
 
 // ========== 类型定义 ==========
 
@@ -134,7 +134,7 @@ function generateJobName(content: string): string {
 /**
  * 构建一次性提醒的 cron 工具参数
  */
-function buildOnceJob(params: RemindParams, delayMs: number, to: string) {
+function buildOnceJob(params: RemindParams, delayMs: number, to: string, accountId: string) {
   const atMs = Date.now() + delayMs;
   const content = params.content!;
   const name = params.name || generateJobName(content);
@@ -150,9 +150,12 @@ function buildOnceJob(params: RemindParams, delayMs: number, to: string) {
       payload: {
         kind: "agentTurn",
         message: buildReminderPrompt(content),
-        deliver: true,
+      },
+      delivery: {
+        mode: "announce",
         channel: "qqbot",
         to,
+        accountId,
       },
     },
   };
@@ -161,7 +164,7 @@ function buildOnceJob(params: RemindParams, delayMs: number, to: string) {
 /**
  * 构建周期提醒的 cron 工具参数
  */
-function buildCronJob(params: RemindParams, to: string) {
+function buildCronJob(params: RemindParams, to: string, accountId: string) {
   const content = params.content!;
   const name = params.name || generateJobName(content);
   const tz = params.timezone || "Asia/Shanghai";
@@ -176,9 +179,12 @@ function buildCronJob(params: RemindParams, to: string) {
       payload: {
         kind: "agentTurn",
         message: buildReminderPrompt(content),
-        deliver: true,
+      },
+      delivery: {
+        mode: "announce",
         channel: "qqbot",
         to,
+        accountId,
       },
     },
   };
@@ -256,6 +262,8 @@ export function registerRemindTool(api: OpenClawPluginApi): void {
         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 * * *\"" });
         }
@@ -263,9 +271,9 @@ export function registerRemindTool(api: OpenClawPluginApi): void {
         // 判断是 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"})`,
           });
@@ -285,9 +293,9 @@ export function registerRemindTool(api: OpenClawPluginApi): void {
           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}"`,
         });