@openclaw-china/qqbot 0.1.13 → 2026.3.3

package/dist/index.js

@@ -11,6 +11,8 @@ import N2, { stdout, stdin } from 'process';
 import ot from 'readline';
 import 'tty';
 import 'util';
+import { createRequire } from 'module';
+import { execFileSync } from 'child_process';
 import WebSocket from 'ws';
 
 var __create = Object.create;
@@ -648,8 +650,8 @@ function getErrorMap() {
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path3, errorMaps, issueData } = params;
-  const fullPath = [...path3, ...issueData.path || []];
+  const { data, path: path4, errorMaps, issueData } = params;
+  const fullPath = [...path4, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -765,11 +767,11 @@ var errorUtil;
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path3, key) {
+  constructor(parent, value, path4, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path3;
+    this._path = path4;
     this._key = key;
   }
   get path() {
@@ -4219,8 +4221,9 @@ var optionalCoercedString = external_exports.preprocess(
   },
   external_exports.string().min(1).optional()
 );
-var QQBotConfigSchema = external_exports.object({
-  enabled: external_exports.boolean().optional().default(true),
+var QQBotAccountSchema = external_exports.object({
+  name: external_exports.string().optional(),
+  enabled: external_exports.boolean().optional(),
   appId: optionalCoercedString,
   clientSecret: optionalCoercedString,
   asr: external_exports.object({
@@ -4241,8 +4244,38 @@ var QQBotConfigSchema = external_exports.object({
   maxFileSizeMB: external_exports.number().positive().optional().default(100),
   mediaTimeoutMs: external_exports.number().int().positive().optional().default(3e4)
 });
-function isConfigured(config) {
-  return Boolean(config?.appId && config?.clientSecret);
+QQBotAccountSchema.extend({
+  defaultAccount: external_exports.string().optional(),
+  accounts: external_exports.record(QQBotAccountSchema).optional()
+});
+var DEFAULT_ACCOUNT_ID = "default";
+function listConfiguredAccountIds(cfg) {
+  const accounts = cfg.channels?.qqbot?.accounts;
+  if (!accounts || typeof accounts !== "object") return [];
+  return Object.keys(accounts).filter(Boolean);
+}
+function listQQBotAccountIds(cfg) {
+  const ids = listConfiguredAccountIds(cfg);
+  if (ids.length === 0) return [DEFAULT_ACCOUNT_ID];
+  return ids.sort((a, b) => a.localeCompare(b));
+}
+function resolveDefaultQQBotAccountId(cfg) {
+  const qqbotConfig = cfg.channels?.qqbot;
+  if (qqbotConfig?.defaultAccount?.trim()) return qqbotConfig.defaultAccount.trim();
+  const ids = listQQBotAccountIds(cfg);
+  if (ids.includes(DEFAULT_ACCOUNT_ID)) return DEFAULT_ACCOUNT_ID;
+  return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+function resolveAccountConfig(cfg, accountId) {
+  const accounts = cfg.channels?.qqbot?.accounts;
+  if (!accounts || typeof accounts !== "object") return void 0;
+  return accounts[accountId];
+}
+function mergeQQBotAccountConfig(cfg, accountId) {
+  const base = cfg.channels?.qqbot ?? {};
+  const { accounts: _ignored, defaultAccount: _ignored2, ...baseConfig } = base;
+  const account = resolveAccountConfig(cfg, accountId) ?? {};
+  return { ...baseConfig, ...account };
 }
 function resolveQQBotCredentials(config) {
   if (!config?.appId || !config?.clientSecret) return void 0;
@@ -6920,9 +6953,9 @@ function showChinaInstallHint(api) {
 // src/client.ts
 var API_BASE = "https://api.sgroup.qq.com";
 var TOKEN_URL = "https://bots.qq.com/app/getAppAccessToken";
-var tokenCache = null;
-var tokenPromise = null;
-var MSG_SEQ_BASE = Math.floor(Date.now() / 1e3) % 1e8;
+var MSG_SEQ_BASE = 1e6;
+var tokenCacheMap = /* @__PURE__ */ new Map();
+var tokenPromiseMap = /* @__PURE__ */ new Map();
 var msgSeqMap = /* @__PURE__ */ new Map();
 function nextMsgSeq(messageId) {
   if (!messageId) return MSG_SEQ_BASE + 1;
@@ -6937,17 +6970,25 @@ function nextMsgSeq(messageId) {
   }
   return MSG_SEQ_BASE + next;
 }
-function clearTokenCache() {
-  tokenCache = null;
+function clearTokenCache(appId) {
+  if (appId) {
+    tokenCacheMap.delete(appId);
+    tokenPromiseMap.delete(appId);
+  } else {
+    tokenCacheMap.clear();
+    tokenPromiseMap.clear();
+  }
 }
 async function getAccessToken(appId, clientSecret, options) {
-  if (tokenCache && Date.now() < tokenCache.expiresAt - 5 * 60 * 1e3) {
-    return tokenCache.token;
+  const cached = tokenCacheMap.get(appId);
+  if (cached && Date.now() < cached.expiresAt - 5 * 60 * 1e3) {
+    return cached.token;
   }
-  if (tokenPromise) {
-    return tokenPromise;
+  const existingPromise = tokenPromiseMap.get(appId);
+  if (existingPromise) {
+    return existingPromise;
   }
-  tokenPromise = (async () => {
+  const promise = (async () => {
     try {
       const data = await httpPost(
         TOKEN_URL,
@@ -6957,19 +6998,20 @@ async function getAccessToken(appId, clientSecret, options) {
       if (!data.access_token) {
         throw new Error("access_token missing from QQ response");
       }
-      tokenCache = {
+      tokenCacheMap.set(appId, {
         token: data.access_token,
         expiresAt: Date.now() + (data.expires_in ?? 7200) * 1e3
-      };
-      return tokenCache.token;
+      });
+      return data.access_token;
     } finally {
-      tokenPromise = null;
+      tokenPromiseMap.delete(appId);
     }
   })();
-  return tokenPromise;
+  tokenPromiseMap.set(appId, promise);
+  return promise;
 }
-async function apiGet(accessToken, path3, options) {
-  const url = `${API_BASE}${path3}`;
+async function apiGet(accessToken, path4, options) {
+  const url = `${API_BASE}${path4}`;
   return httpGet(url, {
     ...options,
     headers: {
@@ -6978,8 +7020,8 @@ async function apiGet(accessToken, path3, options) {
     }
   });
 }
-async function apiPost(accessToken, path3, body, options) {
-  const url = `${API_BASE}${path3}`;
+async function apiPost(accessToken, path4, body, options) {
+  const url = `${API_BASE}${path4}`;
   return httpPost(url, body, {
     ...options,
     headers: {
@@ -7116,9 +7158,8 @@ async function sendGroupMediaMessage(params) {
     { timeout: 15e3 }
   );
 }
-
-// src/send.ts
 var QQBOT_UNSUPPORTED_FILE_TYPE_MESSAGE = "QQ official C2C/group media API does not support generic files (file_type=4, e.g. PDF). Images and other supported media types are unaffected.";
+var require2 = createRequire(import.meta.url);
 function resolveQQBotMediaFileType(fileName) {
   const mediaType = detectMediaType(fileName);
   switch (mediaType) {
@@ -7153,6 +7194,30 @@ async function uploadQQBotFile(params) {
   }
   return upload.file_info;
 }
+async function convertAudioToSilk(audioPath) {
+  const ffmpegPath = require2("ffmpeg-static");
+  if (!ffmpegPath) {
+    throw new Error("ffmpeg-static not found");
+  }
+  const silkWasm = require2("silk-wasm");
+  const tmpDir = fs3.mkdtempSync(path.join(os.tmpdir(), "qqbot-silk-"));
+  const pcmPath = path.join(tmpDir, "audio.pcm");
+  try {
+    execFileSync(
+      ffmpegPath,
+      ["-y", "-i", audioPath, "-f", "s16le", "-ar", "24000", "-ac", "1", pcmPath],
+      { timeout: 3e4, stdio: "pipe" }
+    );
+    const pcmBuffer = fs3.readFileSync(pcmPath);
+    const result = await silkWasm.encode(pcmBuffer, 24e3);
+    return result.data;
+  } finally {
+    try {
+      fs3.rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
 async function sendFileQQBot(params) {
   const { cfg, target, mediaUrl, messageId } = params;
   if (!cfg.appId || !cfg.clientSecret) {
@@ -7178,10 +7243,25 @@ async function sendFileQQBot(params) {
         url: src
       });
     } else {
-      const { buffer } = await readMediaWithConfig(src, {
-        timeout: mediaTimeoutMs,
-        maxSize: maxSizeBytes
-      });
+      let buffer;
+      if (fileType === 3 /* VOICE */) {
+        try {
+          const silkData = await convertAudioToSilk(src);
+          buffer = Buffer.from(silkData);
+        } catch {
+          const local = await readMediaWithConfig(src, {
+            timeout: mediaTimeoutMs,
+            maxSize: maxSizeBytes
+          });
+          buffer = local.buffer;
+        }
+      } else {
+        const local = await readMediaWithConfig(src, {
+          timeout: mediaTimeoutMs,
+          maxSize: maxSizeBytes
+        });
+        buffer = local.buffer;
+      }
       fileInfo = await uploadQQBotFile({
         accessToken,
         target,
@@ -7280,13 +7360,8 @@ var qqbotOutbound = {
   textChunkLimit: 1500,
   chunkerMode: "markdown",
   sendText: async (params) => {
-    const { cfg, to, text, replyToId } = params;
-    const rawCfg = cfg.channels?.qqbot;
-    const parsed = rawCfg ? QQBotConfigSchema.safeParse(rawCfg) : null;
-    const qqCfg = parsed?.success ? parsed.data : rawCfg;
-    if (!qqCfg) {
-      return { channel: "qqbot", error: "QQBot channel not configured" };
-    }
+    const { cfg, to, text, replyToId, accountId } = params;
+    const qqCfg = mergeQQBotAccountConfig(cfg, accountId ?? DEFAULT_ACCOUNT_ID);
     if (!qqCfg.appId || !qqCfg.clientSecret) {
       return { channel: "qqbot", error: "QQBot not configured (missing appId/clientSecret)" };
     }
@@ -7327,20 +7402,15 @@ var qqbotOutbound = {
     }
   },
   sendMedia: async (params) => {
-    const { cfg, to, mediaUrl, text, replyToId } = params;
+    const { cfg, to, mediaUrl, text, replyToId, accountId } = params;
     if (!mediaUrl) {
       const fallbackText = text?.trim() ?? "";
       if (!fallbackText) {
         return { channel: "qqbot", error: "mediaUrl is required for sendMedia" };
       }
-      return qqbotOutbound.sendText({ cfg, to, text: fallbackText, replyToId });
-    }
-    const rawCfg = cfg.channels?.qqbot;
-    const parsed = rawCfg ? QQBotConfigSchema.safeParse(rawCfg) : null;
-    const qqCfg = parsed?.success ? parsed.data : rawCfg;
-    if (!qqCfg) {
-      return { channel: "qqbot", error: "QQBot channel not configured" };
+      return qqbotOutbound.sendText({ cfg, to, text: fallbackText, replyToId, accountId });
     }
+    const qqCfg = mergeQQBotAccountConfig(cfg, accountId ?? DEFAULT_ACCOUNT_ID);
     if (!qqCfg.appId || !qqCfg.clientSecret) {
       return { channel: "qqbot", error: "QQBot not configured (missing appId/clientSecret)" };
     }
@@ -7364,13 +7434,8 @@ ${mediaUrl}` : mediaUrl;
     }
   },
   sendTyping: async (params) => {
-    const { cfg, to, replyToId, inputSecond } = params;
-    const rawCfg = cfg.channels?.qqbot;
-    const parsed = rawCfg ? QQBotConfigSchema.safeParse(rawCfg) : null;
-    const qqCfg = parsed?.success ? parsed.data : rawCfg;
-    if (!qqCfg) {
-      return { channel: "qqbot", error: "QQBot channel not configured" };
-    }
+    const { cfg, to, replyToId, inputSecond, accountId } = params;
+    const qqCfg = mergeQQBotAccountConfig(cfg, accountId ?? DEFAULT_ACCOUNT_ID);
     if (!qqCfg.appId || !qqCfg.clientSecret) {
       return { channel: "qqbot", error: "QQBot not configured (missing appId/clientSecret)" };
     }
@@ -7830,6 +7895,78 @@ function buildMediaFallbackText(mediaUrl, errorMessage) {
   }
   return `\u{1F4CE} ${mediaUrl}`;
 }
+var THINK_BLOCK_RE = /<think\b[^>]*>[\s\S]*?<\/think>/gi;
+var FINAL_BLOCK_RE = /<final\b[^>]*>([\s\S]*?)<\/final>/gi;
+var RAW_THINK_OR_FINAL_TAG_RE = /<\/?(?:think|final)\b[^>]*>/gi;
+var DIRECTIVE_TAG_RE = /\[\[\s*(?:reply_to_current|reply_to\s*:[^\]]+|audio_as_voice|tts(?::text)?|\/tts(?::text)?)\s*\]\]/gi;
+var VOICE_EMOTION_TAG_RE = /\[(?:happy|excited|calm|sad|angry|frustrated|softly|whispers|loudly|cheerfully|deadpan|sarcastically|laughs|sighs|chuckles|gasps|pause|slowly|rushed|hesitates|playfully|warmly|gently)\]/gi;
+var TTS_LIKE_RAW_TEXT_RE = /\[\[\s*(?:tts(?::text)?|\/tts(?::text)?|audio_as_voice|reply_to_current|reply_to\s*:)/i;
+function extractFinalBlocks(text) {
+  const matches = Array.from(text.matchAll(FINAL_BLOCK_RE));
+  if (matches.length === 0) return void 0;
+  return matches.map((match) => (match[1] ?? "").trim()).filter(Boolean).join("\n");
+}
+function sanitizeQQBotOutboundText(rawText) {
+  if (!rawText) return "";
+  let next = rawText.replace(/\r\n/g, "\n");
+  const finalOnly = extractFinalBlocks(next);
+  if (typeof finalOnly === "string") {
+    next = finalOnly;
+  }
+  next = next.replace(THINK_BLOCK_RE, "");
+  next = next.replace(RAW_THINK_OR_FINAL_TAG_RE, "");
+  next = next.replace(DIRECTIVE_TAG_RE, " ");
+  next = next.replace(VOICE_EMOTION_TAG_RE, " ");
+  next = next.replace(/[ \t]+\n/g, "\n");
+  next = next.replace(/\n{3,}/g, "\n\n");
+  next = next.trim();
+  if (!next) return "";
+  if (/^NO_REPLY$/i.test(next)) return "";
+  return next;
+}
+function shouldSuppressQQBotTextWhenMediaPresent(rawText, sanitizedText) {
+  const raw = rawText.trim();
+  if (!raw) return false;
+  if (TTS_LIKE_RAW_TEXT_RE.test(raw)) return true;
+  if (/<(?:think|final)\b/i.test(raw)) return true;
+  if (!sanitizedText) return true;
+  return !/[A-Za-z0-9\u4e00-\u9fff]/.test(sanitizedText);
+}
+function evaluateReplyFinalOnlyDelivery(params) {
+  const { replyFinalOnly, kind, hasMedia } = params;
+  if (!replyFinalOnly || !kind || kind === "final") {
+    return { skipDelivery: false, suppressText: false };
+  }
+  if (hasMedia) {
+    return { skipDelivery: false, suppressText: true };
+  }
+  return { skipDelivery: true, suppressText: false };
+}
+async function sendQQBotMediaWithFallback(params) {
+  const { qqCfg, to, mediaQueue, replyToId, logger } = params;
+  const outbound = params.outbound ?? qqbotOutbound;
+  for (const mediaUrl of mediaQueue) {
+    const result = await outbound.sendMedia({
+      cfg: { channels: { qqbot: qqCfg } },
+      to,
+      mediaUrl,
+      replyToId
+    });
+    if (result.error) {
+      logger.error(`sendMedia failed: ${result.error}`);
+      const fallback = buildMediaFallbackText(mediaUrl, result.error);
+      const fallbackResult = await outbound.sendText({
+        cfg: { channels: { qqbot: qqCfg } },
+        to,
+        text: fallback,
+        replyToId
+      });
+      if (fallbackResult.error) {
+        logger.error(`sendText fallback failed: ${fallbackResult.error}`);
+      }
+    }
+  }
+}
 function buildInboundContext(params) {
   const { event, sessionKey, accountId } = params;
   const body = params.body ?? event.content;
@@ -8015,18 +8152,16 @@ async function dispatchToAgent(params) {
   };
   const replyFinalOnly = qqCfg.replyFinalOnly ?? false;
   const deliver = async (payload, info) => {
-    if (replyFinalOnly && info?.kind && info.kind !== "final") return;
     const typed = payload;
-    const rawText = typed?.text ?? "";
     const mediaLineResult = extractMediaLinesFromText({
-      text: rawText,
+      text: typed?.text ?? "",
       logger
     });
     const localMediaResult = extractLocalMediaFromText({
       text: mediaLineResult.text,
       logger
     });
-    const trimmed = localMediaResult.text.trim();
+    const cleanedText = sanitizeQQBotOutboundText(localMediaResult.text);
     const payloadMediaUrls = Array.isArray(typed?.mediaUrls) ? typed?.mediaUrls : typed?.mediaUrl ? [typed.mediaUrl] : [];
     const mediaQueue = [];
     const seenMedia = /* @__PURE__ */ new Set();
@@ -8040,8 +8175,16 @@ async function dispatchToAgent(params) {
     for (const url of payloadMediaUrls) addMedia(url);
     for (const url of mediaLineResult.mediaUrls) addMedia(url);
     for (const url of localMediaResult.mediaUrls) addMedia(url);
-    if (trimmed) {
-      const converted = textApi?.convertMarkdownTables ? textApi.convertMarkdownTables(trimmed, resolvedTableMode) : trimmed;
+    const deliveryDecision = evaluateReplyFinalOnlyDelivery({
+      replyFinalOnly,
+      kind: info?.kind,
+      hasMedia: mediaQueue.length > 0});
+    if (deliveryDecision.skipDelivery) return;
+    const suppressEchoText = mediaQueue.length > 0 && shouldSuppressQQBotTextWhenMediaPresent(localMediaResult.text, cleanedText);
+    const suppressText = deliveryDecision.suppressText || suppressEchoText;
+    const textToSend = suppressText ? "" : cleanedText;
+    if (textToSend) {
+      const converted = textApi?.convertMarkdownTables ? textApi.convertMarkdownTables(textToSend, resolvedTableMode) : textToSend;
       const chunks = chunkText(converted);
       for (const chunk of chunks) {
         const result = await qqbotOutbound.sendText({
@@ -8055,27 +8198,13 @@ async function dispatchToAgent(params) {
         }
       }
     }
-    for (const mediaUrl of mediaQueue) {
-      const result = await qqbotOutbound.sendMedia({
-        cfg: { channels: { qqbot: qqCfg } },
-        to: target.to,
-        mediaUrl,
-        replyToId: inbound.messageId
-      });
-      if (result.error) {
-        logger.error(`sendMedia failed: ${result.error}`);
-        const fallback = buildMediaFallbackText(mediaUrl, result.error);
-        const fallbackResult = await qqbotOutbound.sendText({
-          cfg: { channels: { qqbot: qqCfg } },
-          to: target.to,
-          text: fallback,
-          replyToId: inbound.messageId
-        });
-        if (fallbackResult.error) {
-          logger.error(`sendText fallback failed: ${fallbackResult.error}`);
-        }
-      }
-    }
+    await sendQQBotMediaWithFallback({
+      qqCfg,
+      to: target.to,
+      mediaQueue,
+      replyToId: inbound.messageId,
+      logger
+    });
   };
   const humanDelay = replyApi.resolveHumanDelayConfig?.(cfg, route.agentId);
   const dispatchBuffered = replyApi.dispatchReplyWithBufferedBlockDispatcher;
@@ -8162,14 +8291,13 @@ async function handleQQBotDispatch(params) {
   if (!inbound) {
     return;
   }
-  const rawCfg = params.cfg?.channels?.qqbot;
-  const parsedCfg = rawCfg ? QQBotConfigSchema.safeParse(rawCfg) : null;
-  const qqCfg = parsedCfg?.success ? parsedCfg.data : rawCfg;
+  const accountId = params.accountId ?? DEFAULT_ACCOUNT_ID;
+  const qqCfg = params.cfg ? mergeQQBotAccountConfig(params.cfg, accountId) : void 0;
   if (!qqCfg) {
     logger.warn("qqbot config missing, ignoring inbound message");
     return;
   }
-  if (!qqCfg.enabled) {
+  if (qqCfg.enabled === false) {
     logger.info("qqbot disabled, ignoring inbound message");
     return;
   }
@@ -8180,7 +8308,7 @@ async function handleQQBotDispatch(params) {
       attachments: inbound.attachments
     })
   );
-  logger.info(`[inbound-user] senderId=${inbound.senderId} content=${inboundLogContent}`);
+  logger.info(`[inbound-user] accountId=${accountId} senderId=${inbound.senderId} content=${inboundLogContent}`);
   if (!shouldHandleMessage(inbound, qqCfg, logger)) {
     return;
   }
@@ -8195,7 +8323,7 @@ async function handleQQBotDispatch(params) {
     inbound: { ...inbound, content },
     cfg: params.cfg,
     qqCfg,
-    accountId: params.accountId,
+    accountId,
     logger
   });
 }
@@ -8208,72 +8336,80 @@ var INTENTS = {
 };
 var DEFAULT_INTENTS = INTENTS.GUILD_MESSAGES | INTENTS.DIRECT_MESSAGE | INTENTS.GROUP_AND_C2C;
 var RECONNECT_DELAYS_MS = [1e3, 2e3, 5e3, 1e4, 2e4, 3e4];
-var activeSocket = null;
-var activeAccountId = null;
-var activePromise = null;
-var activeStop = null;
+var activeConnections = /* @__PURE__ */ new Map();
+function getOrCreateConnection(accountId) {
+  let conn = activeConnections.get(accountId);
+  if (!conn) {
+    conn = {
+      socket: null,
+      promise: null,
+      stop: null,
+      sessionId: null,
+      lastSeq: null,
+      heartbeatTimer: null,
+      reconnectTimer: null,
+      reconnectAttempt: 0,
+      connecting: false
+    };
+    activeConnections.set(accountId, conn);
+  }
+  return conn;
+}
+function clearTimers(conn) {
+  if (conn.heartbeatTimer) {
+    clearInterval(conn.heartbeatTimer);
+    conn.heartbeatTimer = null;
+  }
+  if (conn.reconnectTimer) {
+    clearTimeout(conn.reconnectTimer);
+    conn.reconnectTimer = null;
+  }
+}
+function cleanupSocket(conn) {
+  clearTimers(conn);
+  if (conn.socket) {
+    try {
+      if (conn.socket.readyState === WebSocket.OPEN) {
+        conn.socket.close();
+      }
+    } catch {
+    }
+    conn.socket = null;
+  }
+}
 async function monitorQQBotProvider(opts = {}) {
-  const { config, runtime: runtime2, abortSignal, accountId = "default" } = opts;
+  const { config, runtime: runtime2, abortSignal, accountId = DEFAULT_ACCOUNT_ID } = opts;
   const logger = createLogger("qqbot", {
     log: runtime2?.log,
     error: runtime2?.error
   });
-  if (activeSocket) {
-    if (activeAccountId && activeAccountId !== accountId) {
-      throw new Error(`QQBot already running for account ${activeAccountId}`);
-    }
-    if (activePromise) {
-      return activePromise;
+  const conn = getOrCreateConnection(accountId);
+  if (conn.socket) {
+    if (conn.promise) {
+      return conn.promise;
     }
-    throw new Error("QQBot monitor state invalid: active socket without promise");
+    throw new Error(`QQBot monitor state invalid for account ${accountId}: active socket without promise`);
   }
-  const rawCfg = config?.channels?.qqbot;
-  const parsed = rawCfg ? QQBotConfigSchema.safeParse(rawCfg) : null;
-  const qqCfg = parsed?.success ? parsed.data : rawCfg;
+  const qqCfg = config ? mergeQQBotAccountConfig(config, accountId) : void 0;
   if (!qqCfg) {
     throw new Error("QQBot configuration not found");
   }
   if (!qqCfg.appId || !qqCfg.clientSecret) {
-    throw new Error("QQBot not configured (missing appId or clientSecret)");
+    throw new Error(`QQBot not configured for account ${accountId} (missing appId or clientSecret)`);
   }
-  activePromise = new Promise((resolve3, reject) => {
+  conn.promise = new Promise((resolve3, reject) => {
     let stopped = false;
-    let reconnectAttempt = 0;
-    let heartbeatTimer = null;
-    let reconnectTimer = null;
-    let sessionId = null;
-    let lastSeq = null;
-    let connecting = false;
-    const clearTimers = () => {
-      if (heartbeatTimer) {
-        clearInterval(heartbeatTimer);
-        heartbeatTimer = null;
-      }
-      if (reconnectTimer) {
-        clearTimeout(reconnectTimer);
-        reconnectTimer = null;
-      }
-    };
-    const cleanupSocket = () => {
-      clearTimers();
-      if (activeSocket) {
-        try {
-          if (activeSocket.readyState === WebSocket.OPEN) {
-            activeSocket.close();
-          }
-        } catch {
-        }
-      }
-      activeSocket = null;
-    };
     const finish = (err) => {
       if (stopped) return;
       stopped = true;
       abortSignal?.removeEventListener("abort", onAbort);
-      cleanupSocket();
-      activeAccountId = null;
-      activePromise = null;
-      activeStop = null;
+      cleanupSocket(conn);
+      conn.sessionId = null;
+      conn.lastSeq = null;
+      conn.promise = null;
+      conn.stop = null;
+      conn.reconnectAttempt = 0;
+      activeConnections.delete(accountId);
       {
         resolve3();
       }
@@ -8282,33 +8418,33 @@ async function monitorQQBotProvider(opts = {}) {
       logger.info("abort signal received, stopping gateway");
       finish();
     };
-    activeStop = () => {
+    conn.stop = () => {
       logger.info("stop requested");
       finish();
     };
     const scheduleReconnect = (reason) => {
       if (stopped) return;
-      if (reconnectTimer) return;
-      const delay = RECONNECT_DELAYS_MS[Math.min(reconnectAttempt, RECONNECT_DELAYS_MS.length - 1)];
-      reconnectAttempt += 1;
+      if (conn.reconnectTimer) return;
+      const delay = RECONNECT_DELAYS_MS[Math.min(conn.reconnectAttempt, RECONNECT_DELAYS_MS.length - 1)];
+      conn.reconnectAttempt += 1;
       logger.warn(`[reconnect] ${reason}; retry in ${delay}ms`);
-      reconnectTimer = setTimeout(() => {
-        reconnectTimer = null;
+      conn.reconnectTimer = setTimeout(() => {
+        conn.reconnectTimer = null;
         void connect();
       }, delay);
     };
     const startHeartbeat = (intervalMs) => {
-      if (heartbeatTimer) {
-        clearInterval(heartbeatTimer);
+      if (conn.heartbeatTimer) {
+        clearInterval(conn.heartbeatTimer);
       }
-      heartbeatTimer = setInterval(() => {
-        if (!activeSocket || activeSocket.readyState !== WebSocket.OPEN) return;
-        const payload = JSON.stringify({ op: 1, d: lastSeq });
-        activeSocket.send(payload);
+      conn.heartbeatTimer = setInterval(() => {
+        if (!conn.socket || conn.socket.readyState !== WebSocket.OPEN) return;
+        const payload = JSON.stringify({ op: 1, d: conn.lastSeq });
+        conn.socket.send(payload);
       }, intervalMs);
     };
     const sendIdentify = (token) => {
-      if (!activeSocket || activeSocket.readyState !== WebSocket.OPEN) return;
+      if (!conn.socket || conn.socket.readyState !== WebSocket.OPEN) return;
       const payload = {
         op: 2,
         d: {
@@ -8317,10 +8453,10 @@ async function monitorQQBotProvider(opts = {}) {
           shard: [0, 1]
         }
       };
-      activeSocket.send(JSON.stringify(payload));
+      conn.socket.send(JSON.stringify(payload));
     };
     const sendResume = (token, session, seq) => {
-      if (!activeSocket || activeSocket.readyState !== WebSocket.OPEN) return;
+      if (!conn.socket || conn.socket.readyState !== WebSocket.OPEN) return;
       const payload = {
         op: 6,
         d: {
@@ -8329,11 +8465,11 @@ async function monitorQQBotProvider(opts = {}) {
           seq
         }
       };
-      activeSocket.send(JSON.stringify(payload));
+      conn.socket.send(JSON.stringify(payload));
     };
     const handleGatewayPayload = async (payload) => {
       if (typeof payload.s === "number") {
-        lastSeq = payload.s;
+        conn.lastSeq = payload.s;
       }
       switch (payload.op) {
         case 10: {
@@ -8341,8 +8477,8 @@ async function monitorQQBotProvider(opts = {}) {
           const interval = hello?.heartbeat_interval ?? 3e4;
           startHeartbeat(interval);
           const token = await getAccessToken(qqCfg.appId, qqCfg.clientSecret);
-          if (sessionId && typeof lastSeq === "number") {
-            sendResume(token, sessionId, lastSeq);
+          if (conn.sessionId && typeof conn.lastSeq === "number") {
+            sendResume(token, conn.sessionId, conn.lastSeq);
           } else {
             sendIdentify(token);
           }
@@ -8351,14 +8487,14 @@ async function monitorQQBotProvider(opts = {}) {
         case 11:
           return;
         case 7:
-          cleanupSocket();
+          cleanupSocket(conn);
           scheduleReconnect("server requested reconnect");
           return;
         case 9:
-          sessionId = null;
-          lastSeq = null;
-          clearTokenCache();
-          cleanupSocket();
+          conn.sessionId = null;
+          conn.lastSeq = null;
+          clearTokenCache(qqCfg.appId);
+          cleanupSocket(conn);
           scheduleReconnect("invalid session");
           return;
         case 0: {
@@ -8366,14 +8502,14 @@ async function monitorQQBotProvider(opts = {}) {
           if (eventType === "READY") {
             const ready = payload.d;
             if (ready?.session_id) {
-              sessionId = ready.session_id;
+              conn.sessionId = ready.session_id;
             }
-            reconnectAttempt = 0;
+            conn.reconnectAttempt = 0;
             logger.info("gateway ready");
             return;
           }
           if (eventType === "RESUMED") {
-            reconnectAttempt = 0;
+            conn.reconnectAttempt = 0;
             logger.info("gateway resumed");
             return;
           }
@@ -8393,16 +8529,15 @@ async function monitorQQBotProvider(opts = {}) {
       }
     };
     const connect = async () => {
-      if (stopped || connecting) return;
-      connecting = true;
+      if (stopped || conn.connecting) return;
+      conn.connecting = true;
       try {
-        cleanupSocket();
+        cleanupSocket(conn);
         const token = await getAccessToken(qqCfg.appId, qqCfg.clientSecret);
         const gatewayUrl = await getGatewayUrl(token);
         logger.info(`connecting gateway: ${gatewayUrl}`);
         const ws = new WebSocket(gatewayUrl);
-        activeSocket = ws;
-        activeAccountId = accountId;
+        conn.socket = ws;
         ws.on("open", () => {
           logger.info("gateway socket opened");
         });
@@ -8421,7 +8556,7 @@ async function monitorQQBotProvider(opts = {}) {
         });
         ws.on("close", (code, reason) => {
           logger.warn(`gateway socket closed (${code}) ${String(reason)}`);
-          cleanupSocket();
+          cleanupSocket(conn);
           scheduleReconnect("socket closed");
         });
         ws.on("error", (err) => {
@@ -8429,10 +8564,10 @@ async function monitorQQBotProvider(opts = {}) {
         });
       } catch (err) {
         logger.error(`gateway connect failed: ${String(err)}`);
-        cleanupSocket();
+        cleanupSocket(conn);
         scheduleReconnect("connect failed");
       } finally {
-        connecting = false;
+        conn.connecting = false;
       }
     };
     if (abortSignal?.aborted) {
@@ -8442,27 +8577,20 @@ async function monitorQQBotProvider(opts = {}) {
     abortSignal?.addEventListener("abort", onAbort, { once: true });
     void connect();
   });
-  return activePromise;
+  return conn.promise;
 }
-function stopQQBotMonitor() {
-  if (activeStop) {
-    activeStop();
+function stopQQBotMonitorForAccount(accountId = DEFAULT_ACCOUNT_ID) {
+  const conn = activeConnections.get(accountId);
+  if (!conn) return;
+  if (conn.stop) {
+    conn.stop();
     return;
   }
-  if (activeSocket) {
-    try {
-      activeSocket.close();
-    } catch {
-    }
-    activeSocket = null;
-    activeAccountId = null;
-    activePromise = null;
-    activeStop = null;
-  }
+  cleanupSocket(conn);
+  activeConnections.delete(accountId);
 }
 
 // src/channel.ts
-var DEFAULT_ACCOUNT_ID = "default";
 var meta = {
   id: "qqbot",
   label: "QQ Bot",
@@ -8475,17 +8603,17 @@ var meta = {
 };
 function resolveQQBotAccount(params) {
   const { cfg, accountId = DEFAULT_ACCOUNT_ID } = params;
-  const qqCfg = cfg.channels?.qqbot;
-  const parsed = qqCfg ? QQBotConfigSchema.safeParse(qqCfg) : null;
-  const config = parsed?.success ? parsed.data : void 0;
-  const credentials = resolveQQBotCredentials(config);
+  const merged = mergeQQBotAccountConfig(cfg, accountId);
+  const baseEnabled = cfg.channels?.qqbot?.enabled !== false;
+  const enabled = baseEnabled && merged.enabled !== false;
+  const credentials = resolveQQBotCredentials(merged);
   const configured = Boolean(credentials);
   return {
     accountId,
-    enabled: config?.enabled ?? true,
+    enabled,
     configured,
     appId: credentials?.appId,
-    markdownSupport: config?.markdownSupport ?? true
+    markdownSupport: merged.markdownSupport ?? true
   };
 }
 var qqbotPlugin = {
@@ -8558,6 +8686,8 @@ var qqbotPlugin = {
       additionalProperties: false,
       properties: {
         enabled: { type: "boolean" },
+        name: { type: "string" },
+        defaultAccount: { type: "string" },
         appId: { type: "string" },
         clientSecret: { type: "string" },
         asr: {
@@ -8578,46 +8708,121 @@ var qqbotPlugin = {
         groupAllowFrom: { type: "array", items: { type: "string" } },
         historyLimit: { type: "integer", minimum: 0 },
         textChunkLimit: { type: "integer", minimum: 1 },
-        replyFinalOnly: { type: "boolean" }
+        replyFinalOnly: { type: "boolean" },
+        maxFileSizeMB: { type: "number" },
+        mediaTimeoutMs: { type: "number" },
+        accounts: {
+          type: "object",
+          additionalProperties: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              name: { type: "string" },
+              enabled: { type: "boolean" },
+              appId: { type: "string" },
+              clientSecret: { type: "string" },
+              asr: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                  enabled: { type: "boolean" },
+                  appId: { type: "string" },
+                  secretId: { type: "string" },
+                  secretKey: { type: "string" }
+                }
+              },
+              markdownSupport: { type: "boolean" },
+              dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
+              groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
+              requireMention: { type: "boolean" },
+              allowFrom: { type: "array", items: { type: "string" } },
+              groupAllowFrom: { type: "array", items: { type: "string" } },
+              historyLimit: { type: "integer", minimum: 0 },
+              textChunkLimit: { type: "integer", minimum: 1 },
+              replyFinalOnly: { type: "boolean" },
+              maxFileSizeMB: { type: "number" },
+              mediaTimeoutMs: { type: "number" }
+            }
+          }
+        }
       }
     }
   },
   reload: { configPrefixes: ["channels.qqbot"] },
   config: {
-    listAccountIds: (_cfg) => [DEFAULT_ACCOUNT_ID],
+    listAccountIds: (cfg) => listQQBotAccountIds(cfg),
     resolveAccount: (cfg, accountId) => resolveQQBotAccount({ cfg, accountId }),
     defaultAccountId: () => DEFAULT_ACCOUNT_ID,
     setAccountEnabled: (params) => {
+      const accountId = params.accountId ?? DEFAULT_ACCOUNT_ID;
       const existing = params.cfg.channels?.qqbot ?? {};
+      if (accountId === DEFAULT_ACCOUNT_ID) {
+        return {
+          ...params.cfg,
+          channels: {
+            ...params.cfg.channels,
+            qqbot: { ...existing, enabled: params.enabled }
+          }
+        };
+      }
+      const accounts = existing.accounts ?? {};
+      const account = accounts[accountId] ?? {};
       return {
         ...params.cfg,
         channels: {
           ...params.cfg.channels,
           qqbot: {
             ...existing,
-            enabled: params.enabled
+            accounts: {
+              ...accounts,
+              [accountId]: { ...account, enabled: params.enabled }
+            }
           }
         }
       };
     },
     deleteAccount: (params) => {
-      const next = { ...params.cfg };
-      const nextChannels = { ...params.cfg.channels };
-      delete nextChannels.qqbot;
-      if (Object.keys(nextChannels).length > 0) {
-        next.channels = nextChannels;
-      } else {
-        delete next.channels;
+      const accountId = params.accountId ?? DEFAULT_ACCOUNT_ID;
+      if (accountId === DEFAULT_ACCOUNT_ID) {
+        const next = { ...params.cfg };
+        const nextChannels = { ...params.cfg.channels };
+        delete nextChannels.qqbot;
+        if (Object.keys(nextChannels).length > 0) {
+          next.channels = nextChannels;
+        } else {
+          delete next.channels;
+        }
+        return next;
       }
-      return next;
+      const existing = params.cfg.channels?.qqbot;
+      if (!existing?.accounts?.[accountId]) return params.cfg;
+      const { [accountId]: _removed, ...remainingAccounts } = existing.accounts;
+      return {
+        ...params.cfg,
+        channels: {
+          ...params.cfg.channels,
+          qqbot: {
+            ...existing,
+            accounts: Object.keys(remainingAccounts).length > 0 ? remainingAccounts : void 0
+          }
+        }
+      };
+    },
+    isConfigured: (_account, cfg, accountId) => {
+      const id = accountId ?? _account.accountId;
+      const merged = mergeQQBotAccountConfig(cfg, id);
+      return Boolean(merged.appId && merged.clientSecret);
     },
-    isConfigured: (_account, cfg) => isConfigured(cfg.channels?.qqbot),
     describeAccount: (account) => ({
       accountId: account.accountId,
       enabled: account.enabled,
       configured: account.configured
     }),
-    resolveAllowFrom: (params) => params.cfg.channels?.qqbot?.allowFrom ?? [],
+    resolveAllowFrom: (params) => {
+      const accountId = params.accountId ?? DEFAULT_ACCOUNT_ID;
+      const merged = mergeQQBotAccountConfig(params.cfg, accountId);
+      return merged.allowFrom ?? [];
+    },
     formatAllowFrom: (params) => params.allowFrom.map((entry) => String(entry).trim()).filter(Boolean).map((entry) => entry.toLowerCase())
   },
   security: {
@@ -8631,16 +8836,30 @@ var qqbotPlugin = {
     }
   },
   setup: {
-    resolveAccountId: () => DEFAULT_ACCOUNT_ID,
+    resolveAccountId: (params) => params.accountId ?? resolveDefaultQQBotAccountId(params.cfg),
     applyAccountConfig: (params) => {
+      const accountId = params.accountId ?? DEFAULT_ACCOUNT_ID;
       const existing = params.cfg.channels?.qqbot ?? {};
+      if (accountId === DEFAULT_ACCOUNT_ID) {
+        return {
+          ...params.cfg,
+          channels: {
+            ...params.cfg.channels,
+            qqbot: { ...existing, ...params.config, enabled: true }
+          }
+        };
+      }
+      const accounts = existing.accounts ?? {};
       return {
         ...params.cfg,
         channels: {
           ...params.cfg.channels,
           qqbot: {
             ...existing,
-            enabled: true
+            accounts: {
+              ...accounts,
+              [accountId]: { ...accounts[accountId], ...params.config, enabled: true }
+            }
           }
         }
       };
@@ -8667,8 +8886,8 @@ var qqbotPlugin = {
         accountId: ctx.accountId
       });
     },
-    stopAccount: async (_ctx) => {
-      stopQQBotMonitor();
+    stopAccount: async (ctx) => {
+      stopQQBotMonitorForAccount(ctx.accountId);
     },
     getStatus: () => ({ connected: true })
   }
@@ -8684,6 +8903,8 @@ var plugin = {
     additionalProperties: false,
     properties: {
       enabled: { type: "boolean" },
+      name: { type: "string" },
+      defaultAccount: { type: "string" },
       appId: { type: "string" },
       clientSecret: { type: "string" },
       asr: {
@@ -8704,7 +8925,43 @@ var plugin = {
       groupAllowFrom: { type: "array", items: { type: "string" } },
       historyLimit: { type: "integer", minimum: 0 },
       textChunkLimit: { type: "integer", minimum: 1 },
-      replyFinalOnly: { type: "boolean" }
+      replyFinalOnly: { type: "boolean" },
+      maxFileSizeMB: { type: "number" },
+      mediaTimeoutMs: { type: "number" },
+      accounts: {
+        type: "object",
+        additionalProperties: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            name: { type: "string" },
+            enabled: { type: "boolean" },
+            appId: { type: "string" },
+            clientSecret: { type: "string" },
+            asr: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                enabled: { type: "boolean" },
+                appId: { type: "string" },
+                secretId: { type: "string" },
+                secretKey: { type: "string" }
+              }
+            },
+            markdownSupport: { type: "boolean" },
+            dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
+            groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
+            requireMention: { type: "boolean" },
+            allowFrom: { type: "array", items: { type: "string" } },
+            groupAllowFrom: { type: "array", items: { type: "string" } },
+            historyLimit: { type: "integer", minimum: 0 },
+            textChunkLimit: { type: "integer", minimum: 1 },
+            replyFinalOnly: { type: "boolean" },
+            maxFileSizeMB: { type: "number" },
+            mediaTimeoutMs: { type: "number" }
+          }
+        }
+      }
     }
   },
   register(api) {