@openclaw-china/qqbot 2026.3.9 → 2026.3.10

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';
@@ -4245,6 +4245,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 +4265,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 +4320,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 +4873,7 @@ function extractMediaFromText(text, options = {}) {
   const {
     removeFromText = true,
     checkExists = false,
-    existsSync: existsSync5,
+    existsSync: existsSync6,
     parseMediaLines = false,
     parseMarkdownImages = true,
     parseHtmlImages = true,
@@ -4734,7 +4888,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 +6683,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 +6851,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");
@@ -7904,6 +8076,179 @@ ${mediaUrl}` : mediaUrl;
 
 // src/logger.ts
 createLogger("qqbot");
+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;
@@ -8341,6 +8686,46 @@ 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, {
@@ -8383,6 +8768,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;
@@ -8716,15 +9118,12 @@ async function dispatchToAgent(params) {
     const replyFinalOnly = qqCfg.replyFinalOnly ?? false;
     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 +9135,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,7 +9143,7 @@ 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 (textToSend) {
@@ -8919,6 +9317,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)`);
@@ -9248,7 +9654,8 @@ var qqbotPlugin = {
     edit: false,
     reply: true,
     polls: false,
-    blockStreaming: false
+    blockStreaming: false,
+    activeSend: true
   },
   messaging: {
     normalizeTarget: (raw) => {
@@ -9331,6 +9738,7 @@ var qqbotPlugin = {
         longTaskNoticeDelayMs: { type: "integer", minimum: 0 },
         maxFileSizeMB: { type: "number" },
         mediaTimeoutMs: { type: "number" },
+        autoSendLocalPathMedia: { type: "boolean" },
         inboundMedia: {
           type: "object",
           additionalProperties: false,
@@ -9371,6 +9779,7 @@ var qqbotPlugin = {
               longTaskNoticeDelayMs: { type: "integer", minimum: 0 },
               maxFileSizeMB: { type: "number" },
               mediaTimeoutMs: { type: "number" },
+              autoSendLocalPathMedia: { type: "boolean" },
               inboundMedia: {
                 type: "object",
                 additionalProperties: false,
@@ -9386,6 +9795,7 @@ var qqbotPlugin = {
     }
   },
   reload: { configPrefixes: ["channels.qqbot"] },
+  onboarding: qqbotOnboardingAdapter,
   config: {
     listAccountIds: (cfg) => listQQBotAccountIds(cfg),
     resolveAccount: (cfg, accountId) => resolveQQBotAccount({ cfg, accountId }),
@@ -9567,6 +9977,7 @@ var plugin = {
       longTaskNoticeDelayMs: { type: "integer", minimum: 0 },
       maxFileSizeMB: { type: "number" },
       mediaTimeoutMs: { type: "number" },
+      autoSendLocalPathMedia: { type: "boolean" },
       inboundMedia: {
         type: "object",
         additionalProperties: false,
@@ -9607,6 +10018,7 @@ var plugin = {
             longTaskNoticeDelayMs: { type: "integer", minimum: 0 },
             maxFileSizeMB: { type: "number" },
             mediaTimeoutMs: { type: "number" },
+            autoSendLocalPathMedia: { type: "boolean" },
             inboundMedia: {
               type: "object",
               additionalProperties: false,
@@ -9631,6 +10043,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