@xmanrui/dsh-im 4.38.0 → 4.38.2

package/src/channels/feishu/bridge.mjs

@@ -1,6 +1,7 @@
 import { BusyMessageDispatcher, canAutomaticallySteer } from '../shared/busy-message-dispatcher.mjs';
 import { isPermissionCommand, runPermissionCommand } from '../shared/permission-command.mjs';
 import { randomUUID } from 'node:crypto';
+import { chunkMarkdownText } from '../shared/markdown-chunks.mjs';
 import QRCode from 'qrcode';
 import { waitForFeishuOperation } from './feishu-channel.mjs';
 import {
@@ -209,6 +210,19 @@ const STEP_PUSH_POST_CHUNK_MAX_BYTES = 24_000;
 const STEP_STREAM_PATCH_MIN_INTERVAL_MS = 1_000;
 /** Confirm missed boundaries from history; elapsed time is never completion. */
 const MIRROR_CHECK_MS = 30_000;
+/** Retire orphan snapshots outside Feishu's message update window. */
+const MIRROR_STALE_MS = 14 * 24 * 60 * 60_000;
+const MIRROR_RECOVERY_MAX_FAILURES = 20;
+
+function mirrorErrorText(error) {
+  return [error?.response?.data?.msg, error?.msg, error?.message]
+    .filter((value) => typeof value === 'string' && value.trim()).join('; ') || String(error);
+}
+
+function isExpiredMirrorError(error) {
+  return /Message has expired when updating message|Message can only be updated within fourteen days/i
+    .test(mirrorErrorText(error));
+}
 /** One answer chunk inside the streaming card: small enough that the block
  *  splitter can always distribute blocks across sealed/live cards. */
 const STEP_STREAM_ANSWER_CHUNK_MAX_BYTES = 18_000;
@@ -848,27 +862,48 @@ export class FeishuHarnessBridge {
   }
 
   /** Recover only a known finished turn, using its last successful card JSON. */
-  async #sealOrphanMirrors() {
-    for (const [key, entry] of this.#state.mirrorEntries?.() ?? []) {
-      if (!entry?.chatId || !entry.sessionId || !Number.isSafeInteger(entry.turn)
-        || !Array.isArray(entry.cardIds) || !entry.cardIds.length) continue;
-      await this.#queueEventTask(entry.sessionId, async () => {
+  async #sealOrphanMirrors(onlyKey = null) {
+    for (const [key, queuedEntry] of this.#state.mirrorEntries?.() ?? []) {
+      if (onlyKey !== null && key !== onlyKey) continue;
+      if (!queuedEntry?.sessionId) continue;
+      await this.#queueEventTask(queuedEntry.sessionId, async () => {
         if (this.#signal?.aborted) return;
         // An adopted turn now owns this record and will finish through its queue.
         if (this.#sessionSyncTurns.has(key)) return;
+        // A queued timer must not resurrect a deleted record or overwrite a
+        // newer snapshot/failure count with the entry captured before queuing.
+        let entry = this.#state.mirrorEntries?.().find(([entryKey]) => entryKey === key)?.[1];
+        if (!entry?.chatId || !entry.sessionId || !Number.isSafeInteger(entry.turn)
+          || !Array.isArray(entry.cardIds) || !entry.cardIds.length) return;
+        const now = Date.now();
+        if (!Number.isFinite(entry.claimedAt) || entry.claimedAt <= 0 || entry.claimedAt > now) {
+          entry = { ...entry, claimedAt: now };
+          await this.#state.setMirror?.(key, entry);
+        }
+        if (now - entry.claimedAt >= MIRROR_STALE_MS) {
+          await this.#clearMirrorRecovery(key, 'snapshot expired');
+          return;
+        }
+        const failures = Number.isSafeInteger(entry.recoveryFailures) && entry.recoveryFailures > 0
+          ? entry.recoveryFailures : 0;
+        if (failures >= MIRROR_RECOVERY_MAX_FAILURES) {
+          await this.#clearMirrorRecovery(key, 'recovery failure limit reached');
+          return;
+        }
         try {
           const events = await this.#mirrorHistory(entry.sessionId, entry.turn);
+          if (this.#signal?.aborted) return;
           const outcome = extractCompletedTurnAnswer(events, { turn: entry.turn });
           if (outcome.endSeq < 0) {
-            this.#scheduleMirrorCheck(`recovery\0${key}`, () => this.#sealOrphanMirrors());
+            this.#scheduleMirrorCheck(`recovery\0${key}`, () => this.#sealOrphanMirrors(key));
             return;
           }
           if (this.#restoreMirrorCard(key, entry)) {
             const result = await this.#finishStepCard(key, {
               answerText: outcome.text, stopped: outcome.reason !== 'completed',
             });
-            if (!result?.ok) throw new Error('Recovered mirror could not deliver its final answer');
-            await this.#state.clearMirror?.(key);
+            if (!result?.ok) throw result?.error ?? new Error('Recovered mirror could not deliver its final answer');
+            await this.#clearMirrorRecovery(key);
             return;
           }
           const content = JSON.parse(entry.lastContent);
@@ -880,15 +915,40 @@ export class FeishuHarnessBridge {
           else elements.push({ tag: 'markdown', content: status });
           // Earlier chunks are sealed history; update only the live card.
           await this.#patchStepCard(entry.cardIds.at(-1), JSON.stringify(content));
-          await this.#state.clearMirror?.(key);
+          await this.#clearMirrorRecovery(key);
         } catch (error) {
-          this.#logger.warn?.('[dsh-feishu] mirror recovery failed:', error?.message ?? error);
-          this.#scheduleMirrorCheck(`recovery\0${key}`, () => this.#sealOrphanMirrors());
+          if (this.#signal?.aborted) return;
+          const current = this.#state.mirrorEntries?.().find(([entryKey]) => entryKey === key)?.[1];
+          if (!current) return;
+          if (isExpiredMirrorError(error)) {
+            await this.#clearMirrorRecovery(key, 'message expired');
+            return;
+          }
+          await this.#state.setMirror?.(key, { ...current, recoveryFailures: failures + 1 });
+          if (failures + 1 >= MIRROR_RECOVERY_MAX_FAILURES) {
+            await this.#clearMirrorRecovery(key, 'recovery failure limit reached');
+            return;
+          }
+          this.#logger.warn?.('[dsh-feishu] mirror recovery failed:', mirrorErrorText(error),
+            { sessionId: entry.sessionId, turn: entry.turn, recoveryFailures: failures + 1 });
+          this.#scheduleMirrorCheck(`recovery\0${key}`, () => this.#sealOrphanMirrors(key));
         }
       });
     }
   }
 
+  async #clearMirrorRecovery(key, reason = null) {
+    const timerKey = `recovery\0${key}`;
+    clearTimeout(this.#sessionSyncIdleTimers.get(timerKey));
+    this.#sessionSyncIdleTimers.delete(timerKey);
+    const entry = this.#state.mirrorEntries?.().find(([entryKey]) => entryKey === key)?.[1];
+    await this.#state.clearMirror?.(key);
+    if (reason && entry) {
+      this.#logger.warn?.('[dsh-feishu] mirror recovery stopped:', reason,
+        { sessionId: entry.sessionId, turn: entry.turn, recoveryFailures: entry.recoveryFailures ?? 0 });
+    }
+  }
+
   setGroupResponseMode(value) {
     this.#groupResponseMode = normalizeFeishuGroupResponseMode(value);
   }
@@ -4230,10 +4290,12 @@ export class FeishuHarnessBridge {
     mirror.result = { ok: result?.ok === true, text };
     mirror.finishedAt = Date.now();
     // Keep the last successful snapshot on failure so recovery can preserve it.
-    if (result?.ok) await this.#state.clearMirror?.(mirror.key);
-    else if (recovering) {
+    if (result?.ok) await this.#clearMirrorRecovery(mirror.key);
+    else if (isExpiredMirrorError(result?.error)) {
+      await this.#clearMirrorRecovery(mirror.key, 'message expired');
+    } else if (recovering) {
       this.#sessionSyncTurns.delete(mirror.key);
-      this.#scheduleMirrorCheck(`recovery\0${mirror.key}`, () => this.#sealOrphanMirrors());
+      this.#scheduleMirrorCheck(`recovery\0${mirror.key}`, () => this.#sealOrphanMirrors(mirror.key));
     }
     return result?.ok === true;
   }
@@ -4790,7 +4852,13 @@ export class FeishuHarnessBridge {
 
   /** Replace the draft interval with `text` chunked into splitter-safe blocks. */
   #writeStepCardAnswer(card, text) {
-    const blocks = splitStepPostMarkdown(text, STEP_STREAM_ANSWER_CHUNK_MAX_BYTES)
+    // JSON can expand one UTF-16 unit to six bytes (for example a control
+    // character). Leave room for the element wrapper, and let the existing
+    // Markdown splitter reopen fences in each independently rendered block.
+    const chunks = Buffer.byteLength(JSON.stringify(text), 'utf8') + 128 <= STEP_STREAM_ANSWER_CHUNK_MAX_BYTES
+      ? [text]
+      : chunkMarkdownText(text, Math.floor((STEP_STREAM_ANSWER_CHUNK_MAX_BYTES - 128) / 6));
+    const blocks = chunks
       .map((chunk) => ({ kind: 'message', text: chunk }));
     if (card.answerStart !== null) {
       card.blocks.splice(card.answerStart, card.answerEnd - card.answerStart + 1, ...blocks);
@@ -4917,13 +4985,14 @@ export class FeishuHarnessBridge {
       card.lastRenderAt = this.#stepPushClock.now();
     } catch (error) {
       card.broken = true;
+      card.lastError = error;
       this.#logger.warn?.(
         '[dsh-feishu] step streaming card render failed; the turn continues without it:',
-        error?.message ?? String(error),
+        mirrorErrorText(error),
       );
       if (card.deliveryViaOpenId) {
         this.#logger.warn?.('[dsh-feishu] session-sync mirror card render failed:',
-          error?.message ?? String(error),
+          mirrorErrorText(error),
           { sessionId: card.sessionSyncSessionId, turn: card.sessionSyncTurn });
       }
     }
@@ -4933,9 +5002,8 @@ export class FeishuHarnessBridge {
    * Seal the turn's card with a terminal status and the final answer. The
    * streamed answer draft is rewritten in place with the delivery text; when
    * no draft exists the answer is appended. Returns `{ ok, cardIds }` when
-   * the answer is visible on the cards, or null when the caller must fall
-   * back to the post ladder (absent/broken card, or the answer never reached
-   * a successful render). Safe to call twice.
+   * the answer is visible, `{ ok: false, error }` on failure, or null when
+   * no card exists. Callers fall back unless ok is true. Safe to call twice.
    */
   async #finishStepCard(key, { stopped = false, answerText = null } = {}) {
     const card = this.#stepCards.get(key);
@@ -4944,7 +5012,7 @@ export class FeishuHarnessBridge {
     try {
       await card.renderChain?.catch?.(() => {});
     } catch { /* the seal below decides what the user sees */ }
-    if (card.broken) return null;
+    if (card.broken) return { ok: false, error: card.lastError };
     const status = stopped ? 'stopped' : 'completed';
     const body = typeof answerText === 'string' ? answerText : '';
     // Whether the answer was already visible from a streamed draft render —
@@ -4975,10 +5043,10 @@ export class FeishuHarnessBridge {
       }
       this.#logger.warn?.(
         '[dsh-feishu] step streaming card finish failed:',
-        error?.message ?? String(error),
+        mirrorErrorText(error),
         { sessionId: card.sessionSyncSessionId, turn: card.sessionSyncTurn },
       );
-      return null;
+      return { ok: false, error };
     }
   }
 
@@ -5033,7 +5101,10 @@ export class FeishuHarnessBridge {
       data: { content: cardJson },
     }));
     if (response?.code && response.code !== 0) {
-      throw new Error(`Feishu step card patch failed: ${response.msg || response.code}`);
+      const error = new Error(`Feishu step card patch failed: ${response.msg || response.code}`);
+      error.code = response.code;
+      error.feishuCode = response.code;
+      throw error;
     }
   }
 

package/src/channels/matrix/matrix-runtime.mjs

@@ -36,6 +36,7 @@ import {
   extractOutboundMentions,
   hasRoomMention,
 } from './matrix-rich-text.mjs';
+import { chunkMarkdownParts } from '../shared/markdown-chunks.mjs';
 
 const RECONNECT_DELAYS_MS = Object.freeze([1_000, 3_000, 5_000, 10_000, 30_000]);
 const SYNC_LONG_POLL_MS = 30_000;
@@ -917,14 +918,23 @@ export class MatrixRuntime {
       ? target.threadId : null;
     const replyToEventId = typeof target?.replyToEventId === 'string' && isMatrixEventId(target.replyToEventId)
       ? target.replyToEventId : null;
-    const chunks = splitMessageText(text, this.#config.maxMessageLength);
+    const chunks = options.format === 'markdown'
+      ? chunkMarkdownParts(text, this.#config.maxMessageLength)
+      : splitMessageText(text, this.#config.maxMessageLength).map(plain => ({ markdown: plain, plain }));
     const providerMessageIds = [];
     for (const chunk of chunks) {
-      const content = buildMatrixTextContent({
-        text: chunk,
-        mentionUserIds: extractOutboundMentions(chunk),
-        roomMention: this.#config.allowRoomMentions && hasRoomMention(chunk),
-      });
+      let content;
+      try {
+        content = buildMatrixTextContent({
+          text: chunk.markdown,
+          mentionUserIds: extractOutboundMentions(chunk.markdown),
+          roomMention: this.#config.allowRoomMentions && hasRoomMention(chunk.markdown),
+        });
+      } catch {
+        this.#logger.warn?.('[dsh-im:matrix] Rich text could not be prepared; sending plain text');
+        if (!chunk.plain) continue;
+        content = { msgtype: 'm.text', body: chunk.plain };
+      }
       applyMatrixRelations(content, { threadId, replyToEventId });
       const result = await this.#sendRoomEvent(roomId, 'm.room.message', content, {
         ...(options.signal ? { signal: options.signal } : {}),

package/src/channels/qq/markdown-reply.mjs

@@ -4,347 +4,13 @@
 import { t } from '../shared/i18n.mjs';
 import { ApiError } from '@tencent-connect/qqbot-nodejs';
 
-const DEFAULT_CHUNK_LIMIT = 4_500;
-const CODE_FENCE_OPEN = /^( {0,3})(`{3,}|~{3,})(.*)$/;
+import { chunkMarkdownParts } from '../shared/markdown-chunks.mjs';
+export { chunkMarkdownText } from '../shared/markdown-chunks.mjs';
+
 const MARKDOWN_REJECTION_CODES = new Set([40_034_090]);
 const PASSIVE_REPLY_LIMIT = Object.freeze({ c2c: 4, group: 5 });
 const PARTIAL_REPLY_NOTICE = () => t('回答较长，后续内容未能通过 QQ 完整发送，请回复“继续”。');
 
-function safeSliceIndex(value, limit) {
-  let index = Math.min(limit, value.length);
-  const before = value.charCodeAt(index - 1);
-  const after = value.charCodeAt(index);
-  if (before >= 0xD800 && before <= 0xDBFF && after >= 0xDC00 && after <= 0xDFFF) {
-    index -= 1;
-  }
-  return Math.max(1, index);
-}
-
-function openingFence(line) {
-  const normalized = line.endsWith('\r') ? line.slice(0, -1) : line;
-  const match = CODE_FENCE_OPEN.exec(normalized);
-  if (!match) return null;
-  // CommonMark forbids backticks in the info string of a backtick fence.
-  if (match[2][0] === '`' && match[3].includes('`')) return null;
-  return { delimiter: match[2], info: match[3], indent: match[1].length };
-}
-
-function closesFence(line, opening) {
-  const match = /^ {0,3}(`{3,}|~{3,})[ \t]*$/.exec(line);
-  return Boolean(match
-    && match[1][0] === opening.delimiter[0]
-    && match[1].length >= opening.delimiter.length);
-}
-
-function longestLeadingRun(text, character) {
-  let longest = 0;
-  for (const line of text.split('\n')) {
-    let offset = 0;
-    while (offset < 3 && line[offset] === ' ') offset += 1;
-    let length = 0;
-    while (line[offset + length] === character) length += 1;
-    longest = Math.max(longest, length);
-  }
-  return longest;
-}
-
-function safeCodeFence(text, info) {
-  const backticks = '`'.repeat(Math.max(3, longestLeadingRun(text, '`') + 1));
-  const tildes = '~'.repeat(Math.max(3, longestLeadingRun(text, '~') + 1));
-  if (info.includes('`')) return tildes;
-  return backticks.length <= tildes.length ? backticks : tildes;
-}
-
-function removeFenceIndent(line, indent) {
-  let index = 0;
-  let column = 0;
-  let remaining = indent;
-  while (remaining > 0 && index < line.length) {
-    if (line[index] === ' ') {
-      index += 1;
-      column += 1;
-      remaining -= 1;
-      continue;
-    }
-    if (line[index] === '\t') {
-      const width = 4 - (column % 4);
-      if (width <= remaining) {
-        index += 1;
-        column += width;
-        remaining -= width;
-        continue;
-      }
-      return `${' '.repeat(width - remaining)}${line.slice(index + 1)}`;
-    }
-    break;
-  }
-  return line.slice(index);
-}
-
-function normalizeFencedContent(lines, indent) {
-  return indent === 0 ? lines : lines.map((line) => removeFenceIndent(line, indent));
-}
-
-function splitRawText(text, limit) {
-  if (text.length <= limit) return [text];
-  const parts = [];
-  let remaining = text;
-  while (remaining.length > limit) {
-    let index = safeSliceIndex(remaining, limit);
-    const newline = remaining.lastIndexOf('\n', index - 1);
-    if (newline >= 0) index = newline + 1;
-    parts.push(remaining.slice(0, index));
-    remaining = remaining.slice(index);
-  }
-  if (remaining || parts.length === 0) parts.push(remaining);
-  return parts;
-}
-
-function splitAsFencedCode(text, info, limit) {
-  if (limit < 8) return splitRawText(text, limit).map((part) => ({
-    markdown: part,
-    plain: part,
-  }));
-  const delimiter = safeCodeFence(text, info);
-  let opening = `${delimiter}${info}`;
-  if (opening.length + delimiter.length + 2 >= limit) opening = delimiter;
-  const payloadLimit = limit - opening.length - delimiter.length - 2;
-  if (payloadLimit < 1) return splitRawText(text, limit).map((part) => ({
-    markdown: part,
-    plain: part,
-  }));
-  return splitRawText(text, payloadLimit).map((part) => (
-    {
-      markdown: `${opening}\n${part}${part.endsWith('\n') ? '' : '\n'}${delimiter}`,
-      plain: part,
-    }
-  ));
-}
-
-function hasClosingBacktickRun(text, start, length) {
-  for (let index = start; index < text.length;) {
-    if (text[index] !== '`') {
-      index += 1;
-      continue;
-    }
-    let end = index + 1;
-    while (text[end] === '`') end += 1;
-    if (end - index === length) return true;
-    index = end;
-  }
-  return false;
-}
-
-function gfmTableCells(line) {
-  const normalized = line.endsWith('\r') ? line.slice(0, -1) : line;
-  if (normalized.startsWith('    ') || normalized.startsWith('\t')) return null;
-  const text = normalized.trim();
-  if (!text) return null;
-
-  const cells = [];
-  let cell = '';
-  let separators = 0;
-  let codeRun = 0;
-  for (let index = 0; index < text.length;) {
-    const character = text[index];
-    if (character === '\\' && index + 1 < text.length) {
-      cell += text.slice(index, index + 2);
-      index += 2;
-      continue;
-    }
-    if (character === '`') {
-      let end = index + 1;
-      while (text[end] === '`') end += 1;
-      const length = end - index;
-      if (codeRun === length) {
-        codeRun = 0;
-      } else if (codeRun === 0 && hasClosingBacktickRun(text, end, length)) {
-        codeRun = length;
-      }
-      cell += text.slice(index, end);
-      index = end;
-      continue;
-    }
-    if (character === '|' && codeRun === 0) {
-      cells.push(cell);
-      cell = '';
-      separators += 1;
-      index += 1;
-      continue;
-    }
-    cell += character;
-    index += 1;
-  }
-  if (separators === 0) return null;
-  cells.push(cell);
-  if (cells[0].trim() === '') cells.shift();
-  if (cells.at(-1)?.trim() === '') cells.pop();
-  return cells.length > 0 ? cells : null;
-}
-
-function gfmTableStart(lines, index) {
-  const headerCells = gfmTableCells(lines[index]);
-  const separatorCells = gfmTableCells(lines[index + 1] ?? '');
-  if (!headerCells || !separatorCells || headerCells.length !== separatorCells.length) return null;
-  if (!separatorCells.every((cell) => /^\s*:?-+:?\s*$/.test(cell))) return null;
-  return { headerCells };
-}
-
-function supportedTableBodyCells(line) {
-  const normalized = line.endsWith('\r') ? line.slice(0, -1) : line;
-  const content = normalized.replace(/^ {0,3}/, '');
-  if (openingFence(normalized)
-    || /^(?:#{1,6}(?:[ \t]+|$)|>|(?:[-+*]|\d{1,9}[.)])[ \t]+)/.test(content)) {
-    return null;
-  }
-  return gfmTableCells(normalized);
-}
-
-function splitOversizedTable(lines, limit) {
-  const source = lines.join('\n');
-  if (lines.length < 2 || !gfmTableStart(lines, 0)) {
-    return splitAsFencedCode(source, 'text', limit);
-  }
-  const prefix = `${lines[0]}\n${lines[1]}`;
-  const rows = lines.slice(2);
-  if (prefix.length > limit
-    || rows.some((row) => `${prefix}\n${row}`.length > limit)) {
-    return splitAsFencedCode(source, 'text', limit);
-  }
-  const chunks = [];
-  let current = prefix;
-  let currentRows = [];
-  for (const row of rows) {
-    const candidate = `${current}\n${row}`;
-    if (candidate.length > limit) {
-      chunks.push({
-        markdown: current,
-        plain: chunks.length === 0 ? current : currentRows.join('\n'),
-      });
-      current = `${prefix}\n${row}`;
-      currentRows = [row];
-    } else {
-      current = candidate;
-      currentRows.push(row);
-    }
-  }
-  chunks.push({
-    markdown: current,
-    plain: chunks.length === 0 ? current : currentRows.join('\n'),
-  });
-  return chunks;
-}
-
-/**
- * 按换行边界切分 Markdown 文本：
- * - 可容纳的代码块和可识别的 GFM pipe table 保持完整；
- * - 超长代码块会补齐围栏，超长表格会为每段重复表头；
- * - 超长行在 limit 处硬切，避免单行超限无法投递。
- */
-function chunkMarkdownParts(text, limit = DEFAULT_CHUNK_LIMIT) {
-  const value = typeof text === 'string' ? text : '';
-  const bound = Number.isInteger(limit) && limit > 0 ? limit : DEFAULT_CHUNK_LIMIT;
-  if (value.length <= bound) return value ? [{ markdown: value, plain: value }] : [];
-
-  // Once splitting is required, normalize line endings so a chunk never ends
-  // with a dangling CR whose paired LF moved to the next QQ message.
-  const lines = value.replace(/\r\n?/g, '\n').split('\n');
-  const chunks = [];
-  let current = null;
-
-  const flushCurrent = () => {
-    if (current === null) return;
-    if (current.length > 0) chunks.push({ markdown: current, plain: current });
-    current = null;
-  };
-
-  const appendBlock = (block) => {
-    if (block.length <= bound) {
-      if (current === null) {
-        current = block;
-        return;
-      }
-      const candidate = `${current}\n${block}`;
-      if (candidate.length > bound) {
-        if (current.length > 0) chunks.push({ markdown: current, plain: current });
-        current = block;
-      } else {
-        current = candidate;
-      }
-      return;
-    }
-    // 超大块：收束当前块后按 bound 硬切，保证每块可投递。
-    flushCurrent();
-    let remaining = block;
-    while (remaining.length > bound) {
-      const index = safeSliceIndex(remaining, bound);
-      const part = remaining.slice(0, index);
-      chunks.push({ markdown: part, plain: part });
-      remaining = remaining.slice(index);
-    }
-    current = remaining;
-  };
-
-  const appendLine = (line) => {
-    let remaining = line;
-    // 超长行先硬切，保证每块不超过 bound。
-    while (remaining.length > bound) {
-      flushCurrent();
-      const index = safeSliceIndex(remaining, bound);
-      const part = remaining.slice(0, index);
-      chunks.push({ markdown: part, plain: part });
-      remaining = remaining.slice(index);
-    }
-    appendBlock(remaining);
-  };
-
-  for (let index = 0; index < lines.length;) {
-    const fence = openingFence(lines[index]);
-    if (fence) {
-      flushCurrent();
-      let end = index + 1;
-      while (end < lines.length && !closesFence(lines[end], fence)) end += 1;
-      const hasClosingFence = end < lines.length;
-      const blockLines = lines.slice(index, hasClosingFence ? end + 1 : lines.length);
-      const block = blockLines.join('\n');
-      if (block.length <= bound) {
-        appendBlock(block);
-      } else {
-        const contentLines = blockLines.slice(1, hasClosingFence ? -1 : undefined);
-        const content = normalizeFencedContent(contentLines, fence.indent).join('\n');
-        chunks.push(...splitAsFencedCode(content, fence.info, bound));
-      }
-      index = hasClosingFence ? end + 1 : lines.length;
-      continue;
-    }
-
-    if (gfmTableStart(lines, index)) {
-      let end = index + 2;
-      while (end < lines.length && supportedTableBodyCells(lines[end])) end += 1;
-      const tableLines = lines.slice(index, end);
-      const table = tableLines.join('\n');
-      if (table.length <= bound) {
-        appendBlock(table);
-      } else {
-        flushCurrent();
-        chunks.push(...splitOversizedTable(tableLines, bound));
-      }
-      index = end;
-      continue;
-    }
-
-    appendLine(lines[index]);
-    index += 1;
-  }
-
-  flushCurrent();
-  return chunks.filter(({ markdown, plain }) => markdown.length > 0 || plain.length > 0);
-}
-
-export function chunkMarkdownText(text, limit = DEFAULT_CHUNK_LIMIT) {
-  return chunkMarkdownParts(text, limit).map(({ markdown }) => markdown);
-}
-
 function nextMsgSeq() {
   // 与 SDK getNextMsgSeq 相同的 16-bit 随机 seed；同批分片在 seed 上递增，
   // 保证同一个被动回复 msg_id 内不发生随机碰撞。
@@ -376,7 +42,7 @@ function sendPlainText(bot, target, content, msgSeq) {
  * 以 markdown（msg_type=2）发送回复；单条被平台拒绝时回退纯文本（msg_type=0）。
  * 返回每条消息的平台响应，供调用方提取 provider message ids。
  */
-export async function sendMarkdownReply(bot, target, text, { logger } = {}) {
+export async function sendMarkdownReply(bot, target, text, { logger, signal, requireComplete = false } = {}) {
   const chunks = chunkMarkdownParts(text);
   const results = [];
   const firstMsgSeq = nextMsgSeq();
@@ -404,6 +70,7 @@ export async function sendMarkdownReply(bot, target, text, { logger } = {}) {
   };
 
   for (const [index, chunk] of chunks.entries()) {
+    signal?.throwIfAborted();
     const msgSeq = (firstMsgSeq + index) & 0xFFFF;
     const deliveryTarget = overflow && index >= passiveContentCount
       ? proactiveTarget
@@ -423,7 +90,7 @@ export async function sendMarkdownReply(bot, target, text, { logger } = {}) {
             '[dsh-im:qq] markdown delivery outcome is uncertain; refusing a duplicate-prone retry:',
             error,
           );
-          if (results.length === 0) throw error;
+          if (requireComplete || results.length === 0) throw error;
           await sendPartialNotice();
           break;
         }
@@ -437,7 +104,7 @@ export async function sendMarkdownReply(bot, target, text, { logger } = {}) {
     try {
       results.push(await sendPlainText(bot, deliveryTarget, chunk.plain, msgSeq));
     } catch (error) {
-      if (results.length === 0) throw error;
+      if (requireComplete || results.length === 0) throw error;
       await sendPartialNotice();
       break;
     }

package/src/channels/qq/qq-runtime.mjs

@@ -9,6 +9,7 @@ import { t } from '../shared/i18n.mjs';
 import { evaluateInboundAccess } from '../shared/inbound-access.mjs';
 import { createQqBridgeStatus, QqHarnessBridge } from './qq-bridge.mjs';
 import { isQqMessageAddressed, normalizeQqMentions } from './qq-mention.mjs';
+import { sendMarkdownReply } from './markdown-reply.mjs';
 
 function timeoutError() {
   const error = new Error('QQ WebSocket did not become ready in time');
@@ -114,7 +115,7 @@ export class QqRuntime {
     }, options);
   }
 
-  async sendProactiveText(target, text, { signal } = {}) {
+  async sendProactiveText(target, text, { signal, format = 'plain' } = {}) {
     const nativeId = target?.kind === 'user'
       ? (typeof target?.route?.userOpenId === 'string' ? target.route.userOpenId.trim() : '')
       : target?.kind === 'group'
@@ -131,10 +132,17 @@ export class QqRuntime {
       throw error;
     }
     signal?.throwIfAborted();
-    return this.#bot.sendText({
+    const replyTarget = {
       scope: target.kind === 'user' ? 'c2c' : 'group',
       targetId: nativeId,
-    }, text);
+    };
+    if (format === 'markdown') {
+      await sendMarkdownReply(this.#bot, replyTarget, text, {
+        logger: this.#logger, signal, requireComplete: true,
+      });
+      return { sent: true };
+    }
+    return this.#bot.sendText(replyTarget, text);
   }
 
   async start() {