@xmanrui/dsh-im 4.37.0 → 4.38.1

package/src/channels/shared/markdown-chunks.mjs

@@ -0,0 +1,338 @@
+// Structure-aware Markdown chunks reused by outbound channel renderers.
+const DEFAULT_CHUNK_LIMIT = 4_500;
+const CODE_FENCE_OPEN = /^( {0,3})(`{3,}|~{3,})(.*)$/;
+
+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 处硬切，避免单行超限无法投递。
+ */
+export 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);
+}

package/src/channels/shared/message-failure.mjs

@@ -128,7 +128,7 @@ function failureCode(error) {
     'harness-loopback-forbidden', 'harness-host-untrusted',
     'harness-request-forbidden',
   ].includes(code)) return 'HARNESS_ACCESS';
-  if (['harness-api-not-found', 'harness-response-invalid'].includes(code)) {
+  if (['harness-api-not-found', 'harness-response-invalid', 'gateway/input-invalid'].includes(code)) {
     return 'HARNESS_PROTOCOL';
   }
   if (code === 'harness-turn-failed') return 'INTERNAL_UNKNOWN';

package/src/channels/shared/text-harness-bridge.mjs

@@ -649,8 +649,11 @@ export class TextHarnessBridge {
     });
   }
 
-  sendProactiveText(target, text, { signal } = {}) {
+  sendProactiveText(target, text, { signal, format = 'plain' } = {}) {
     signal?.throwIfAborted();
+    if (format === 'markdown' && typeof this.#bot.sendDelivery === 'function') {
+      return this.#bot.sendDelivery(target, createTextDeliveryBlock(text, format));
+    }
     return this.#bot.sendText(target, text);
   }
 

package/src/channels/slack/slack-api.mjs

@@ -271,13 +271,14 @@ export class SlackApi {
       : null;
   }
 
-  postMessage({ channelId, text, threadTs, signal }) {
+  postMessage({ channelId, text, threadTs, signal, format = 'plain' }) {
     return this.#request('chat.postMessage', {
       tokenKind: 'bot',
       signal,
       body: {
         channel: slackId(channelId, 'channel id'),
         text: safeOutgoingText(text),
+        ...(format === 'markdown' ? { blocks: [{ type: 'markdown', text: safeOutgoingText(text) }] } : {}),
         ...(threadTs ? { thread_ts: cleanString(threadTs) } : {}),
         mrkdwn: true,
         link_names: false,

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

@@ -1,5 +1,7 @@
 import { extractConnectionEvidence, createConnectionDiagnostics, atConnectionStage } from '../shared/connection-error.mjs';
 import { splitMessageText } from '../shared/editable-message-stream.mjs';
+import { chunkMarkdownParts } from '../shared/markdown-chunks.mjs';
+import { createTextDeliveryBlock } from '../shared/semantic/delivery.mjs';
 import { t } from '../shared/i18n.mjs';
 import { SlackApi } from './slack-api.mjs';
 import { createSlackBridgeStatus, SlackHarnessBridge } from './slack-bridge.mjs';
@@ -350,6 +352,34 @@ export class SlackBotClient {
     return { providerMessageIds };
   }
 
+  async sendDelivery(target, value) {
+    const block = createTextDeliveryBlock(value);
+    if (block.format === 'plain') return this.sendText(target, block.text);
+    const providerMessageIds = [];
+    // Standard Markdown blocks have a 12,000-character payload limit.
+    for (const chunk of chunkMarkdownParts(block.text, SLACK_STREAM_CHUNK_LIMIT)) {
+      this.#signal?.throwIfAborted();
+      try {
+        const result = await this.#api.postMessage({
+          channelId: target.channelId, threadTs: target.threadTs,
+          text: chunk.markdown, format: 'markdown', signal: this.#signal,
+        });
+        if (typeof result?.ts === 'string' && result.ts) providerMessageIds.push(result.ts);
+      } catch (error) {
+        // Retry only a definite formatting rejection, never an ambiguous send.
+        if (this.#signal?.aborted || Number(error?.status) >= 500
+          || !['invalid_blocks', 'invalid_blocks_format', 'invalid_markdown']
+            .includes(error?.providerCode)) throw error;
+        this.#logger?.warn?.('[dsh-im:slack] Markdown rejected; sending this chunk as text');
+        if (chunk.plain) {
+          const result = await this.sendText(target, chunk.plain);
+          providerMessageIds.push(...result.providerMessageIds);
+        }
+      }
+    }
+    return { providerMessageIds };
+  }
+
   async addReaction(target, emoji, { signal } = {}) {
     const reactionKey = String(emoji ?? '').trim();
     await this.#api.addReaction({

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

@@ -761,6 +761,7 @@ export class TelegramBotClient {
     try {
       chunks = splitTelegramRichMarkdown(block.text);
     } catch {
+      this.#logger.warn?.('[dsh-im:telegram] Rich Markdown could not be prepared; sending plain text');
       return this.#sendPlain(target, block.text);
     }
     const providerMessageIds = [];

package/src/channels/wecom/wecom-bridge.mjs

@@ -21,6 +21,7 @@ import {
   isBatchInputCommand,
 } from '../shared/batch-input.mjs';
 import { runCompactCommand } from '../shared/compact-command.mjs';
+import { isSharedLocalCommand } from '../shared/command-permission.mjs';
 import { isClearCommand, runClearCommand } from '../shared/clear-command.mjs';
 import { isHistoryCommand, runHistoryCommand } from '../shared/history-command.mjs';
 import {
@@ -154,10 +155,9 @@ function messageText(frame) {
     : text;
 }
 
-function imageContents(frame) {
-  const body = bodyOf(frame);
-  if (body.msgtype === 'image') return [body.image];
-  if (body.msgtype !== 'mixed' || !Array.isArray(body.mixed?.msg_item)) return [];
+function imageContents(body) {
+  if (body?.msgtype === 'image') return [body.image];
+  if (body?.msgtype !== 'mixed' || !Array.isArray(body.mixed?.msg_item)) return [];
   return body.mixed.msg_item
     .filter((item) => item?.msgtype === 'image')
     .map((item) => item.image);
@@ -259,7 +259,7 @@ export function wecomInboundMessage(frame, client) {
   const replyTo = replyReferenceForBody(body);
   return {
     content: messageText(frame),
-    images: imageContents(frame).map((image) => imageSource(client, image)).filter(Boolean),
+    images: imageContents(body).map((image) => imageSource(client, image)).filter(Boolean),
     files: fileContents(frame).map((file) => fileSource(client, file)).filter(Boolean),
     ...(replyTo ? { replyTo } : {}),
   };
@@ -337,6 +337,25 @@ function imageQueueFullMessage(message) {
   };
 }
 
+function quotedImageGuidance(message) {
+  const lines = [];
+  const directCount = message.images.length;
+  const quotedCount = message.quotedImages?.length ?? 0;
+  if (quotedCount > 0) {
+    if (directCount > 0) lines.push(t('图片 {indexes} 来自当前消息。', {
+      indexes: Array.from({ length: directCount }, (_, index) => index + 1).join(', '),
+    }));
+    lines.push(t('图片 {indexes} 来自被引用消息。图片序号与本轮附件清单一致。', {
+      indexes: Array.from({ length: quotedCount }, (_, index) => directCount + index + 1).join(', '),
+    }));
+  }
+  if (message.missingQuotedImageCount > 0) lines.push(t(
+    '有 {count} 张引用图片未提供可下载资源，未附上这些图片；需要看图时请用户重新发送。',
+    { count: message.missingQuotedImageCount },
+  ));
+  return lines.join('\n');
+}
+
 function interactionReplyText(frame) {
   return bodyOf(frame).msgtype === 'text' ? messageText(frame) : '';
 }
@@ -1082,19 +1101,33 @@ export class WecomHarnessBridge {
     // may legally stay queued longer. Start the authenticated SDK download as
     // soon as the validated callback is accepted, then consume it in order.
     const inboundMessage = wecomInboundMessage(frame, this.#client);
-    const imageCount = inboundMessage.images.length;
+    const directCount = inboundMessage.images.length;
+    const quoteContents = isSharedLocalCommand(inboundMessage.content, {
+      hasImages: hasInboundImages(inboundMessage),
+      hasFiles: hasInboundFiles(inboundMessage),
+    }) ? [] : imageContents(bodyOf(frame).quote);
+    const quotedImages = quoteContents.map((image) => imageSource(this.#client, image)).filter(Boolean);
+    const combinedMessage = { ...inboundMessage, images: [...inboundMessage.images, ...quotedImages] };
+    const imageCount = combinedMessage.images.length;
     let reservedImages = 0;
-    let preparedMessage = inboundMessage;
+    let preparedMessage = combinedMessage;
     if (imageCount > 0) {
       if (this.#prefetchedImageCount + imageCount <= MAX_PREFETCHED_IMAGES) {
         reservedImages = imageCount;
         this.#prefetchedImageCount += reservedImages;
-        preparedMessage = prefetchInboundImages(inboundMessage, this.#signal,
+        preparedMessage = prefetchInboundImages(combinedMessage, this.#signal,
           this.#harness.getImageInputLimits?.() ?? imageInputLimits());
       } else {
-        preparedMessage = imageQueueFullMessage(inboundMessage);
+        preparedMessage = imageQueueFullMessage(combinedMessage);
       }
     }
+    // Keep quoted media separate until local command and interaction routing is done.
+    preparedMessage = {
+      ...preparedMessage,
+      images: preparedMessage.images.slice(0, directCount),
+      quotedImages: preparedMessage.images.slice(directCount),
+      missingQuotedImageCount: quoteContents.length - quotedImages.length,
+    };
     preparedMessage = prefetchInboundFiles(preparedMessage, this.#signal);
     const previous = this.#queues.get(key) ?? Promise.resolve();
     const current = previous
@@ -1390,6 +1423,8 @@ export class WecomHarnessBridge {
       let content = hasImages || hasReply
         ? await promptContentForInboundMessage(message, { signal: this.#signal, deferImages: true })
         : undefined;
+      const imageGuidance = quotedImageGuidance(message);
+      if (imageGuidance) content.push({ type: 'text', text: imageGuidance });
       const snapshot = this.#acceptedMessageIds.get(messageId);
       let contextEnhanced = false;
       if (snapshot) {
@@ -1440,7 +1475,7 @@ export class WecomHarnessBridge {
           }),
           onInteractionResolved: (resolution) => this.#handleInteractionResolved(resolution),
           files: message.files,
-          images: message.images,
+          images: [...message.images, ...(message.quotedImages ?? [])],
         },
       });
       if (batchSubmission) {

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

@@ -4,6 +4,7 @@ import { WSAuthFailureError, WSClient, WSReconnectExhaustedError } from '@wecom/
 import { createWecomBridgeStatus, WecomHarnessBridge } from './wecom-bridge.mjs';
 import { sendRememberedConnectionTest } from '../shared/connection-test.mjs';
 import { t } from '../shared/i18n.mjs';
+import { chunkMarkdownText } from '../shared/markdown-chunks.mjs';
 
 function timeoutError() {
   const error = new Error('Enterprise WeChat WebSocket authentication timed out');
@@ -240,7 +241,7 @@ export class WecomRuntime {
     }, options);
   }
 
-  async sendProactiveText(target, text, { signal } = {}) {
+  async sendProactiveText(target, text, { signal, format = 'plain' } = {}) {
     const chatId = typeof target?.route?.chatId === 'string'
       ? target.route.chatId.trim() : '';
     if ((target?.kind !== 'user' && target?.kind !== 'group') || !chatId) {
@@ -254,10 +255,15 @@ export class WecomRuntime {
       throw error;
     }
     signal?.throwIfAborted();
-    await this.#client.sendMessage(chatId, {
-      msgtype: 'markdown',
-      markdown: { content: text },
-    });
+    // At most three UTF-8 bytes per UTF-16 unit: stay within the existing
+    // bridge's 18,000-byte budget while keeping Markdown structures intact.
+    const chunks = format === 'markdown' ? chunkMarkdownText(text, 6_000) : [text];
+    for (const content of chunks) {
+      signal?.throwIfAborted();
+      await this.#client.sendMessage(chatId, {
+        msgtype: 'markdown', markdown: { content },
+      });
+    }
     return { sent: true };
   }
 

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

@@ -1,5 +1,6 @@
 import { createWeixinDiagnostics } from './connection-error.mjs';
-import { DEFAULT_WEIXIN_MAX_MESSAGE_CHARS, WeixinApiError, rejectedProviderResponse } from './weixin-api.mjs';
+import { DEFAULT_WEIXIN_MAX_MESSAGE_CHARS, WeixinApiError, rejectedProviderResponse, splitWeixinText } from './weixin-api.mjs';
+import { chunkMarkdownText } from '../shared/markdown-chunks.mjs';
 import {
   createWeixinBridgeStatus, WeixinHarnessBridge, weixinSendError, weixinSendFailureOptions,
 } from './weixin-bridge.mjs';
@@ -350,7 +351,7 @@ export class WeixinRuntime {
     return { sent: true };
   }
 
-  async #sendTrackedText({ toUserId, text, signal }) {
+  async #sendTrackedText({ toUserId, text, signal, fullText = text, chunkIndex = 0, chunkCount = 1 }) {
     const sentAt = Date.now();
     const contextToken = this.#state.contextTokenFor?.(toUserId);
     let result;
@@ -366,7 +367,7 @@ export class WeixinRuntime {
     } catch (cause) {
       if (signal?.aborted) throw cause;
       const error = weixinSendError(cause, {
-        baseUrl: this.#config.baseUrl, text, chunk: text, chunkIndex: 0, chunkCount: 1,
+        baseUrl: this.#config.baseUrl, text: fullText, chunk: text, chunkIndex, chunkCount,
         maxMessageChars: this.#maxMessageChars, contextToken,
       });
       const failure = setLastMessageFailure(this.#status,
@@ -402,7 +403,7 @@ export class WeixinRuntime {
     }, options);
   }
 
-  async sendProactiveText(target, text, { signal } = {}) {
+  async sendProactiveText(target, text, { signal, format = 'plain' } = {}) {
     const toUserId = typeof target?.route?.toUserId === 'string'
       ? target.route.toUserId.trim() : '';
     if (target?.kind !== 'user' || !toUserId) {
@@ -415,12 +416,18 @@ export class WeixinRuntime {
       error.code = 'bot-not-connected';
       throw error;
     }
-    signal?.throwIfAborted();
-    await this.#sendTrackedText({
-      toUserId,
-      text,
-      signal: signal ?? this.#abortController.signal,
-    });
+    const sendSignal = signal ?? this.#abortController.signal;
+    sendSignal.throwIfAborted();
+    const chunks = format === 'markdown'
+      ? chunkMarkdownText(text, this.#maxMessageChars)
+      : splitWeixinText(text, this.#maxMessageChars);
+    for (const [chunkIndex, chunk] of chunks.entries()) {
+      sendSignal.throwIfAborted();
+      await this.#sendTrackedText({
+        toUserId, text: chunk, signal: sendSignal,
+        fullText: text, chunkIndex, chunkCount: chunks.length,
+      });
+    }
     return { sent: true };
   }
 }