@tencent-connect/openclaw-qqbot 1.6.2-alpha.2 → 1.6.2-alpha.3

package/dist/src/update-checker.js

@@ -24,15 +24,6 @@ let _lastInfo = {
     checkedAt: 0,
 };
 let _checking = false;
-/** 已通知过的版本号，避免同一版本重复推送 */
-let _notifiedVersion = null;
-let _onUpdateFound = null;
-/**
- * 注册新版本发现回调（仅在首次检测到某个新版本时触发一次）
- */
-export function onUpdateFound(cb) {
-    _onUpdateFound = cb;
-}
 export function triggerUpdateCheck(log) {
     if (_checking)
         return;
@@ -64,11 +55,6 @@ export function triggerUpdateCheck(log) {
             _lastInfo = { current: CURRENT_VERSION, latest: compareTarget, hasUpdate, checkedAt: now };
             if (hasUpdate) {
                 log?.info?.(`[qqbot:update-checker] new version available: ${compareTarget} (current: ${CURRENT_VERSION})`);
-                // 首次发现该版本时触发回调
-                if (_onUpdateFound && compareTarget !== _notifiedVersion) {
-                    _notifiedVersion = compareTarget;
-                    _onUpdateFound(_lastInfo);
-                }
             }
         }
         catch (parseErr) {
@@ -79,11 +65,6 @@ export function triggerUpdateCheck(log) {
 export function getUpdateInfo() {
     return { ..._lastInfo };
 }
-export function formatUpdateNotice(info) {
-    if (!info.hasUpdate || !info.latest)
-        return "";
-    return `\u{1f195} 有新版本可用: v${info.latest}（当前 v${info.current}）\n使用 /qqbot-upgrade 升级`;
-}
 function compareVersions(a, b) {
     const parse = (v) => {
         const clean = v.replace(/^v/, "");

package/dist/src/user-messages.d.ts

@@ -1,16 +1,8 @@
+export {};
 /**
- * 用户面向的提示文案集中管理
- * 仅保留格式校验类提示，运行时错误走日志不面向用户
+ * 用户面向的提示文案 — 已清空
+ *
+ * 设计原则（对齐飞书插件）：
+ * QQBot 插件层不生成额外的用户提示信息。
+ * 所有运行时错误仅写日志，不面向用户展示。
  */
-export declare const MSG: {
-    readonly IMAGE_FORMAT_UNSUPPORTED: (ext: string) => string;
-    readonly VOICE_CHANNEL_UNSUPPORTED: "抱歉，语音消息暂不支持在频道中发送～";
-    readonly VIDEO_CHANNEL_UNSUPPORTED: "抱歉，视频消息暂不支持在频道中发送～";
-    readonly FILE_CHANNEL_UNSUPPORTED: "抱歉，文件消息暂不支持在频道中发送～";
-    readonly VOICE_MISSING_TEXT: "抱歉，语音消息缺少内容～";
-    readonly VIDEO_MISSING_PATH: "抱歉，视频消息缺少内容～";
-    readonly FILE_MISSING_PATH: "抱歉，文件消息缺少内容～";
-    readonly PAYLOAD_PARSE_ERROR: "抱歉，消息格式异常，无法处理～";
-    readonly UNSUPPORTED_MEDIA_TYPE: "抱歉，暂不支持该媒体类型～";
-    readonly UNSUPPORTED_PAYLOAD_TYPE: "抱歉，暂不支持该消息类型～";
-};

package/dist/src/user-messages.js

@@ -1,20 +1,8 @@
+export {};
 /**
- * 用户面向的提示文案集中管理
- * 仅保留格式校验类提示，运行时错误走日志不面向用户
+ * 用户面向的提示文案 — 已清空
+ *
+ * 设计原则（对齐飞书插件）：
+ * QQBot 插件层不生成额外的用户提示信息。
+ * 所有运行时错误仅写日志，不面向用户展示。
  */
-export const MSG = {
-    // 图片格式校验
-    IMAGE_FORMAT_UNSUPPORTED: (ext) => `抱歉，暂不支持 ${ext} 格式的图片～`,
-    // 频道不支持的媒体类型
-    VOICE_CHANNEL_UNSUPPORTED: "抱歉，语音消息暂不支持在频道中发送～",
-    VIDEO_CHANNEL_UNSUPPORTED: "抱歉，视频消息暂不支持在频道中发送～",
-    FILE_CHANNEL_UNSUPPORTED: "抱歉，文件消息暂不支持在频道中发送～",
-    // 缺少必要内容
-    VOICE_MISSING_TEXT: "抱歉，语音消息缺少内容～",
-    VIDEO_MISSING_PATH: "抱歉，视频消息缺少内容～",
-    FILE_MISSING_PATH: "抱歉，文件消息缺少内容～",
-    // 载荷解析校验
-    PAYLOAD_PARSE_ERROR: "抱歉，消息格式异常，无法处理～",
-    UNSUPPORTED_MEDIA_TYPE: "抱歉，暂不支持该媒体类型～",
-    UNSUPPORTED_PAYLOAD_TYPE: "抱歉，暂不支持该消息类型～",
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tencent-connect/openclaw-qqbot",
-  "version": "1.6.2-alpha.2",
+  "version": "1.6.2-alpha.3",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/channel.ts

@@ -13,38 +13,17 @@ import { startGateway } from "./gateway.js";
 import { qqbotOnboardingAdapter } from "./onboarding.js";
 import { getQQBotRuntime } from "./runtime.js";
 
+/** QQ Bot 单条消息文本长度上限 */
+export const TEXT_CHUNK_LIMIT = 5000;
+
 /**
- * 简单的文本分块函数
- * 用于预先分块长文本
+ * Markdown 感知的文本分块函数
+ * 委托给 SDK 内置的 channel.text.chunkMarkdownText
+ * 支持代码块自动关闭/重开、括号感知等
  */
-function chunkText(text: string, limit: number): string[] {
-  if (text.length <= limit) return [text];
-  
-  const chunks: string[] = [];
-  let remaining = text;
-  
-  while (remaining.length > 0) {
-    if (remaining.length <= limit) {
-      chunks.push(remaining);
-      break;
-    }
-    
-    // 尝试在换行处分割
-    let splitAt = remaining.lastIndexOf("\n", limit);
-    if (splitAt <= 0 || splitAt < limit * 0.5) {
-      // 没找到合适的换行，尝试在空格处分割
-      splitAt = remaining.lastIndexOf(" ", limit);
-    }
-    if (splitAt <= 0 || splitAt < limit * 0.5) {
-      // 还是没找到，强制在 limit 处分割
-      splitAt = limit;
-    }
-    
-    chunks.push(remaining.slice(0, splitAt));
-    remaining = remaining.slice(splitAt).trimStart();
-  }
-  
-  return chunks;
+export function chunkText(text: string, limit: number): string[] {
+  const runtime = getQQBotRuntime();
+  return runtime.channel.text.chunkMarkdownText(text, limit);
 }
 
 export const qqbotPlugin: ChannelPlugin<ResolvedQQBotAccount> = {
@@ -66,7 +45,7 @@ export const qqbotPlugin: ChannelPlugin<ResolvedQQBotAccount> = {
      * blockStreaming: true 表示该 Channel 支持块流式
      * 框架会收集流式响应，然后通过 deliver 回调发送
      */
-    blockStreaming: false,
+    blockStreaming: true,
   },
   reload: { configPrefixes: ["channels.qqbot"] },
   // CLI onboarding wizard
@@ -230,9 +209,9 @@ export const qqbotPlugin: ChannelPlugin<ResolvedQQBotAccount> = {
   },
   outbound: {
     deliveryMode: "direct",
-    chunker: chunkText,
+    chunker: (text, limit) => getQQBotRuntime().channel.text.chunkMarkdownText(text, limit),
     chunkerMode: "markdown",
-    textChunkLimit: 20000,
+    textChunkLimit: 5000,
     sendText: async ({ to, text, accountId, replyToId, cfg }) => {
       console.log(`[qqbot:channel] sendText called — accountId=${accountId}, to=${to}, replyToId=${replyToId}, text.length=${text?.length ?? 0}`);
       console.log(`[qqbot:channel] sendText text preview: ${text?.slice(0, 100)}${(text?.length ?? 0) > 100 ? "..." : ""}`);

package/src/gateway.ts

@@ -8,7 +8,7 @@ import { recordKnownUser, flushKnownUsers, listKnownUsers } from "./known-users.
 import { getQQBotRuntime } from "./runtime.js";
 import { setRefIndex, getRefIndex, formatRefEntryForAgent, flushRefIndex, type RefAttachmentSummary } from "./ref-index-store.js";
 import { matchSlashCommand, getPluginVersion, type SlashCommandContext, type SlashCommandFileResult, type QueueSnapshot } from "./slash-commands.js";
-import { triggerUpdateCheck, onUpdateFound, formatUpdateNotice } from "./update-checker.js";
+import { triggerUpdateCheck } from "./update-checker.js";
 import { startImageServer, isImageServerRunning, downloadFile, type ImageServerConfig } from "./image-server.js";
 import { getImageSize, formatQQBotMarkdownImage, hasQQBotImageSize, DEFAULT_IMAGE_SIZE } from "./utils/image-size.js";
 import { parseQQBotPayload, encodePayloadForCron, isCronReminderPayload, isMediaPayload, type CronReminderPayload, type MediaPayload } from "./utils/payload.js";
@@ -16,8 +16,9 @@ import { convertSilkToWav, isVoiceAttachment, formatDuration, resolveTTSConfig,
 import { normalizeMediaTags } from "./utils/media-tags.js";
 import { checkFileSize, readFileAsync, fileExistsAsync, isLargeFile, formatFileSize } from "./utils/file-utils.js";
 import { getQQBotDataDir, isLocalPath as isLocalFilePath, normalizePath, sanitizeFileName, runDiagnostics } from "./utils/platform.js";
-import { MSG } from "./user-messages.js";
+
 import { sendPhoto, sendVoice, sendVideoMsg, sendDocument, sendMedia as sendMediaAuto, type MediaTargetContext } from "./outbound.js";
+import { chunkText, TEXT_CHUNK_LIMIT } from "./channel.js";
 
 /**
  * 通用 OpenAI 兼容 STT（语音转文字）
@@ -221,6 +222,8 @@ function parseFaceTags(text: string): string {
   });
 }
 
+// formatMediaErrorMessage 已移至 user-messages.ts 集中管理
+
 // ============ 内部标记过滤 ============
 
 /**
@@ -408,36 +411,9 @@ export async function startGateway(ctx: GatewayContext): Promise<void> {
     }
   }
 
-  // 后台版本检查（detached 子进程，零阻塞）
+  // 后台版本检查（供 /qqbot-version、/qqbot-upgrade 指令被动查询）
   triggerUpdateCheck(log);
 
-  // 注册新版本通知回调：仅发给管理员，带防抖
-  let lastUpdateNotifyAt = 0;
-  const UPDATE_NOTIFY_DEBOUNCE_MS = 5 * 60 * 1000; // 5 分钟内不重复通知
-  onUpdateFound(async (info) => {
-    try {
-      // 防抖：避免短时间内重复推送
-      const now = Date.now();
-      if (now - lastUpdateNotifyAt < UPDATE_NOTIFY_DEBOUNCE_MS) {
-        log?.debug?.(`[qqbot:${account.accountId}] Update notification debounced`);
-        return;
-      }
-      const notice = formatUpdateNotice(info);
-      if (!notice) return;
-      const adminId = resolveAdminOpenId();
-      if (!adminId) {
-        log?.debug?.(`[qqbot:${account.accountId}] No admin or known user to send update notification`);
-        return;
-      }
-      const token = await getAccessToken(account.appId, account.clientSecret);
-      await sendProactiveC2CMessage(token, adminId, notice);
-      lastUpdateNotifyAt = Date.now();
-      log?.info(`[qqbot:${account.accountId}] Sent update notification to admin: ${adminId}`);
-    } catch (err) {
-      log?.debug?.(`[qqbot:${account.accountId}] Failed to send update notification to admin: ${err}`);
-    }
-  });
-
   // 初始化 API 配置（markdown 支持）
   initApiConfig({
     markdownSupport: account.markdownSupport,
@@ -468,7 +444,7 @@ export async function startGateway(ctx: GatewayContext): Promise<void> {
       attachments.push(attachment);
     }
     setRefIndex(refIdx, {
-      content: (meta.text ?? "").slice(0, 500),
+      content: meta.text ?? "",
       senderId: account.accountId,
       senderName: account.accountId,
       timestamp: Date.now(),
@@ -1684,20 +1660,24 @@ export async function startGateway(ctx: GatewayContext): Promise<void> {
 
                   for (const item of sendQueue) {
                     if (item.type === "text") {
-                      try {
-                        await sendWithTokenRetry(async (token) => {
-                          const ref = consumeQuoteRef();
-                          if (event.type === "c2c") {
-                            return await sendC2CMessage(token, event.senderId, item.content, event.messageId, ref);
-                          } else if (event.type === "group" && event.groupOpenid) {
-                            return await sendGroupMessage(token, event.groupOpenid, item.content, event.messageId);
-                          } else if (event.channelId) {
-                            return await sendChannelMessage(token, event.channelId, item.content, event.messageId);
-                          }
-                        });
-                        log?.info(`[qqbot:${account.accountId}] Sent text: ${item.content.slice(0, 50)}...`);
-                      } catch (err) {
-                        log?.error(`[qqbot:${account.accountId}] Failed to send text: ${err}`);
+                      // 对长文本进行分块发送
+                      const textChunks = getQQBotRuntime().channel.text.chunkMarkdownText(item.content, TEXT_CHUNK_LIMIT);
+                      for (const chunk of textChunks) {
+                        try {
+                          await sendWithTokenRetry(async (token) => {
+                            const ref = consumeQuoteRef();
+                            if (event.type === "c2c") {
+                              return await sendC2CMessage(token, event.senderId, chunk, event.messageId, ref);
+                            } else if (event.type === "group" && event.groupOpenid) {
+                              return await sendGroupMessage(token, event.groupOpenid, chunk, event.messageId);
+                            } else if (event.channelId) {
+                              return await sendChannelMessage(token, event.channelId, chunk, event.messageId);
+                            }
+                          });
+                          log?.info(`[qqbot:${account.accountId}] Sent text chunk (${chunk.length}/${item.content.length} chars): ${chunk.slice(0, 50)}...`);
+                        } catch (err) {
+                          log?.error(`[qqbot:${account.accountId}] Failed to send text chunk: ${err}`);
+                        }
                       }
                     } else if (item.type === "image") {
                       const result = await sendPhoto(mediaTarget, item.content);
@@ -1763,9 +1743,7 @@ export async function startGateway(ctx: GatewayContext): Promise<void> {
                 
                 if (payloadResult.isPayload) {
                   if (payloadResult.error) {
-                    // 载荷解析失败，发送错误提示
                     log?.error(`[qqbot:${account.accountId}] Payload parse error: ${payloadResult.error}`);
-                    await sendErrorMessage(MSG.PAYLOAD_PARSE_ERROR);
                     return;
                   }
                   
@@ -1839,7 +1817,7 @@ export async function startGateway(ctx: GatewayContext): Promise<void> {
                             };
                             const mimeType = mimeTypes[ext];
                             if (!mimeType) {
-                              await sendErrorMessage(MSG.IMAGE_FORMAT_UNSUPPORTED(ext));
+                              log?.error(`[qqbot:${account.accountId}] Unsupported image format: ${ext}`);
                               return;
                             }
                             imageUrl = `data:${mimeType};base64,${base64Data}`;
@@ -1884,7 +1862,7 @@ export async function startGateway(ctx: GatewayContext): Promise<void> {
                         try {
                           const ttsText = parsedPayload.caption || parsedPayload.path;
                             if (!ttsText?.trim()) {
-                              await sendErrorMessage(MSG.VOICE_MISSING_TEXT);
+                              log?.error(`[qqbot:${account.accountId}] Voice missing text`);
                             } else {
                               const ttsCfg = resolveTTSConfig(cfg as Record<string, unknown>);
                               if (!ttsCfg) {
@@ -1901,7 +1879,8 @@ export async function startGateway(ctx: GatewayContext): Promise<void> {
                                 } else if (event.type === "group" && event.groupOpenid) {
                                   await sendGroupVoiceMessage(token, event.groupOpenid, silkBase64, event.messageId);
                                 } else if (event.channelId) {
-                                  await sendChannelMessage(token, event.channelId, `${MSG.VOICE_CHANNEL_UNSUPPORTED}\n${ttsText}`, event.messageId);
+                                  log?.error(`[qqbot:${account.accountId}] Voice not supported in channel, sending text fallback`);
+                                  await sendChannelMessage(token, event.channelId, ttsText, event.messageId);
                                 }
                               });
                               log?.info(`[qqbot:${account.accountId}] Voice message sent`);
@@ -1915,7 +1894,7 @@ export async function startGateway(ctx: GatewayContext): Promise<void> {
                         try {
                           const videoPath = normalizePath(parsedPayload.path ?? "");
                           if (!videoPath?.trim()) {
-                            await sendErrorMessage(MSG.VIDEO_MISSING_PATH);
+                            log?.error(`[qqbot:${account.accountId}] Video missing path`);
                           } else {
                             const isHttpUrl = videoPath.startsWith("http://") || videoPath.startsWith("https://");
                             log?.info(`[qqbot:${account.accountId}] Video send: "${videoPath.slice(0, 60)}..."`);
@@ -1928,7 +1907,7 @@ export async function startGateway(ctx: GatewayContext): Promise<void> {
                                 } else if (event.type === "group" && event.groupOpenid) {
                                   await sendGroupVideoMessage(token, event.groupOpenid, videoPath, undefined, event.messageId);
                                 } else if (event.channelId) {
-                                  await sendChannelMessage(token, event.channelId, MSG.VIDEO_CHANNEL_UNSUPPORTED, event.messageId);
+                                  log?.error(`[qqbot:${account.accountId}] Video not supported in channel`);
                                 }
                               } else {
                                 // 本地文件：读取为 Base64
@@ -1948,7 +1927,7 @@ export async function startGateway(ctx: GatewayContext): Promise<void> {
                                 } else if (event.type === "group" && event.groupOpenid) {
                                   await sendGroupVideoMessage(token, event.groupOpenid, undefined, videoBase64, event.messageId);
                                 } else if (event.channelId) {
-                                  await sendChannelMessage(token, event.channelId, MSG.VIDEO_CHANNEL_UNSUPPORTED, event.messageId);
+                                  log?.error(`[qqbot:${account.accountId}] Video not supported in channel`);
                                 }
                               }
                             });
@@ -1975,7 +1954,7 @@ export async function startGateway(ctx: GatewayContext): Promise<void> {
                         try {
                           const filePath = normalizePath(parsedPayload.path ?? "");
                           if (!filePath?.trim()) {
-                            await sendErrorMessage(MSG.FILE_MISSING_PATH);
+                            log?.error(`[qqbot:${account.accountId}] File missing path`);
                           } else {
                             const isHttpUrl = filePath.startsWith("http://") || filePath.startsWith("https://");
                             const fileName = sanitizeFileName(path.basename(filePath));
@@ -1988,7 +1967,7 @@ export async function startGateway(ctx: GatewayContext): Promise<void> {
                                 } else if (event.type === "group" && event.groupOpenid) {
                                   await sendGroupFileMessage(token, event.groupOpenid, undefined, filePath, event.messageId, fileName);
                                 } else if (event.channelId) {
-                                  await sendChannelMessage(token, event.channelId, MSG.FILE_CHANNEL_UNSUPPORTED, event.messageId);
+                                  log?.error(`[qqbot:${account.accountId}] File not supported in channel`);
                                 }
                               } else {
                                 if (!(await fileExistsAsync(filePath))) {
@@ -2005,7 +1984,7 @@ export async function startGateway(ctx: GatewayContext): Promise<void> {
                                 } else if (event.type === "group" && event.groupOpenid) {
                                   await sendGroupFileMessage(token, event.groupOpenid, fileBase64, undefined, event.messageId, fileName);
                                 } else if (event.channelId) {
-                                  await sendChannelMessage(token, event.channelId, MSG.FILE_CHANNEL_UNSUPPORTED, event.messageId);
+                                  log?.error(`[qqbot:${account.accountId}] File not supported in channel`);
                                 }
                               }
                             });
@@ -2016,7 +1995,6 @@ export async function startGateway(ctx: GatewayContext): Promise<void> {
                         }
                       } else {
                         log?.error(`[qqbot:${account.accountId}] Unknown media type: ${(parsedPayload as MediaPayload).mediaType}`);
-                        await sendErrorMessage(MSG.UNSUPPORTED_MEDIA_TYPE);
                       }
                       
                       // 记录活动并返回
@@ -2029,7 +2007,6 @@ export async function startGateway(ctx: GatewayContext): Promise<void> {
                     } else {
                       // 未知的载荷类型
                       log?.error(`[qqbot:${account.accountId}] Unknown payload type: ${(parsedPayload as any).type}`);
-                      await sendErrorMessage(MSG.UNSUPPORTED_PAYLOAD_TYPE);
                       return;
                     }
                   }
@@ -2231,20 +2208,23 @@ export async function startGateway(ctx: GatewayContext): Promise<void> {
                   
                   // 🔹 第三步：发送带公网图片的 markdown 消息
                   if (textWithoutImages.trim()) {
-                    try {
-                      await sendWithTokenRetry(async (token) => {
-                        const ref = consumeQuoteRef();
-                        if (event.type === "c2c") {
-                          return await sendC2CMessage(token, event.senderId, textWithoutImages, event.messageId, ref);
-                        } else if (event.type === "group" && event.groupOpenid) {
-                          return await sendGroupMessage(token, event.groupOpenid, textWithoutImages, event.messageId);
-                        } else if (event.channelId) {
-                          return await sendChannelMessage(token, event.channelId, textWithoutImages, event.messageId);
-                        }
-                      });
-                      log?.info(`[qqbot:${account.accountId}] Sent markdown message with ${httpImageUrls.length} HTTP images (${event.type})`);
-                    } catch (err) {
-                      log?.error(`[qqbot:${account.accountId}] Failed to send markdown message: ${err}`);
+                    const mdChunks = chunkText(textWithoutImages, TEXT_CHUNK_LIMIT);
+                    for (const chunk of mdChunks) {
+                      try {
+                        await sendWithTokenRetry(async (token) => {
+                          const ref = consumeQuoteRef();
+                          if (event.type === "c2c") {
+                            return await sendC2CMessage(token, event.senderId, chunk, event.messageId, ref);
+                          } else if (event.type === "group" && event.groupOpenid) {
+                            return await sendGroupMessage(token, event.groupOpenid, chunk, event.messageId);
+                          } else if (event.channelId) {
+                            return await sendChannelMessage(token, event.channelId, chunk, event.messageId);
+                          }
+                        });
+                        log?.info(`[qqbot:${account.accountId}] Sent markdown chunk (${chunk.length}/${textWithoutImages.length} chars) with ${httpImageUrls.length} HTTP images (${event.type})`);
+                      } catch (err) {
+                        log?.error(`[qqbot:${account.accountId}] Failed to send markdown message chunk: ${err}`);
+                      }
                     }
                   }
                 } else {
@@ -2284,19 +2264,22 @@ export async function startGateway(ctx: GatewayContext): Promise<void> {
                       }
                     }
 
-                    // 发送文本消息
+                    // 发送文本消息（分块）
                     if (textWithoutImages.trim()) {
-                      await sendWithTokenRetry(async (token) => {
-                        const ref = consumeQuoteRef();
-                        if (event.type === "c2c") {
-                          return await sendC2CMessage(token, event.senderId, textWithoutImages, event.messageId, ref);
-                        } else if (event.type === "group" && event.groupOpenid) {
-                          return await sendGroupMessage(token, event.groupOpenid, textWithoutImages, event.messageId);
-                        } else if (event.channelId) {
-                          return await sendChannelMessage(token, event.channelId, textWithoutImages, event.messageId);
-                        }
-                      });
-                      log?.info(`[qqbot:${account.accountId}] Sent text reply (${event.type})`);
+                      const plainChunks = chunkText(textWithoutImages, TEXT_CHUNK_LIMIT);
+                      for (const chunk of plainChunks) {
+                        await sendWithTokenRetry(async (token) => {
+                          const ref = consumeQuoteRef();
+                          if (event.type === "c2c") {
+                            return await sendC2CMessage(token, event.senderId, chunk, event.messageId, ref);
+                          } else if (event.type === "group" && event.groupOpenid) {
+                            return await sendGroupMessage(token, event.groupOpenid, chunk, event.messageId);
+                          } else if (event.channelId) {
+                            return await sendChannelMessage(token, event.channelId, chunk, event.messageId);
+                          }
+                        });
+                        log?.info(`[qqbot:${account.accountId}] Sent text chunk (${chunk.length}/${textWithoutImages.length} chars) (${event.type})`);
+                      }
                     }
                   } catch (err) {
                     log?.error(`[qqbot:${account.accountId}] Send failed: ${err}`);
@@ -2379,7 +2362,7 @@ export async function startGateway(ctx: GatewayContext): Promise<void> {
               },
             },
             replyOptions: {
-              disableBlockStreaming: false,
+              disableBlockStreaming: true,
             },
           });
 
@@ -2515,6 +2498,7 @@ export async function startGateway(ctx: GatewayContext): Promise<void> {
                 } // end isFirstReady
               } else if (t === "RESUMED") {
                 log?.info(`[qqbot:${account.accountId}] Session resumed`);
+                onReady?.(d); // 通知框架连接已恢复，避免 health-monitor 误判 disconnected
                 // RESUMED 也属于首次启动（gateway restart 通常走 resume）
                 if (isFirstReadyGlobal) {
                   isFirstReadyGlobal = false;

package/src/outbound.ts

@@ -26,7 +26,6 @@ import { normalizeMediaTags } from "./utils/media-tags.js";
 import { checkFileSize, readFileAsync, fileExistsAsync, isLargeFile, formatFileSize } from "./utils/file-utils.js";
 import { isLocalPath as isLocalFilePath, normalizePath, sanitizeFileName, getQQBotDataDir } from "./utils/platform.js";
 import { downloadFile } from "./image-server.js";
-import { MSG } from "./user-messages.js";
 
 // ============ 消息回复限流器 ============
 // 同一 message_id 1小时内最多回复 4 次，超过 1 小时无法被动回复（需改为主动消息）
@@ -313,7 +312,7 @@ export async function sendPhoto(
 
   if (isLocal) {
     if (!(await fileExistsAsync(mediaPath))) {
-      return { channel: "qqbot", error: "图片不存在或已失效" };
+      return { channel: "qqbot", error: "Image not found" };
     }
     const sizeCheck = checkFileSize(mediaPath);
     if (!sizeCheck.ok) {
@@ -327,7 +326,7 @@ export async function sendPhoto(
     };
     const mimeType = mimeTypes[ext];
     if (!mimeType) {
-      return { channel: "qqbot", error: MSG.IMAGE_FORMAT_UNSUPPORTED(ext) };
+      return { channel: "qqbot", error: `Unsupported image format: ${ext}` };
     }
     imageUrl = `data:${mimeType};base64,${fileBuffer.toString("base64")}`;
     console.log(`${prefix} sendPhoto: local → Base64 (${formatFileSize(fileBuffer.length)})`);
@@ -430,8 +429,8 @@ export async function sendVoice(
           const r = await sendGroupVoiceMessage(token, ctx.targetId, undefined, mediaPath, ctx.replyToId);
           return { channel: "qqbot", messageId: r.id, timestamp: r.timestamp };
         } else {
-          const r = await sendChannelMessage(token, ctx.targetId, MSG.VOICE_CHANNEL_UNSUPPORTED, ctx.replyToId);
-          return { channel: "qqbot", messageId: r.id, timestamp: r.timestamp };
+          console.log(`${prefix} sendVoice: voice not supported in channel`);
+          return { channel: "qqbot", error: "Voice not supported in channel" };
         }
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -464,7 +463,7 @@ async function sendVoiceFromLocal(
   // 等待文件就绪（TTS 异步生成，文件可能还没写完）
   const fileSize = await waitForFile(mediaPath);
   if (fileSize === 0) {
-    return { channel: "qqbot", error: "语音文件未就绪" };
+    return { channel: "qqbot", error: "Voice generate failed" };
   }
 
   // 精细检测：是否需要转码
@@ -498,8 +497,8 @@ async function sendVoiceFromLocal(
       const r = await sendGroupVoiceMessage(token, ctx.targetId, uploadBase64, undefined, ctx.replyToId);
       return { channel: "qqbot", messageId: r.id, timestamp: r.timestamp };
     } else {
-      const r = await sendChannelMessage(token, ctx.targetId, MSG.VOICE_CHANNEL_UNSUPPORTED, ctx.replyToId);
-      return { channel: "qqbot", messageId: r.id, timestamp: r.timestamp };
+      console.log(`${prefix} sendVoice: voice not supported in channel`);
+      return { channel: "qqbot", error: "Voice not supported in channel" };
     }
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -543,8 +542,8 @@ export async function sendVideoMsg(
         const r = await sendGroupVideoMessage(token, ctx.targetId, mediaPath, undefined, ctx.replyToId);
         return { channel: "qqbot", messageId: r.id, timestamp: r.timestamp };
       } else {
-        const r = await sendChannelMessage(token, ctx.targetId, MSG.VIDEO_CHANNEL_UNSUPPORTED, ctx.replyToId);
-        return { channel: "qqbot", messageId: r.id, timestamp: r.timestamp };
+        console.log(`${prefix} sendVideoMsg: video not supported in channel`);
+        return { channel: "qqbot", error: "Video not supported in channel" };
       }
     }
 
@@ -570,7 +569,7 @@ export async function sendVideoMsg(
 /** 从本地文件发送视频（sendVideoMsg 的内部辅助） */
 async function sendVideoFromLocal(ctx: MediaTargetContext, mediaPath: string, prefix: string): Promise<OutboundResult> {
   if (!(await fileExistsAsync(mediaPath))) {
-    return { channel: "qqbot", error: "视频文件不存在或已失效" };
+    return { channel: "qqbot", error: "Video not found" };
   }
   const sizeCheck = checkFileSize(mediaPath);
   if (!sizeCheck.ok) {
@@ -590,8 +589,8 @@ async function sendVideoFromLocal(ctx: MediaTargetContext, mediaPath: string, pr
       const r = await sendGroupVideoMessage(token, ctx.targetId, undefined, videoBase64, ctx.replyToId);
       return { channel: "qqbot", messageId: r.id, timestamp: r.timestamp };
     } else {
-      const r = await sendChannelMessage(token, ctx.targetId, MSG.VIDEO_CHANNEL_UNSUPPORTED, ctx.replyToId);
-      return { channel: "qqbot", messageId: r.id, timestamp: r.timestamp };
+      console.log(`${prefix} sendVideoMsg: video not supported in channel`);
+      return { channel: "qqbot", error: "Video not supported in channel" };
     }
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -636,8 +635,8 @@ export async function sendDocument(
         const r = await sendGroupFileMessage(token, ctx.targetId, undefined, mediaPath, ctx.replyToId, fileName);
         return { channel: "qqbot", messageId: r.id, timestamp: r.timestamp };
       } else {
-        const r = await sendChannelMessage(token, ctx.targetId, MSG.FILE_CHANNEL_UNSUPPORTED, ctx.replyToId);
-        return { channel: "qqbot", messageId: r.id, timestamp: r.timestamp };
+        console.log(`${prefix} sendDocument: file not supported in channel`);
+        return { channel: "qqbot", error: "File not supported in channel" };
       }
     }
 
@@ -665,7 +664,7 @@ async function sendDocumentFromLocal(ctx: MediaTargetContext, mediaPath: string,
   const fileName = sanitizeFileName(path.basename(mediaPath));
 
   if (!(await fileExistsAsync(mediaPath))) {
-    return { channel: "qqbot", error: "文件不存在或已失效" };
+    return { channel: "qqbot", error: "File not found" };
   }
   const sizeCheck = checkFileSize(mediaPath);
   if (!sizeCheck.ok) {
@@ -687,8 +686,8 @@ async function sendDocumentFromLocal(ctx: MediaTargetContext, mediaPath: string,
       const r = await sendGroupFileMessage(token, ctx.targetId, fileBase64, undefined, ctx.replyToId, fileName);
       return { channel: "qqbot", messageId: r.id, timestamp: r.timestamp };
     } else {
-      const r = await sendChannelMessage(token, ctx.targetId, MSG.FILE_CHANNEL_UNSUPPORTED, ctx.replyToId);
-      return { channel: "qqbot", messageId: r.id, timestamp: r.timestamp };
+      console.log(`${prefix} sendDocument: file not supported in channel`);
+      return { channel: "qqbot", error: "File not supported in channel" };
     }
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);

package/src/ref-index-store.ts

@@ -20,7 +20,7 @@ import { getQQBotDataDir } from "./utils/platform.js";
 // ============ 存储的消息摘要 ============
 
 export interface RefIndexEntry {
-  /** 消息文本内容摘要 */
+  /** 消息文本内容（完整保存） */
   content: string;
   /** 发送者 ID */
   senderId: string;
@@ -56,7 +56,6 @@ export interface RefAttachmentSummary {
 
 const STORAGE_DIR = getQQBotDataDir("data");
 const REF_INDEX_FILE = path.join(STORAGE_DIR, "ref-index.jsonl");
-const MAX_CONTENT_LENGTH = 500; // 存储的消息内容最大字符数
 const MAX_ENTRIES = 50000; // 内存中最大缓存条目数
 const TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 天
 const COMPACT_THRESHOLD_RATIO = 2; // 文件行数超过有效条目 N 倍时 compact
@@ -234,7 +233,7 @@ export function setRefIndex(refIdx: string, entry: RefIndexEntry): void {
 
   const now = Date.now();
   store.set(refIdx, {
-    content: entry.content.slice(0, MAX_CONTENT_LENGTH),
+    content: entry.content,
     senderId: entry.senderId,
     senderName: entry.senderName,
     timestamp: entry.timestamp,
@@ -247,7 +246,7 @@ export function setRefIndex(refIdx: string, entry: RefIndexEntry): void {
   appendLine({
     k: refIdx,
     v: {
-      content: entry.content.slice(0, MAX_CONTENT_LENGTH),
+      content: entry.content,
       senderId: entry.senderId,
       senderName: entry.senderName,
       timestamp: entry.timestamp,