@openclaw-china/qqbot 2026.3.9 → 2026.3.11

package/dist/index.js

@@ -1,9 +1,9 @@
 import * as os from 'os';
 import { homedir, tmpdir } from 'os';
 import * as path2 from 'path';
-import { join } from 'path';
+import { join, dirname } from 'path';
 import * as fs3 from 'fs';
-import { existsSync } from 'fs';
+import { existsSync, readFileSync, rmSync, writeFileSync, mkdirSync } from 'fs';
 import { fileURLToPath } from 'url';
 import * as fsPromises from 'fs/promises';
 import { createHmac } from 'crypto';
@@ -14,6 +14,7 @@ import 'util';
 import { createRequire } from 'module';
 import { execFileSync } from 'child_process';
 import WebSocket from 'ws';
+import { Buffer as Buffer$1 } from 'buffer';
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -4222,6 +4223,7 @@ var optionalCoercedString = external_exports.preprocess(
   (value) => toTrimmedString(value),
   external_exports.string().min(1).optional()
 );
+var QQBotC2CMarkdownDeliveryModeSchema = external_exports.enum(["passive", "proactive-table-only", "proactive-all"]).optional().default("proactive-table-only");
 var QQBotAccountSchema = external_exports.object({
   name: external_exports.string().optional(),
   enabled: external_exports.boolean().optional(),
@@ -4234,6 +4236,7 @@ var QQBotAccountSchema = external_exports.object({
     secretKey: optionalCoercedString
   }).optional(),
   markdownSupport: external_exports.boolean().optional().default(true),
+  c2cMarkdownDeliveryMode: QQBotC2CMarkdownDeliveryModeSchema,
   dmPolicy: external_exports.enum(["open", "pairing", "allowlist"]).optional().default("open"),
   groupPolicy: external_exports.enum(["open", "allowlist", "disabled"]).optional().default("open"),
   requireMention: external_exports.boolean().optional().default(true),
@@ -4245,6 +4248,7 @@ var QQBotAccountSchema = external_exports.object({
   longTaskNoticeDelayMs: external_exports.number().int().min(0).optional().default(3e4),
   maxFileSizeMB: external_exports.number().positive().optional().default(100),
   mediaTimeoutMs: external_exports.number().int().positive().optional().default(3e4),
+  autoSendLocalPathMedia: external_exports.boolean().optional().default(true),
   inboundMedia: external_exports.object({
     dir: external_exports.string().optional(),
     keepDays: external_exports.number().optional()
@@ -4264,6 +4268,9 @@ function resolveInboundMediaKeepDays(config) {
   const value = config?.inboundMedia?.keepDays;
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : DEFAULT_INBOUND_MEDIA_KEEP_DAYS;
 }
+function resolveQQBotAutoSendLocalPathMedia(config) {
+  return config?.autoSendLocalPathMedia ?? true;
+}
 function resolveInboundMediaTempDir() {
   return DEFAULT_INBOUND_MEDIA_TEMP_DIR;
 }
@@ -4316,6 +4323,156 @@ function resolveQQBotASRCredentials(config) {
   };
 }
 
+// src/onboarding.ts
+function isPromptCancelled(value) {
+  return typeof value === "symbol";
+}
+function setQQBotCredentials(params) {
+  const existing = params.cfg.channels?.qqbot ?? {};
+  if (params.accountId === DEFAULT_ACCOUNT_ID) {
+    return {
+      ...params.cfg,
+      channels: {
+        ...params.cfg.channels,
+        qqbot: {
+          ...existing,
+          enabled: true,
+          appId: params.appId,
+          clientSecret: params.clientSecret
+        }
+      }
+    };
+  }
+  const accounts = existing.accounts ?? {};
+  return {
+    ...params.cfg,
+    channels: {
+      ...params.cfg.channels,
+      qqbot: {
+        ...existing,
+        enabled: true,
+        accounts: {
+          ...accounts,
+          [params.accountId]: {
+            ...accounts[params.accountId],
+            enabled: true,
+            appId: params.appId,
+            clientSecret: params.clientSecret
+          }
+        }
+      }
+    }
+  };
+}
+async function noteQQBotCredentialHelp(prompter) {
+  await prompter.note(
+    [
+      "1) \u6253\u5F00 QQ \u5F00\u653E\u5E73\u53F0 (https://q.qq.com/)",
+      "2) \u521B\u5EFA\u673A\u5668\u4EBA\u5E94\u7528\uFF0C\u83B7\u53D6 AppID \u548C ClientSecret",
+      "3) \u5728\u5F00\u53D1\u8BBE\u7F6E\u4E2D\u914D\u7F6E\u6C99\u7BB1\u6210\u5458\u6216\u6D4B\u8BD5\u7FA4",
+      "4) \u914D\u7F6E\u5B8C\u6210\u540E\u53EF\u4F7F\u7528 openclaw gateway \u542F\u52A8\u8FDE\u63A5",
+      "",
+      '\u547D\u4EE4\u884C\u4E5F\u652F\u6301\uFF1Aopenclaw channels add --channel qqbot --token "AppID:ClientSecret"'
+    ].join("\n"),
+    "QQ Bot \u914D\u7F6E"
+  );
+}
+function resolveOnboardingAccountId(params) {
+  const override = params.accountOverrides?.qqbot?.trim();
+  if (override) return override;
+  const defaultAccountId = resolveDefaultQQBotAccountId(params.cfg);
+  const accountIds = listQQBotAccountIds(params.cfg);
+  if (!params.shouldPromptAccountIds || accountIds.length <= 1) {
+    return defaultAccountId;
+  }
+  return params.prompter.select({
+    message: "\u9009\u62E9\u8981\u914D\u7F6E\u7684 QQ Bot \u8D26\u6237",
+    options: accountIds.map((accountId) => ({
+      value: accountId,
+      label: accountId === DEFAULT_ACCOUNT_ID ? "\u9ED8\u8BA4\u8D26\u6237" : accountId
+    })),
+    initialValue: defaultAccountId
+  }).then((selected) => isPromptCancelled(selected) ? defaultAccountId : selected);
+}
+var qqbotOnboardingAdapter = {
+  channel: "qqbot",
+  getStatus: async (params) => {
+    const accountIds = listQQBotAccountIds(params.cfg);
+    const configuredAccountId = accountIds.find(
+      (accountId) => Boolean(resolveQQBotCredentials(mergeQQBotAccountConfig(params.cfg, accountId)))
+    );
+    const configured = Boolean(configuredAccountId);
+    const defaultAccountId = resolveDefaultQQBotAccountId(params.cfg);
+    const statusLines = configured ? [
+      configuredAccountId && configuredAccountId !== DEFAULT_ACCOUNT_ID ? `QQ Bot: \u5DF2\u914D\u7F6E (${configuredAccountId})` : `QQ Bot: \u5DF2\u914D\u7F6E${defaultAccountId !== DEFAULT_ACCOUNT_ID ? ` (default=${defaultAccountId})` : ""}`
+    ] : ["QQ Bot: \u9700\u8981 AppID \u548C ClientSecret"];
+    return {
+      channel: "qqbot",
+      configured,
+      statusLines,
+      selectionHint: configured ? "\u5DF2\u914D\u7F6E" : "\u9700\u8981 AppID \u548C ClientSecret",
+      quickstartScore: configured ? 2 : 0
+    };
+  },
+  configure: async (params) => {
+    const accountId = await resolveOnboardingAccountId(params);
+    const merged = mergeQQBotAccountConfig(params.cfg, accountId);
+    const configured = Boolean(resolveQQBotCredentials(merged));
+    let next = params.cfg;
+    let appId = null;
+    let clientSecret = null;
+    if (!configured) {
+      await noteQQBotCredentialHelp(params.prompter);
+    } else {
+      const keepCurrent = await params.prompter.confirm({
+        message: accountId === DEFAULT_ACCOUNT_ID ? "QQ Bot \u51ED\u8BC1\u5DF2\u914D\u7F6E\uFF0C\u662F\u5426\u4FDD\u7559\u5F53\u524D\u914D\u7F6E\uFF1F" : `\u8D26\u6237 ${accountId} \u7684 QQ Bot \u51ED\u8BC1\u5DF2\u914D\u7F6E\uFF0C\u662F\u5426\u4FDD\u7559\u5F53\u524D\u914D\u7F6E\uFF1F`,
+        initialValue: true
+      });
+      if (keepCurrent) {
+        return { cfg: next, accountId };
+      }
+    }
+    const nextAppId = await params.prompter.text({
+      message: "\u8BF7\u8F93\u5165 QQ Bot AppID",
+      placeholder: "\u4F8B\u5982: 102146862",
+      initialValue: typeof merged.appId === "string" ? merged.appId : void 0,
+      validate: (value) => String(value ?? "").trim() ? void 0 : "AppID \u4E0D\u80FD\u4E3A\u7A7A"
+    });
+    if (isPromptCancelled(nextAppId)) {
+      return { cfg: next, accountId };
+    }
+    appId = String(nextAppId).trim();
+    const nextClientSecret = await params.prompter.text({
+      message: "\u8BF7\u8F93\u5165 QQ Bot ClientSecret",
+      placeholder: "\u4F60\u7684 ClientSecret",
+      validate: (value) => String(value ?? "").trim() ? void 0 : "ClientSecret \u4E0D\u80FD\u4E3A\u7A7A"
+    });
+    if (isPromptCancelled(nextClientSecret)) {
+      return { cfg: next, accountId };
+    }
+    clientSecret = String(nextClientSecret).trim();
+    if (appId && clientSecret) {
+      next = setQQBotCredentials({
+        cfg: next,
+        accountId,
+        appId,
+        clientSecret
+      });
+    }
+    return { cfg: next, accountId };
+  },
+  disable: (cfg) => ({
+    ...cfg,
+    channels: {
+      ...cfg.channels,
+      qqbot: {
+        ...cfg.channels?.qqbot ?? {},
+        enabled: false
+      }
+    }
+  })
+};
+
 // ../../packages/shared/src/logger/logger.ts
 function createLogger(prefix, opts) {
   const logFn = opts?.log ?? console.log;
@@ -4719,7 +4876,7 @@ function extractMediaFromText(text, options = {}) {
   const {
     removeFromText = true,
     checkExists = false,
-    existsSync: existsSync5,
+    existsSync: existsSync6,
     parseMediaLines = false,
     parseMarkdownImages = true,
     parseHtmlImages = true,
@@ -4734,7 +4891,7 @@ function extractMediaFromText(text, options = {}) {
     const key = media.localPath || media.source;
     if (seenSources.has(key)) return false;
     if (checkExists && media.isLocal && media.localPath) {
-      const exists = existsSync5 ? existsSync5(media.localPath) : fs3.existsSync(media.localPath);
+      const exists = existsSync6 ? existsSync6(media.localPath) : fs3.existsSync(media.localPath);
       if (!exists) return false;
     }
     seenSources.add(key);
@@ -6529,6 +6686,13 @@ function getChannelConfig(cfg, channelId) {
   const existing = channels[channelId];
   return isRecord(existing) ? existing : {};
 }
+function getGatewayAuthToken(cfg) {
+  if (!isRecord(cfg.gateway)) {
+    return void 0;
+  }
+  const auth = isRecord(cfg.gateway.auth) ? cfg.gateway.auth : void 0;
+  return toTrimmedString2(auth?.token);
+}
 function getPreferredAccountConfig(channelCfg) {
   const accounts = channelCfg.accounts;
   if (!isRecord(accounts)) {
@@ -6690,11 +6854,22 @@ async function configureDingtalk(prompter, cfg) {
     "\u542F\u7528 AI Card \u6D41\u5F0F\u56DE\u590D\uFF08\u63A8\u8350\u5173\u95ED\uFF0C\u4F7F\u7528\u975E\u6D41\u5F0F\uFF09",
     toBoolean(existing.enableAICard, false)
   );
-  return mergeChannelConfig(cfg, "dingtalk", {
+  const patch = {
     clientId,
     clientSecret,
     enableAICard
-  });
+  };
+  if (enableAICard) {
+    const gatewayToken = await prompter.askSecret({
+      label: "OpenClaw Gateway Token\uFF08\u6D41\u5F0F\u8F93\u51FA\u5FC5\u9700\uFF1B\u7559\u7A7A\u5219\u4F7F\u7528\u5168\u5C40 gateway.auth.token\uFF09",
+      existingValue: toTrimmedString2(existing.gatewayToken) ?? getGatewayAuthToken(cfg),
+      required: false
+    });
+    if (gatewayToken.trim()) {
+      patch.gatewayToken = gatewayToken;
+    }
+  }
+  return mergeChannelConfig(cfg, "dingtalk", patch);
 }
 async function configureFeishu(prompter, cfg) {
   section("\u914D\u7F6E Feishu\uFF08\u98DE\u4E66\uFF09");
@@ -7083,9 +7258,11 @@ function showChinaInstallHint(api) {
 var API_BASE = "https://api.sgroup.qq.com";
 var TOKEN_URL = "https://bots.qq.com/app/getAppAccessToken";
 var MSG_SEQ_BASE = 1e6;
+var MAX_DUPLICATE_MSG_SEQ_RETRIES = 5;
 var tokenCacheMap = /* @__PURE__ */ new Map();
 var tokenPromiseMap = /* @__PURE__ */ new Map();
 var msgSeqMap = /* @__PURE__ */ new Map();
+var fallbackMsgSeq = 0;
 function toTrimmedString3(value) {
   if (value === void 0 || value === null) return void 0;
   const next = String(value).trim();
@@ -7105,7 +7282,10 @@ function sanitizeUploadFileName(fileName) {
   return normalized || "file";
 }
 function nextMsgSeq(sequenceKey) {
-  if (!sequenceKey) return MSG_SEQ_BASE + 1;
+  if (!sequenceKey) {
+    fallbackMsgSeq += 1;
+    return MSG_SEQ_BASE + fallbackMsgSeq;
+  }
   const current = msgSeqMap.get(sequenceKey) ?? 0;
   const next = current + 1;
   msgSeqMap.set(sequenceKey, next);
@@ -7117,6 +7297,46 @@ function nextMsgSeq(sequenceKey) {
   }
   return MSG_SEQ_BASE + next;
 }
+function resolveMsgSeqKey(messageId, eventId) {
+  if (messageId) return `msg:${messageId}`;
+  if (eventId) return `event:${eventId}`;
+  return void 0;
+}
+function isDuplicateMsgSeqError(err) {
+  if (!(err instanceof HttpError) || err.status !== 400) {
+    return false;
+  }
+  const body = err.body?.trim();
+  if (!body) {
+    return false;
+  }
+  try {
+    const parsed = JSON.parse(body);
+    if (parsed.code === 40054005 || parsed.err_code === 40054005) {
+      return true;
+    }
+    const message = typeof parsed.message === "string" ? parsed.message.toLowerCase() : "";
+    return message.includes("msgseq") && (message.includes("\u53BB\u91CD") || message.includes("duplicate"));
+  } catch {
+    const lowered = body.toLowerCase();
+    return lowered.includes("msgseq") && (lowered.includes("\u53BB\u91CD") || lowered.includes("duplicate"));
+  }
+}
+async function postPassiveMessage(params) {
+  let lastError;
+  for (let attempt = 0; attempt <= MAX_DUPLICATE_MSG_SEQ_RETRIES; attempt += 1) {
+    const msgSeq = nextMsgSeq(params.sequenceKey);
+    try {
+      return await apiPost(params.accessToken, params.path, params.buildBody(msgSeq), params.options);
+    } catch (err) {
+      lastError = err;
+      if (!isDuplicateMsgSeqError(err) || attempt === MAX_DUPLICATE_MSG_SEQ_RETRIES) {
+        throw err;
+      }
+    }
+  }
+  throw lastError;
+}
 function clearTokenCache(appId) {
   const normalizedAppId = toTrimmedString3(appId);
   if (normalizedAppId) {
@@ -7185,16 +7405,11 @@ async function getGatewayUrl(accessToken) {
   return data.url;
 }
 function buildMessageBody(params) {
-  const msgSeq = nextMsgSeq(params.messageId ?? params.eventId);
-  const body = params.markdown ? {
-    markdown: { content: params.content },
-    msg_type: 2,
-    msg_seq: msgSeq
-  } : {
+  const body = buildTextMessageBody({
     content: params.content,
-    msg_type: 0,
-    msg_seq: msgSeq
-  };
+    markdown: params.markdown
+  });
+  body.msg_seq = params.msgSeq;
   if (params.messageId) {
     body.msg_id = params.messageId;
   } else if (params.eventId) {
@@ -7202,22 +7417,63 @@ function buildMessageBody(params) {
   }
   return body;
 }
+function buildTextMessageBody(params) {
+  return params.markdown ? {
+    markdown: { content: params.content },
+    msg_type: 2
+  } : {
+    content: params.content,
+    msg_type: 0
+  };
+}
+function buildProactiveMessageBody(params) {
+  if (!params.content.trim()) {
+    throw new Error("QQBot proactive message content is empty");
+  }
+  return buildTextMessageBody(params);
+}
 async function sendC2CMessage(params) {
-  const body = buildMessageBody({
+  return postPassiveMessage({
+    accessToken: params.accessToken,
+    path: `/v2/users/${params.openid}/messages`,
+    sequenceKey: resolveMsgSeqKey(params.messageId, params.eventId),
+    options: { timeout: 15e3 },
+    buildBody: (msgSeq) => buildMessageBody({
+      content: params.content,
+      messageId: params.messageId,
+      eventId: params.eventId,
+      markdown: params.markdown,
+      msgSeq
+    })
+  });
+}
+async function sendGroupMessage(params) {
+  return postPassiveMessage({
+    accessToken: params.accessToken,
+    path: `/v2/groups/${params.groupOpenid}/messages`,
+    sequenceKey: resolveMsgSeqKey(params.messageId, params.eventId),
+    options: { timeout: 15e3 },
+    buildBody: (msgSeq) => buildMessageBody({
+      content: params.content,
+      messageId: params.messageId,
+      eventId: params.eventId,
+      markdown: params.markdown,
+      msgSeq
+    })
+  });
+}
+async function sendProactiveC2CMessage(params) {
+  const body = buildProactiveMessageBody({
     content: params.content,
-    messageId: params.messageId,
-    eventId: params.eventId,
     markdown: params.markdown
   });
   return apiPost(params.accessToken, `/v2/users/${params.openid}/messages`, body, {
     timeout: 15e3
   });
 }
-async function sendGroupMessage(params) {
-  const body = buildMessageBody({
+async function sendProactiveGroupMessage(params) {
+  const body = buildProactiveMessageBody({
     content: params.content,
-    messageId: params.messageId,
-    eventId: params.eventId,
     markdown: params.markdown
   });
   return apiPost(params.accessToken, `/v2/groups/${params.groupOpenid}/messages`, body, {
@@ -7234,11 +7490,12 @@ async function sendChannelMessage(params) {
   });
 }
 async function sendC2CInputNotify(params) {
-  const msgSeq = nextMsgSeq(params.messageId ?? params.eventId);
-  await apiPost(
-    params.accessToken,
-    `/v2/users/${params.openid}/messages`,
-    {
+  await postPassiveMessage({
+    accessToken: params.accessToken,
+    path: `/v2/users/${params.openid}/messages`,
+    sequenceKey: resolveMsgSeqKey(params.messageId, params.eventId),
+    options: { timeout: 15e3 },
+    buildBody: (msgSeq) => ({
       msg_type: 6,
       input_notify: {
         input_type: 1,
@@ -7246,9 +7503,8 @@ async function sendC2CInputNotify(params) {
       },
       msg_seq: msgSeq,
       ...params.messageId ? { msg_id: params.messageId } : params.eventId ? { event_id: params.eventId } : {}
-    },
-    { timeout: 15e3 }
-  );
+    })
+  });
 }
 async function uploadC2CMedia(params) {
   const body = {
@@ -7289,34 +7545,34 @@ async function uploadGroupMedia(params) {
   });
 }
 async function sendC2CMediaMessage(params) {
-  const msgSeq = nextMsgSeq(params.messageId ?? params.eventId);
-  return apiPost(
-    params.accessToken,
-    `/v2/users/${params.openid}/messages`,
-    {
+  return postPassiveMessage({
+    accessToken: params.accessToken,
+    path: `/v2/users/${params.openid}/messages`,
+    sequenceKey: resolveMsgSeqKey(params.messageId, params.eventId),
+    options: { timeout: 15e3 },
+    buildBody: (msgSeq) => ({
       msg_type: 7,
       media: { file_info: params.fileInfo },
       msg_seq: msgSeq,
       ...params.content ? { content: params.content } : {},
       ...params.messageId ? { msg_id: params.messageId } : params.eventId ? { event_id: params.eventId } : {}
-    },
-    { timeout: 15e3 }
-  );
+    })
+  });
 }
 async function sendGroupMediaMessage(params) {
-  const msgSeq = nextMsgSeq(params.messageId ?? params.eventId);
-  return apiPost(
-    params.accessToken,
-    `/v2/groups/${params.groupOpenid}/messages`,
-    {
+  return postPassiveMessage({
+    accessToken: params.accessToken,
+    path: `/v2/groups/${params.groupOpenid}/messages`,
+    sequenceKey: resolveMsgSeqKey(params.messageId, params.eventId),
+    options: { timeout: 15e3 },
+    buildBody: (msgSeq) => ({
       msg_type: 7,
       media: { file_info: params.fileInfo },
       msg_seq: msgSeq,
       ...params.content ? { content: params.content } : {},
       ...params.messageId ? { msg_id: params.messageId } : params.eventId ? { event_id: params.eventId } : {}
-    },
-    { timeout: 15e3 }
-  );
+    })
+  });
 }
 var require2 = createRequire(import.meta.url);
 function resolveQQBotMediaFileType(fileName) {
@@ -7569,6 +7825,14 @@ function logEventIdFallback(params) {
   }
   console.info(detail);
 }
+function logQQBotOutboundDispatch(params) {
+  const accountLabel = params.accountId?.trim() || DEFAULT_ACCOUNT_ID;
+  const textLength = typeof params.text === "string" ? params.text.length : 0;
+  const mediaLabel = params.mediaUrl ? ` media=${shortId(params.mediaUrl)}` : "";
+  console.info(
+    `[qqbot] outbound action=${params.action} api=${params.api} accountId=${accountLabel} target=${params.targetKind}:${shortId(params.targetId)} markdown=${params.markdown ? "yes" : "no"} replyToId=${params.replyToId ? "yes" : "no"} replyEventId=${params.replyEventId ? "yes" : "no"} textLen=${textLength}${mediaLabel}`
+  );
+}
 function shouldRetryWithEventId(err) {
   const status = err instanceof HttpError ? err.status : void 0;
   let body = "";
@@ -7589,6 +7853,15 @@ function shouldRetryWithEventId(err) {
 function shouldSendTextAsFollowupForMedia(mediaUrl) {
   return detectMediaType(stripTitleFromUrl(mediaUrl)) === "file";
 }
+function buildPassiveReplyRefs(params) {
+  if (params.replyToId) {
+    return { messageId: params.replyToId };
+  }
+  if (params.replyEventId) {
+    return { eventId: params.replyEventId };
+  }
+  return {};
+}
 var qqbotOutbound = {
   deliveryMode: "direct",
   textChunkLimit: 1500,
@@ -7606,13 +7879,42 @@ var qqbotOutbound = {
     const groupMarkdown = false;
     try {
       if (target.kind === "group") {
+        if (!replyToId && !replyEventId) {
+          logQQBotOutboundDispatch({
+            action: "text",
+            api: "sendProactiveGroupMessage",
+            accountId,
+            targetKind: target.kind,
+            targetId: target.id,
+            markdown,
+            text
+          });
+          const result3 = await sendProactiveGroupMessage({
+            accessToken,
+            groupOpenid: target.id,
+            content: text,
+            markdown
+          });
+          return { channel: "qqbot", messageId: result3.id, timestamp: result3.timestamp };
+        }
         let result2;
         try {
+          logQQBotOutboundDispatch({
+            action: "text",
+            api: "sendGroupMessage",
+            accountId,
+            targetKind: target.kind,
+            targetId: target.id,
+            markdown: groupMarkdown,
+            replyToId,
+            replyEventId,
+            text
+          });
           result2 = await sendGroupMessage({
             accessToken,
             groupOpenid: target.id,
             content: text,
-            messageId: replyToId,
+            ...buildPassiveReplyRefs({ replyToId, replyEventId }),
             markdown: groupMarkdown
           });
         } catch (err) {
@@ -7663,6 +7965,15 @@ var qqbotOutbound = {
         return { channel: "qqbot", messageId: result2.id, timestamp: result2.timestamp };
       }
       if (target.kind === "channel") {
+        logQQBotOutboundDispatch({
+          action: "text",
+          api: "sendChannelMessage",
+          accountId,
+          targetKind: target.kind,
+          targetId: target.id,
+          replyToId,
+          text
+        });
         const result2 = await sendChannelMessage({
           accessToken,
           channelId: target.id,
@@ -7671,13 +7982,42 @@ var qqbotOutbound = {
         });
         return { channel: "qqbot", messageId: result2.id, timestamp: result2.timestamp };
       }
+      if (!replyToId && !replyEventId) {
+        logQQBotOutboundDispatch({
+          action: "text",
+          api: "sendProactiveC2CMessage",
+          accountId,
+          targetKind: target.kind,
+          targetId: target.id,
+          markdown,
+          text
+        });
+        const result2 = await sendProactiveC2CMessage({
+          accessToken,
+          openid: target.id,
+          content: text,
+          markdown
+        });
+        return { channel: "qqbot", messageId: result2.id, timestamp: result2.timestamp };
+      }
       let result;
       try {
+        logQQBotOutboundDispatch({
+          action: "text",
+          api: "sendC2CMessage",
+          accountId,
+          targetKind: target.kind,
+          targetId: target.id,
+          markdown,
+          replyToId,
+          replyEventId,
+          text
+        });
         result = await sendC2CMessage({
           accessToken,
           openid: target.id,
           content: text,
-          messageId: replyToId,
+          ...buildPassiveReplyRefs({ replyToId, replyEventId }),
           markdown
         });
       } catch (err) {
@@ -7755,6 +8095,17 @@ ${mediaUrl}` : mediaUrl;
     try {
       let result;
       try {
+        logQQBotOutboundDispatch({
+          action: "media",
+          api: "sendFileQQBot",
+          accountId,
+          targetKind: target.kind,
+          targetId: target.id,
+          replyToId,
+          replyEventId,
+          text: sendTextAsFollowup ? void 0 : trimmedText,
+          mediaUrl
+        });
         result = await sendFileQQBot({
           cfg: qqCfg,
           target: { kind: target.kind, id: target.id },
@@ -7904,6 +8255,451 @@ ${mediaUrl}` : mediaUrl;
 
 // src/logger.ts
 createLogger("qqbot");
+var DEFAULT_QQBOT_MARKDOWN_IMAGE_SIZE = {
+  width: 512,
+  height: 512
+};
+var MARKDOWN_IMAGE_RE2 = /!\[([^\]]*)\]\(([^)\n]+)\)/g;
+var BARE_HTTP_IMAGE_URL_RE = /(?<![(\["'<])(https?:\/\/[^\s)"'<>]+\.(?:png|jpe?g|gif|webp)(?:\?[^\s)"'<>]*)?)/gi;
+var FENCED_CODE_BLOCK_RE = /(^|\n)(`{3,}|~{3,})[^\n]*\n[\s\S]*?\n\2(?=\n|$)/g;
+function parsePngSize(buffer) {
+  if (buffer.length < 24) return null;
+  if (buffer[0] !== 137 || buffer[1] !== 80 || buffer[2] !== 78 || buffer[3] !== 71) {
+    return null;
+  }
+  return {
+    width: buffer.readUInt32BE(16),
+    height: buffer.readUInt32BE(20)
+  };
+}
+function parseJpegSize(buffer) {
+  if (buffer.length < 4 || buffer[0] !== 255 || buffer[1] !== 216) {
+    return null;
+  }
+  let offset = 2;
+  while (offset < buffer.length - 9) {
+    if (buffer[offset] !== 255) {
+      offset += 1;
+      continue;
+    }
+    const marker = buffer[offset + 1];
+    if (marker === 192 || marker === 194) {
+      return {
+        height: buffer.readUInt16BE(offset + 5),
+        width: buffer.readUInt16BE(offset + 7)
+      };
+    }
+    if (offset + 3 >= buffer.length) {
+      break;
+    }
+    const blockLength = buffer.readUInt16BE(offset + 2);
+    offset += 2 + blockLength;
+  }
+  return null;
+}
+function parseGifSize(buffer) {
+  if (buffer.length < 10) return null;
+  const signature = buffer.toString("ascii", 0, 6);
+  if (signature !== "GIF87a" && signature !== "GIF89a") {
+    return null;
+  }
+  return {
+    width: buffer.readUInt16LE(6),
+    height: buffer.readUInt16LE(8)
+  };
+}
+function parseWebpSize(buffer) {
+  if (buffer.length < 30) return null;
+  if (buffer.toString("ascii", 0, 4) !== "RIFF" || buffer.toString("ascii", 8, 12) !== "WEBP") {
+    return null;
+  }
+  const chunkType = buffer.toString("ascii", 12, 16);
+  if (chunkType === "VP8 " && buffer[23] === 157 && buffer[24] === 1 && buffer[25] === 42) {
+    return {
+      width: buffer.readUInt16LE(26) & 16383,
+      height: buffer.readUInt16LE(28) & 16383
+    };
+  }
+  if (chunkType === "VP8L" && buffer[20] === 47) {
+    const bits = buffer.readUInt32LE(21);
+    return {
+      width: (bits & 16383) + 1,
+      height: (bits >> 14 & 16383) + 1
+    };
+  }
+  if (chunkType === "VP8X") {
+    return {
+      width: (buffer[24] | buffer[25] << 8 | buffer[26] << 16) + 1,
+      height: (buffer[27] | buffer[28] << 8 | buffer[29] << 16) + 1
+    };
+  }
+  return null;
+}
+function parseImageSize(buffer) {
+  return parsePngSize(buffer) ?? parseJpegSize(buffer) ?? parseGifSize(buffer) ?? parseWebpSize(buffer);
+}
+function normalizeImageSize(size) {
+  if (!size) return null;
+  if (!Number.isFinite(size.width) || !Number.isFinite(size.height)) return null;
+  if (size.width <= 0 || size.height <= 0) return null;
+  return {
+    width: Math.round(size.width),
+    height: Math.round(size.height)
+  };
+}
+function splitMarkdownImageDestination(rawDestination) {
+  let next = rawDestination.trim();
+  const whitespaceIndex = next.search(/\s/);
+  if (whitespaceIndex >= 0) {
+    next = next.slice(0, whitespaceIndex);
+  }
+  if (next.startsWith("<") && next.endsWith(">")) {
+    next = next.slice(1, -1).trim();
+  }
+  return next;
+}
+function splitFencedCodeBlocks(text) {
+  const segments = [];
+  const re = new RegExp(FENCED_CODE_BLOCK_RE.source, FENCED_CODE_BLOCK_RE.flags);
+  let lastIndex = 0;
+  let match;
+  while ((match = re.exec(text)) !== null) {
+    const leading = match[1] ?? "";
+    const codeStart = match.index + leading.length;
+    if (codeStart > lastIndex) {
+      segments.push({ kind: "text", value: text.slice(lastIndex, codeStart) });
+    }
+    segments.push({ kind: "code", value: text.slice(codeStart, re.lastIndex) });
+    lastIndex = re.lastIndex;
+  }
+  if (lastIndex < text.length) {
+    segments.push({ kind: "text", value: text.slice(lastIndex) });
+  }
+  return segments;
+}
+async function replaceAsync(input2, pattern, replacer) {
+  const re = new RegExp(pattern.source, pattern.flags);
+  let result = "";
+  let lastIndex = 0;
+  let match;
+  while ((match = re.exec(input2)) !== null) {
+    result += input2.slice(lastIndex, match.index);
+    result += await replacer(match);
+    lastIndex = match.index + match[0].length;
+    if (match[0].length === 0) {
+      re.lastIndex += 1;
+    }
+  }
+  result += input2.slice(lastIndex);
+  return result;
+}
+async function getResolvedImageSize(params) {
+  const { url, cache, resolveImageSize } = params;
+  const existing = cache.get(url);
+  if (existing) {
+    return existing;
+  }
+  const pending = resolveImageSize(url).then((size) => normalizeImageSize(size) ?? DEFAULT_QQBOT_MARKDOWN_IMAGE_SIZE).catch(() => DEFAULT_QQBOT_MARKDOWN_IMAGE_SIZE);
+  cache.set(url, pending);
+  return pending;
+}
+async function normalizeTextSegment(params) {
+  const { text, seenImageUrls, imageSizeCache, resolveImageSize } = params;
+  const withMarkdownImages = await replaceAsync(text, MARKDOWN_IMAGE_RE2, async (match) => {
+    const fullMatch = match[0];
+    const destination = splitMarkdownImageDestination(match[2] ?? "");
+    if (!isQQBotHttpImageUrl(destination)) {
+      return fullMatch;
+    }
+    seenImageUrls.add(destination);
+    if (hasQQBotMarkdownImageSize(fullMatch)) {
+      return fullMatch;
+    }
+    const size = await getResolvedImageSize({
+      url: destination,
+      cache: imageSizeCache,
+      resolveImageSize
+    });
+    return formatQQBotMarkdownImage(destination, size);
+  });
+  return replaceAsync(withMarkdownImages, BARE_HTTP_IMAGE_URL_RE, async (match) => {
+    const url = match[1] ?? match[0];
+    if (!isQQBotHttpImageUrl(url)) {
+      return match[0];
+    }
+    seenImageUrls.add(url);
+    const size = await getResolvedImageSize({
+      url,
+      cache: imageSizeCache,
+      resolveImageSize
+    });
+    return formatQQBotMarkdownImage(url, size);
+  });
+}
+function isQQBotHttpImageUrl(url) {
+  const trimmed = url.trim();
+  if (!/^https?:\/\//i.test(trimmed)) {
+    return false;
+  }
+  try {
+    const parsed = new URL(trimmed);
+    return /\.(?:png|jpe?g|gif|webp)$/i.test(parsed.pathname);
+  } catch {
+    return /\.(?:png|jpe?g|gif|webp)(?:\?[^\s)"'<>]*)?$/i.test(trimmed);
+  }
+}
+async function getQQBotHttpImageSize(url, timeoutMs = 5e3) {
+  if (!isQQBotHttpImageUrl(url)) {
+    return null;
+  }
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        Range: "bytes=0-65535",
+        "User-Agent": "OpenClaw-QQBot-ImageSize/1.0"
+      }
+    });
+    if (!(response.ok || response.status === 206)) {
+      return null;
+    }
+    const buffer = Buffer$1.from(await response.arrayBuffer());
+    return normalizeImageSize(parseImageSize(buffer));
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+function formatQQBotMarkdownImage(url, size) {
+  const resolved = normalizeImageSize(size) ?? DEFAULT_QQBOT_MARKDOWN_IMAGE_SIZE;
+  return `![#${resolved.width}px #${resolved.height}px](${url})`;
+}
+function hasQQBotMarkdownImageSize(markdownImage) {
+  return /!\[#\d+px\s+#\d+px\]\([^)]+\)/.test(markdownImage);
+}
+async function normalizeQQBotMarkdownImages(params) {
+  const text = params.text ?? "";
+  const appendImageUrls = params.appendImageUrls ?? [];
+  const resolveImageSize = params.resolveImageSize ?? ((url) => getQQBotHttpImageSize(url, params.timeoutMs));
+  const imageSizeCache = /* @__PURE__ */ new Map();
+  const seenImageUrls = /* @__PURE__ */ new Set();
+  const segments = splitFencedCodeBlocks(text);
+  const normalizedSegments = [];
+  for (const segment of segments) {
+    if (segment.kind === "code") {
+      normalizedSegments.push(segment.value);
+      continue;
+    }
+    normalizedSegments.push(
+      await normalizeTextSegment({
+        text: segment.value,
+        seenImageUrls,
+        imageSizeCache,
+        resolveImageSize
+      })
+    );
+  }
+  const appendedImages = [];
+  for (const rawUrl of appendImageUrls) {
+    const url = rawUrl.trim();
+    if (!isQQBotHttpImageUrl(url) || seenImageUrls.has(url)) {
+      continue;
+    }
+    seenImageUrls.add(url);
+    const size = await getResolvedImageSize({
+      url,
+      cache: imageSizeCache,
+      resolveImageSize
+    });
+    appendedImages.push(formatQQBotMarkdownImage(url, size));
+  }
+  const body = normalizedSegments.join("").trim();
+  if (appendedImages.length === 0) {
+    return body;
+  }
+  if (!body) {
+    return appendedImages.join("\n");
+  }
+  return `${body}
+
+${appendedImages.join("\n")}`;
+}
+var DEFAULT_KNOWN_TARGETS_PATH = join(homedir(), ".openclaw", "data", "qqbot", "known-targets.json");
+function resolveKnownTargetsFilePath(options) {
+  return options?.filePath?.trim() || DEFAULT_KNOWN_TARGETS_PATH;
+}
+function ensureKnownTargetsDir(filePath) {
+  mkdirSync(dirname(filePath), { recursive: true });
+}
+function compareTargetsByLastSeenDesc(a, b) {
+  if (b.lastSeenAt !== a.lastSeenAt) {
+    return b.lastSeenAt - a.lastSeenAt;
+  }
+  return a.target.localeCompare(b.target);
+}
+function normalizeKnownQQBotTarget(target) {
+  const accountId = target.accountId.trim() || DEFAULT_ACCOUNT_ID;
+  const normalized = {
+    accountId,
+    kind: target.kind,
+    target: target.target.trim(),
+    sourceChatType: target.sourceChatType,
+    firstSeenAt: Math.trunc(target.firstSeenAt),
+    lastSeenAt: Math.trunc(target.lastSeenAt)
+  };
+  const displayName = target.displayName?.trim();
+  if (displayName) {
+    normalized.displayName = displayName;
+  }
+  return normalized;
+}
+function parseKnownTargets(raw, filePath) {
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed)) {
+    throw new Error(`Invalid known QQBot targets file: ${filePath}`);
+  }
+  return parsed.filter((entry) => {
+    if (!entry || typeof entry !== "object") return false;
+    const candidate = entry;
+    return typeof candidate.accountId === "string" && typeof candidate.kind === "string" && typeof candidate.target === "string" && typeof candidate.sourceChatType === "string" && typeof candidate.firstSeenAt === "number" && typeof candidate.lastSeenAt === "number";
+  }).map((entry) => normalizeKnownQQBotTarget(entry)).filter((entry) => entry.target.length > 0);
+}
+function readKnownTargets(options) {
+  const filePath = resolveKnownTargetsFilePath(options);
+  if (!existsSync(filePath)) {
+    return [];
+  }
+  const raw = readFileSync(filePath, "utf8");
+  if (!raw.trim()) {
+    return [];
+  }
+  return parseKnownTargets(raw, filePath).sort(compareTargetsByLastSeenDesc);
+}
+function writeKnownTargets(targets, options) {
+  const filePath = resolveKnownTargetsFilePath(options);
+  if (targets.length === 0) {
+    if (existsSync(filePath)) {
+      rmSync(filePath, { force: true });
+    }
+    return;
+  }
+  ensureKnownTargetsDir(filePath);
+  writeFileSync(filePath, `${JSON.stringify(targets, null, 2)}
+`, "utf8");
+}
+function upsertKnownQQBotTarget(params) {
+  const next = normalizeKnownQQBotTarget(params.target);
+  if (!next.target) {
+    throw new Error("Known QQBot target requires a non-empty target");
+  }
+  const targets = readKnownTargets(params);
+  const index = targets.findIndex(
+    (entry) => entry.accountId === next.accountId && entry.target === next.target
+  );
+  if (index >= 0) {
+    const existing = targets[index];
+    targets[index] = {
+      ...existing,
+      kind: next.kind,
+      sourceChatType: next.sourceChatType,
+      displayName: next.displayName ?? existing.displayName,
+      lastSeenAt: next.lastSeenAt
+    };
+  } else {
+    targets.push(next);
+  }
+  targets.sort(compareTargetsByLastSeenDesc);
+  writeKnownTargets(targets, params);
+  return index >= 0 ? targets.find((entry) => entry.accountId === next.accountId && entry.target === next.target) : next;
+}
+function listKnownQQBotTargets(params = {}) {
+  let targets = readKnownTargets(params);
+  if (params.accountId?.trim()) {
+    targets = targets.filter((entry) => entry.accountId === params.accountId?.trim());
+  }
+  if (params.kind) {
+    targets = targets.filter((entry) => entry.kind === params.kind);
+  }
+  if (typeof params.limit === "number" && params.limit > 0) {
+    targets = targets.slice(0, params.limit);
+  }
+  return targets;
+}
+function getKnownQQBotTarget(params) {
+  const target = params.target.trim();
+  if (!target) return void 0;
+  const matches = readKnownTargets(params).filter((entry) => {
+    if (entry.target !== target) return false;
+    if (params.accountId?.trim()) {
+      return entry.accountId === params.accountId.trim();
+    }
+    return true;
+  });
+  return matches[0];
+}
+function removeKnownQQBotTarget(params) {
+  const target = params.target.trim();
+  if (!target) return false;
+  const before = readKnownTargets(params);
+  const filtered = before.filter((entry) => {
+    if (entry.target !== target) return true;
+    if (params.accountId?.trim()) {
+      return entry.accountId !== params.accountId.trim();
+    }
+    return false;
+  });
+  if (filtered.length === before.length) {
+    return false;
+  }
+  writeKnownTargets(filtered, params);
+  return true;
+}
+function clearKnownQQBotTargets(params = {}) {
+  const before = readKnownTargets(params);
+  const filtered = before.filter((entry) => {
+    if (params.accountId?.trim() && entry.accountId !== params.accountId.trim()) {
+      return true;
+    }
+    if (params.kind && entry.kind !== params.kind) {
+      return true;
+    }
+    return false;
+  });
+  const removed = before.length - filtered.length;
+  if (removed === 0) {
+    return 0;
+  }
+  writeKnownTargets(filtered, params);
+  return removed;
+}
+async function sendProactiveQQBotMessage(params) {
+  const to = params.to.trim();
+  if (!to) {
+    return { channel: "qqbot", error: "to is required for proactive send" };
+  }
+  if (params.mediaUrl?.trim()) {
+    return qqbotOutbound.sendMedia({
+      cfg: params.cfg,
+      to,
+      mediaUrl: params.mediaUrl.trim(),
+      text: params.text,
+      accountId: params.accountId
+    });
+  }
+  const text = params.text?.trim();
+  if (!text) {
+    return { channel: "qqbot", error: "text or mediaUrl is required for proactive send" };
+  }
+  return qqbotOutbound.sendText({
+    cfg: params.cfg,
+    to,
+    text,
+    accountId: params.accountId
+  });
+}
 
 // src/runtime.ts
 var runtime = null;
@@ -7916,6 +8712,24 @@ function getQQBotRuntime() {
   }
   return runtime;
 }
+var sessionDispatchQueue = /* @__PURE__ */ new Map();
+function buildSessionDispatchQueueKey(route) {
+  const accountId = route.accountId?.trim() || DEFAULT_ACCOUNT_ID;
+  return `${accountId}:${route.sessionKey}`;
+}
+async function runSerializedSessionDispatch(queueKey, task) {
+  const previous = sessionDispatchQueue.get(queueKey) ?? Promise.resolve();
+  const run = previous.catch(() => void 0).then(task);
+  const cleanup = run.then(() => void 0, () => void 0);
+  sessionDispatchQueue.set(queueKey, cleanup);
+  try {
+    return await run;
+  } finally {
+    if (sessionDispatchQueue.get(queueKey) === cleanup) {
+      sessionDispatchQueue.delete(queueKey);
+    }
+  }
+}
 function toString(value) {
   if (typeof value === "string" && value.trim()) return value;
   return void 0;
@@ -8341,26 +9155,100 @@ function resolveEnvelopeFrom(event) {
   }
   return event.senderName?.trim() || event.senderId;
 }
+function resolveKnownQQBotTargetFromInbound(params) {
+  const { inbound, accountId } = params;
+  if (inbound.type === "direct") {
+    if (!inbound.c2cOpenid?.trim()) {
+      return void 0;
+    }
+    return {
+      accountId,
+      kind: "user",
+      target: `user:${inbound.c2cOpenid}`,
+      displayName: inbound.senderName,
+      sourceChatType: "direct",
+      firstSeenAt: inbound.timestamp,
+      lastSeenAt: inbound.timestamp
+    };
+  }
+  if (inbound.type === "group" && inbound.groupOpenid?.trim()) {
+    return {
+      accountId,
+      kind: "group",
+      target: `group:${inbound.groupOpenid}`,
+      displayName: inbound.senderName,
+      sourceChatType: "group",
+      firstSeenAt: inbound.timestamp,
+      lastSeenAt: inbound.timestamp
+    };
+  }
+  if (inbound.type === "channel" && inbound.channelId?.trim()) {
+    return {
+      accountId,
+      kind: "channel",
+      target: `channel:${inbound.channelId}`,
+      displayName: inbound.senderName,
+      sourceChatType: "channel",
+      firstSeenAt: inbound.timestamp,
+      lastSeenAt: inbound.timestamp
+    };
+  }
+  return void 0;
+}
 function extractLocalMediaFromText(params) {
   const { text, logger } = params;
-  const result = extractMediaFromText(text, {
-    removeFromText: true,
-    checkExists: true,
-    existsSync: (p) => {
-      const exists = fs3.existsSync(p);
-      if (!exists) {
-        logger?.warn?.(`[media] local file not found: ${p}`);
-      }
-      return exists;
-    },
-    parseMediaLines: false,
-    parseMarkdownImages: true,
-    parseHtmlImages: false,
-    parseBarePaths: true,
-    parseMarkdownLinks: true
+  const mediaUrls = [];
+  const seenMedia = /* @__PURE__ */ new Set();
+  let nextText = text;
+  const MARKDOWN_LINKED_IMAGE_RE2 = /\[!\[([^\]]*)\]\(([^)]+)\)\]\(([^)]+)\)/g;
+  const MARKDOWN_IMAGE_RE3 = /!\[([^\]]*)\]\(([^)]+)\)/g;
+  const MARKDOWN_LINK_RE2 = /\[([^\]]*)\]\(([^)]+)\)/g;
+  const BARE_LOCAL_MEDIA_PATH_RE = /`?((?:\/(?:tmp|var|private|Users|home|root)\/[^\s`'",)]+|[A-Za-z]:[\\/][^\s`'",)]+)\.(?:png|jpg|jpeg|gif|bmp|webp|svg|ico|mp3|wav|ogg|m4a|amr|flac|aac|wma|mp4|mov|avi|mkv|webm|flv|wmv|m4v))`?/gi;
+  const collectLocalRichMedia = (rawValue, allowedTypes) => {
+    const candidate = stripTitleFromUrl(rawValue.trim());
+    if (!candidate || !isLocalReference(candidate)) {
+      return void 0;
+    }
+    if (!fs3.existsSync(candidate)) {
+      logger?.warn?.(`[media] local file not found: ${candidate}`);
+      return void 0;
+    }
+    const mediaType = detectMediaType(candidate);
+    if (mediaType === "file") {
+      return void 0;
+    }
+    if (allowedTypes && !allowedTypes.has(mediaType)) {
+      return void 0;
+    }
+    if (seenMedia.has(candidate)) {
+      return candidate;
+    }
+    seenMedia.add(candidate);
+    mediaUrls.push(candidate);
+    return candidate;
+  };
+  nextText = nextText.replace(MARKDOWN_LINKED_IMAGE_RE2, (fullMatch, _alt, rawPath) => {
+    return collectLocalRichMedia(rawPath) ? "" : fullMatch;
   });
-  const mediaUrls = result.all.filter((m) => m.isLocal && typeof m.localPath === "string").filter((m) => m.type !== "file").map((m) => m.localPath);
-  return { text: result.text, mediaUrls };
+  nextText = nextText.replace(MARKDOWN_IMAGE_RE3, (fullMatch, _alt, rawPath) => {
+    return collectLocalRichMedia(rawPath) ? "" : fullMatch;
+  });
+  nextText = nextText.replace(MARKDOWN_LINK_RE2, (fullMatch, _label, rawPath) => {
+    const mediaPath = collectLocalRichMedia(rawPath, /* @__PURE__ */ new Set(["audio", "video"]));
+    if (!mediaPath) {
+      return fullMatch;
+    }
+    return "";
+  });
+  nextText = nextText.replace(BARE_LOCAL_MEDIA_PATH_RE, (fullMatch, rawPath) => {
+    return collectLocalRichMedia(rawPath) ? "" : fullMatch;
+  });
+  nextText = nextText.replace(/[ \t]+\n/g, "\n");
+  nextText = nextText.replace(/\n{3,}/g, "\n\n");
+  return {
+    text: nextText.trim(),
+    mediaUrls
+  };
 }
 function extractMediaLinesFromText(params) {
   const { text, logger } = params;
@@ -8383,6 +9271,23 @@ function extractMediaLinesFromText(params) {
   const mediaUrls = result.all.map((m) => m.isLocal ? m.localPath ?? m.source : m.source).filter((m) => typeof m === "string" && m.trim().length > 0);
   return { text: result.text, mediaUrls };
 }
+function extractQQBotReplyMedia(params) {
+  const mediaLineResult = extractMediaLinesFromText({
+    text: params.text,
+    logger: params.logger
+  });
+  if (!params.autoSendLocalPathMedia) {
+    return mediaLineResult;
+  }
+  const localMediaResult = extractLocalMediaFromText({
+    text: mediaLineResult.text,
+    logger: params.logger
+  });
+  return {
+    text: localMediaResult.text,
+    mediaUrls: [.../* @__PURE__ */ new Set([...mediaLineResult.mediaUrls, ...localMediaResult.mediaUrls])]
+  };
+}
 function buildMediaFallbackText(mediaUrl) {
   if (!/^https?:\/\//i.test(mediaUrl)) {
     return void 0;
@@ -8396,6 +9301,9 @@ var FILE_PLACEHOLDER_RE = /\[文件:\s*[^\]\n]+\]/g;
 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;
+var MARKDOWN_TABLE_SEPARATOR_RE = /^\|?(?:\s*:?-{3,}:?\s*\|)+(?:\s*:?-{3,}:?)?\|?$/;
+var EXPLICIT_MARKDOWN_FENCE_RE = /(^|\n)(`{3,}|~{3,})\s*(?:markdown|md)\s*\n([\s\S]*?)\n\2(?=\n|$)/gi;
+var GENERIC_MARKDOWN_FENCE_RE = /(^|\n)(`{3,}|~{3,})\s*\n([\s\S]*?)\n\2(?=\n|$)/g;
 function extractFinalBlocks(text) {
   const matches = Array.from(text.matchAll(FINAL_BLOCK_RE));
   if (matches.length === 0) return void 0;
@@ -8420,6 +9328,14 @@ function sanitizeQQBotOutboundText(rawText) {
   if (/^NO_REPLY$/i.test(next)) return "";
   return next;
 }
+function formatQQBotOutboundPreview(text, maxLength = 240) {
+  const normalized = text.replace(/\r\n/g, "\n").trim();
+  if (!normalized) {
+    return '""';
+  }
+  const preview = normalized.length > maxLength ? `${normalized.slice(0, Math.max(0, maxLength - 3))}...` : normalized;
+  return JSON.stringify(preview);
+}
 function shouldSuppressQQBotTextWhenMediaPresent(rawText, sanitizedText) {
   const raw = rawText.trim();
   if (!raw) return false;
@@ -8452,6 +9368,111 @@ function evaluateReplyFinalOnlyDelivery(params) {
   }
   return { skipDelivery: true, suppressText: false };
 }
+function isQQBotC2CTarget(to) {
+  const trimmed = to.trim();
+  const raw = trimmed.startsWith("qqbot:") ? trimmed.slice("qqbot:".length) : trimmed;
+  return !raw.startsWith("group:") && !raw.startsWith("channel:");
+}
+function splitQQBotMarkdownTransportMediaUrls(mediaUrls) {
+  const markdownImageUrls = [];
+  const mediaQueue = [];
+  const seenMarkdownImages = /* @__PURE__ */ new Set();
+  const seenMedia = /* @__PURE__ */ new Set();
+  for (const rawUrl of mediaUrls) {
+    const next = rawUrl.trim();
+    if (!next) continue;
+    if (isQQBotHttpImageUrl(next)) {
+      if (seenMarkdownImages.has(next)) continue;
+      seenMarkdownImages.add(next);
+      markdownImageUrls.push(next);
+      continue;
+    }
+    if (seenMedia.has(next)) continue;
+    seenMedia.add(next);
+    mediaQueue.push(next);
+  }
+  return { markdownImageUrls, mediaQueue };
+}
+function hasQQBotMarkdownTable(text) {
+  const lines = text.replace(/\r\n/g, "\n").split("\n");
+  for (let index = 0; index < lines.length - 1; index += 1) {
+    const header = lines[index]?.trim() ?? "";
+    const separator = lines[index + 1]?.trim() ?? "";
+    if (!header.includes("|") || !MARKDOWN_TABLE_SEPARATOR_RE.test(separator)) {
+      continue;
+    }
+    const headerColumns = header.split("|").filter((column) => column.trim()).length;
+    const separatorColumns = separator.split("|").filter((column) => column.trim()).length;
+    if (headerColumns >= 2 && separatorColumns >= 2) {
+      return true;
+    }
+  }
+  return false;
+}
+function resolveQQBotTextReplyRefs(params) {
+  const mode = params.c2cMarkdownDeliveryMode ?? "proactive-table-only";
+  const forceProactive = params.markdownSupport && isQQBotC2CTarget(params.to) && (mode === "proactive-all" || mode === "proactive-table-only" && hasQQBotMarkdownTable(params.text));
+  if (!forceProactive) {
+    return {
+      forceProactive: false,
+      replyToId: params.replyToId,
+      replyEventId: params.replyEventId
+    };
+  }
+  return {
+    forceProactive: true,
+    replyToId: void 0,
+    replyEventId: void 0
+  };
+}
+function appendQQBotBufferedText(bufferedTexts, nextText) {
+  const normalized = nextText.trim();
+  if (!normalized) return bufferedTexts;
+  if (bufferedTexts.length === 0) return [normalized];
+  const currentCombined = bufferedTexts.join("\n\n");
+  if (currentCombined === normalized || currentCombined.includes(normalized)) {
+    return bufferedTexts;
+  }
+  if (normalized.includes(currentCombined)) {
+    return [normalized];
+  }
+  const last = bufferedTexts[bufferedTexts.length - 1];
+  if (last === normalized) {
+    return bufferedTexts;
+  }
+  return [...bufferedTexts, normalized];
+}
+function normalizeQQBotRenderedMarkdown(text) {
+  if (!text.trim()) return "";
+  let next = text.trim();
+  let changed = false;
+  next = next.replace(
+    EXPLICIT_MARKDOWN_FENCE_RE,
+    (block, leadingLineBreak, _fence, inner) => {
+      const normalizedInner = inner.trim();
+      if (!normalizedInner) {
+        return block;
+      }
+      changed = true;
+      return `${leadingLineBreak}${normalizedInner}`;
+    }
+  );
+  next = next.replace(
+    GENERIC_MARKDOWN_FENCE_RE,
+    (block, leadingLineBreak, _fence, inner) => {
+      const normalizedInner = inner.trim();
+      if (!normalizedInner) {
+        return block;
+      }
+      if (!hasQQBotMarkdownTable(normalizedInner)) {
+        return block;
+      }
+      changed = true;
+      return `${leadingLineBreak}${normalizedInner}`;
+    }
+  );
+  return changed ? next.trim() : text.trim();
+}
 async function sendQQBotMediaWithFallback(params) {
   const { qqCfg, to, mediaQueue, replyToId, replyEventId, logger, onDelivered, onError } = params;
   const outbound = params.outbound ?? qqbotOutbound;
@@ -8518,13 +9539,8 @@ function buildInboundContext(params) {
   };
 }
 async function dispatchToAgent(params) {
-  const { inbound, cfg, qqCfg, accountId, logger } = params;
+  const { inbound, cfg, qqCfg, accountId, logger, route } = params;
   const runtime2 = getQQBotRuntime();
-  const routing = runtime2.channel?.routing?.resolveAgentRoute;
-  if (!routing) {
-    logger.warn("routing API not available");
-    return;
-  }
   const target = resolveChatTarget(inbound);
   if (inbound.c2cOpenid) {
     const typing = await qqbotOutbound.sendTyping({
@@ -8538,12 +9554,6 @@ async function dispatchToAgent(params) {
       logger.warn(`sendTyping failed: ${typing.error}`);
     }
   }
-  const route = routing({
-    cfg,
-    channel: "qqbot",
-    accountId,
-    peer: { kind: target.peerKind, id: target.peerId }
-  });
   const replyApi = runtime2.channel?.reply;
   if (!replyApi) {
     logger.warn("reply API not available");
@@ -8714,17 +9724,99 @@ async function dispatchToAgent(params) {
       return [text];
     };
     const replyFinalOnly = qqCfg.replyFinalOnly ?? false;
+    const markdownSupport = qqCfg.markdownSupport ?? true;
+    const c2cMarkdownDeliveryMode = qqCfg.c2cMarkdownDeliveryMode ?? "proactive-table-only";
+    const useC2CMarkdownTransport = markdownSupport && isQQBotC2CTarget(target.to);
+    let bufferedC2CMarkdownTexts = [];
+    let bufferedC2CMarkdownMediaUrls = [];
+    const bufferedC2CMarkdownMediaSeen = /* @__PURE__ */ new Set();
+    const bufferC2CMarkdownMedia = (url) => {
+      const next = url?.trim();
+      if (!next || bufferedC2CMarkdownMediaSeen.has(next)) return;
+      bufferedC2CMarkdownMediaSeen.add(next);
+      bufferedC2CMarkdownMediaUrls.push(next);
+    };
+    const flushBufferedC2CMarkdownReply = async () => {
+      if (!useC2CMarkdownTransport || bufferedC2CMarkdownTexts.length === 0 && bufferedC2CMarkdownMediaUrls.length === 0) {
+        bufferedC2CMarkdownTexts = [];
+        bufferedC2CMarkdownMediaUrls = [];
+        bufferedC2CMarkdownMediaSeen.clear();
+        return;
+      }
+      const combinedText = bufferedC2CMarkdownTexts.join("\n\n").trim();
+      const combinedMediaUrls = [...bufferedC2CMarkdownMediaUrls];
+      bufferedC2CMarkdownTexts = [];
+      bufferedC2CMarkdownMediaUrls = [];
+      bufferedC2CMarkdownMediaSeen.clear();
+      const normalizedCombinedText = normalizeQQBotRenderedMarkdown(combinedText);
+      const { markdownImageUrls, mediaQueue } = splitQQBotMarkdownTransportMediaUrls(combinedMediaUrls);
+      const finalMarkdownText = await normalizeQQBotMarkdownImages({
+        text: normalizedCombinedText,
+        appendImageUrls: markdownImageUrls
+      });
+      const textReplyRefs = resolveQQBotTextReplyRefs({
+        to: target.to,
+        text: finalMarkdownText || normalizedCombinedText,
+        markdownSupport,
+        c2cMarkdownDeliveryMode,
+        replyToId: inbound.messageId,
+        replyEventId: inbound.eventId
+      });
+      const textSegments = finalMarkdownText ? [finalMarkdownText] : [];
+      const deliveryLabel = textReplyRefs.forceProactive ? "c2c-markdown-proactive" : "c2c-markdown-passive";
+      logger.info(
+        `delivery=${deliveryLabel} to=${target.to} segments=${textSegments.length} media=${mediaQueue.length} replyToId=${textReplyRefs.replyToId ? "yes" : "no"} replyEventId=${textReplyRefs.replyEventId ? "yes" : "no"} tableMode=${String(resolvedTableMode)} chunkMode=${String(chunkMode ?? "default")}`
+      );
+      await sendQQBotMediaWithFallback({
+        qqCfg,
+        to: target.to,
+        mediaQueue,
+        replyToId: textReplyRefs.replyToId,
+        replyEventId: textReplyRefs.replyEventId,
+        logger,
+        onDelivered: () => {
+          markReplyDelivered();
+        },
+        onError: (error) => {
+          markGroupMessageInterfaceBlocked(error);
+        }
+      });
+      if (!finalMarkdownText) {
+        return;
+      }
+      for (let segmentIndex = 0; segmentIndex < textSegments.length; segmentIndex += 1) {
+        const segment = textSegments[segmentIndex] ?? "";
+        const chunks = chunkText(segment);
+        for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex += 1) {
+          const chunk = chunks[chunkIndex] ?? "";
+          logger.info(
+            `delivery=${deliveryLabel} segment=${segmentIndex + 1}/${textSegments.length} chunk=${chunkIndex + 1}/${chunks.length} preview=${formatQQBotOutboundPreview(chunk)}`
+          );
+          const result = await qqbotOutbound.sendText({
+            cfg: { channels: { qqbot: qqCfg } },
+            to: target.to,
+            text: chunk,
+            replyToId: textReplyRefs.replyToId,
+            replyEventId: textReplyRefs.replyEventId
+          });
+          if (result.error) {
+            logger.error(`send buffered QQ markdown reply failed: ${result.error}`);
+            markGroupMessageInterfaceBlocked(result.error);
+          } else {
+            logger.info(`sent buffered QQ markdown reply (len=${chunk.length})`);
+            markReplyDelivered();
+          }
+        }
+      }
+    };
     const deliver = async (payload, info) => {
       const typed = payload;
-      const mediaLineResult = extractMediaLinesFromText({
+      const extractedTextMedia = extractQQBotReplyMedia({
         text: typed?.text ?? "",
-        logger
-      });
-      const localMediaResult = extractLocalMediaFromText({
-        text: mediaLineResult.text,
-        logger
+        logger,
+        autoSendLocalPathMedia: resolveQQBotAutoSendLocalPathMedia(qqCfg)
       });
-      const cleanedText = sanitizeQQBotOutboundText(localMediaResult.text);
+      const cleanedText = sanitizeQQBotOutboundText(extractedTextMedia.text);
       const payloadMediaUrls = Array.isArray(typed?.mediaUrls) ? typed?.mediaUrls : typed?.mediaUrl ? [typed.mediaUrl] : [];
       const mediaQueue = [];
       const seenMedia = /* @__PURE__ */ new Set();
@@ -8736,8 +9828,7 @@ async function dispatchToAgent(params) {
         mediaQueue.push(next);
       };
       for (const url of payloadMediaUrls) addMedia(url);
-      for (const url of mediaLineResult.mediaUrls) addMedia(url);
-      for (const url of localMediaResult.mediaUrls) addMedia(url);
+      for (const url of extractedTextMedia.mediaUrls) addMedia(url);
       const deliveryDecision = evaluateReplyFinalOnlyDelivery({
         replyFinalOnly,
         kind: info?.kind,
@@ -8745,19 +9836,36 @@ async function dispatchToAgent(params) {
         sanitizedText: cleanedText
       });
       if (deliveryDecision.skipDelivery) return;
-      const suppressEchoText = mediaQueue.length > 0 && shouldSuppressQQBotTextWhenMediaPresent(localMediaResult.text, cleanedText);
+      const suppressEchoText = mediaQueue.length > 0 && shouldSuppressQQBotTextWhenMediaPresent(extractedTextMedia.text, cleanedText);
       const suppressText = deliveryDecision.suppressText || suppressEchoText;
       const textToSend = suppressText ? "" : cleanedText;
+      if (useC2CMarkdownTransport) {
+        if (textToSend) {
+          bufferedC2CMarkdownTexts = appendQQBotBufferedText(bufferedC2CMarkdownTexts, textToSend);
+        }
+        for (const url of mediaQueue) {
+          bufferC2CMarkdownMedia(url);
+        }
+        return;
+      }
       if (textToSend) {
         const converted = textApi?.convertMarkdownTables ? textApi.convertMarkdownTables(textToSend, resolvedTableMode) : textToSend;
+        const textReplyRefs = resolveQQBotTextReplyRefs({
+          to: target.to,
+          text: converted,
+          markdownSupport,
+          c2cMarkdownDeliveryMode,
+          replyToId: inbound.messageId,
+          replyEventId: inbound.eventId
+        });
         const chunks = chunkText(converted);
         for (const chunk of chunks) {
           const result = await qqbotOutbound.sendText({
             cfg: { channels: { qqbot: qqCfg } },
             to: target.to,
             text: chunk,
-            replyToId: inbound.messageId,
-            replyEventId: inbound.eventId
+            replyToId: textReplyRefs.replyToId,
+            replyEventId: textReplyRefs.replyEventId
           });
           if (result.error) {
             logger.error(`sendText failed: ${result.error}`);
@@ -8801,6 +9909,7 @@ async function dispatchToAgent(params) {
           }
         }
       });
+      await flushBufferedC2CMarkdownReply();
     } else {
       const dispatcherResult = replyApi.createReplyDispatcherWithTyping ? replyApi.createReplyDispatcherWithTyping({
         deliver,
@@ -8830,6 +9939,7 @@ async function dispatchToAgent(params) {
         replyOptions: dispatcherResult.replyOptions
       });
       dispatcherResult.markDispatchIdle?.();
+      await flushBufferedC2CMarkdownReply();
     }
     const noReplyFallback = resolveQQBotNoReplyFallback({
       inbound,
@@ -8919,6 +10029,14 @@ async function handleQQBotDispatch(params) {
   if (!shouldHandleMessage(inbound, qqCfg, logger)) {
     return;
   }
+  const knownTarget = resolveKnownQQBotTargetFromInbound({ inbound, accountId });
+  if (knownTarget) {
+    try {
+      upsertKnownQQBotTarget({ target: knownTarget });
+    } catch (err) {
+      logger.warn(`failed to record known qqbot target: ${String(err)}`);
+    }
+  }
   const attachmentCount = inbound.attachments?.length ?? 0;
   if (attachmentCount > 0) {
     logger.info(`inbound message includes ${attachmentCount} attachment(s)`);
@@ -8926,13 +10044,34 @@ async function handleQQBotDispatch(params) {
   if (!content && attachmentCount === 0) {
     return;
   }
-  await dispatchToAgent({
-    inbound: { ...inbound, content },
+  const runtime2 = getQQBotRuntime();
+  const routing = runtime2.channel?.routing?.resolveAgentRoute;
+  if (!routing) {
+    logger.warn("routing API not available");
+    return;
+  }
+  const target = resolveChatTarget(inbound);
+  const route = routing({
     cfg: params.cfg,
-    qqCfg,
+    channel: "qqbot",
     accountId,
-    logger
+    peer: { kind: target.peerKind, id: target.peerId }
   });
+  const queueKey = buildSessionDispatchQueueKey(route);
+  if (sessionDispatchQueue.has(queueKey)) {
+    logger.info(`session busy; queueing inbound dispatch sessionKey=${route.sessionKey}`);
+  }
+  await runSerializedSessionDispatch(
+    queueKey,
+    async () => dispatchToAgent({
+      inbound: { ...inbound, content },
+      cfg: params.cfg,
+      qqCfg,
+      accountId,
+      logger,
+      route
+    })
+  );
 }
 
 // src/monitor.ts
@@ -9232,7 +10371,8 @@ function resolveQQBotAccount(params) {
     enabled,
     configured,
     appId: credentials?.appId,
-    markdownSupport: merged.markdownSupport ?? true
+    markdownSupport: merged.markdownSupport ?? true,
+    c2cMarkdownDeliveryMode: merged.c2cMarkdownDeliveryMode ?? "proactive-table-only"
   };
 }
 var qqbotPlugin = {
@@ -9248,7 +10388,8 @@ var qqbotPlugin = {
     edit: false,
     reply: true,
     polls: false,
-    blockStreaming: false
+    blockStreaming: false,
+    activeSend: true
   },
   messaging: {
     normalizeTarget: (raw) => {
@@ -9320,6 +10461,10 @@ var qqbotPlugin = {
           }
         },
         markdownSupport: { type: "boolean" },
+        c2cMarkdownDeliveryMode: {
+          type: "string",
+          enum: ["passive", "proactive-table-only", "proactive-all"]
+        },
         dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
         groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
         requireMention: { type: "boolean" },
@@ -9331,6 +10476,7 @@ var qqbotPlugin = {
         longTaskNoticeDelayMs: { type: "integer", minimum: 0 },
         maxFileSizeMB: { type: "number" },
         mediaTimeoutMs: { type: "number" },
+        autoSendLocalPathMedia: { type: "boolean" },
         inboundMedia: {
           type: "object",
           additionalProperties: false,
@@ -9360,6 +10506,10 @@ var qqbotPlugin = {
                 }
               },
               markdownSupport: { type: "boolean" },
+              c2cMarkdownDeliveryMode: {
+                type: "string",
+                enum: ["passive", "proactive-table-only", "proactive-all"]
+              },
               dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
               groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
               requireMention: { type: "boolean" },
@@ -9371,6 +10521,7 @@ var qqbotPlugin = {
               longTaskNoticeDelayMs: { type: "integer", minimum: 0 },
               maxFileSizeMB: { type: "number" },
               mediaTimeoutMs: { type: "number" },
+              autoSendLocalPathMedia: { type: "boolean" },
               inboundMedia: {
                 type: "object",
                 additionalProperties: false,
@@ -9386,6 +10537,7 @@ var qqbotPlugin = {
     }
   },
   reload: { configPrefixes: ["channels.qqbot"] },
+  onboarding: qqbotOnboardingAdapter,
   config: {
     listAccountIds: (cfg) => listQQBotAccountIds(cfg),
     resolveAccount: (cfg, accountId) => resolveQQBotAccount({ cfg, accountId }),
@@ -9556,6 +10708,10 @@ var plugin = {
         }
       },
       markdownSupport: { type: "boolean" },
+      c2cMarkdownDeliveryMode: {
+        type: "string",
+        enum: ["passive", "proactive-table-only", "proactive-all"]
+      },
       dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
       groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
       requireMention: { type: "boolean" },
@@ -9567,6 +10723,7 @@ var plugin = {
       longTaskNoticeDelayMs: { type: "integer", minimum: 0 },
       maxFileSizeMB: { type: "number" },
       mediaTimeoutMs: { type: "number" },
+      autoSendLocalPathMedia: { type: "boolean" },
       inboundMedia: {
         type: "object",
         additionalProperties: false,
@@ -9596,6 +10753,10 @@ var plugin = {
               }
             },
             markdownSupport: { type: "boolean" },
+            c2cMarkdownDeliveryMode: {
+              type: "string",
+              enum: ["passive", "proactive-table-only", "proactive-all"]
+            },
             dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
             groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
             requireMention: { type: "boolean" },
@@ -9607,6 +10768,7 @@ var plugin = {
             longTaskNoticeDelayMs: { type: "integer", minimum: 0 },
             maxFileSizeMB: { type: "number" },
             mediaTimeoutMs: { type: "number" },
+            autoSendLocalPathMedia: { type: "boolean" },
             inboundMedia: {
               type: "object",
               additionalProperties: false,
@@ -9631,6 +10793,6 @@ var plugin = {
 };
 var index_default = plugin;
 
-export { DEFAULT_ACCOUNT_ID, index_default as default, getQQBotRuntime, qqbotPlugin, setQQBotRuntime };
+export { DEFAULT_ACCOUNT_ID, clearKnownQQBotTargets, index_default as default, getKnownQQBotTarget, getQQBotRuntime, listKnownQQBotTargets, qqbotPlugin, removeKnownQQBotTarget, sendProactiveQQBotMessage, setQQBotRuntime };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map