@xmanrui/dsh-im 4.5.0 → 4.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmanrui/dsh-im",
-  "version": "4.5.0",
+  "version": "4.6.0",
   "description": "把九种 IM 机器人和公网 AI Office 接入本机 DeepSeek Harness。 Connect nine IM channels and a public AI Office to a local DeepSeek Harness.",
   "keywords": [
     "deepseek-harness",

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

@@ -39,7 +39,6 @@ import {
   hasInboundImages,
   imagePromptDiagnostic,
   imagePromptUserMessage,
-  promptContentForMessage,
 } from '../shared/image-prompt.mjs';
 import {
   hasInboundFiles,
@@ -48,10 +47,16 @@ import {
 } from '../shared/inbound-file.mjs';
 import { rememberConnectionTestTarget } from '../shared/connection-test.mjs';
 import { deliverOutboundArtifacts } from '../shared/semantic/artifact-delivery.mjs';
+import {
+  hasReplyReference,
+  promptContentForInboundMessage,
+} from '../shared/semantic/reply-reference.mjs';
 import {
   createDeliveryReceipt,
   providerMessageIdsFor,
 } from '../shared/semantic/delivery.mjs';
+import { recoverAssistantTextByTimestamp } from '../shared/session-reply-recovery.mjs';
+import { DINGTALK_RECENT_OUTBOUND_MATCH_TOLERANCE_MS } from './state-store.mjs';
 import {
   channelDeliveryFailure,
   clearLastMessageFailure,
@@ -185,11 +190,95 @@ function downloadCodeFor(value) {
   return nonEmptyString(value?.downloadCode) ?? nonEmptyString(value?.pictureDownloadCode);
 }
 
+function dingtalkTimestampMs(value) {
+  const number = typeof value === 'string' && value.trim() ? Number(value) : value;
+  if (!Number.isFinite(number) || number < 0) return null;
+  return Math.trunc(number < 10_000_000_000 ? number * 1_000 : number);
+}
+
+function usefulReplyText(value) {
+  const text = nonEmptyString(value);
+  return text && !/^\[interactive card message\]$/iu.test(text) ? text : null;
+}
+
+function dingtalkReplyReference(message, options) {
+  const replyEnvelope = message?.text;
+  if (replyEnvelope?.isReplyMsg !== true) return null;
+  const replied = replyEnvelope?.repliedMsg;
+  if (!replied || typeof replied !== 'object') {
+    return { unavailableReason: 'not-delivered' };
+  }
+
+  const msgtype = nonEmptyString(replied.msgType ?? replied.msgtype)?.toLowerCase() ?? '';
+  const repliedContent = parsedMessageContent({ content: replied.content }) ?? {};
+  const pseudoMessage = {
+    msgtype,
+    text: {
+      content: nonEmptyString(repliedContent.text)
+        ?? (typeof replied.content === 'string' ? replied.content : ''),
+    },
+    content: repliedContent,
+  };
+  const normalized = dingtalkInboundMessage(pseudoMessage, options);
+  let attachments = [];
+  if (msgtype === 'picture') {
+    attachments = [{ kind: 'image' }];
+  } else if (msgtype === 'file') {
+    const name = nonEmptyString(repliedContent.fileName ?? repliedContent.file_name);
+    attachments = [{ kind: 'file', ...(name ? { name } : {}) }];
+  } else if (msgtype === 'richtext') {
+    attachments = richTextEntries(repliedContent)
+      .filter((entry) => String(entry?.type ?? '').toLowerCase() === 'picture')
+      .map(() => ({ kind: 'image' }));
+  } else if (msgtype === 'voice' || msgtype === 'audio') {
+    attachments = [{ kind: 'audio' }];
+  } else if (msgtype === 'video') {
+    attachments = [{ kind: 'video' }];
+  }
+
+  const messageId = nonEmptyString(replied.msgId ?? replied.messageId);
+  const authorId = nonEmptyString(replied.senderId ?? replied.senderStaffId);
+  const authorName = nonEmptyString(replied.senderNick ?? replied.senderName);
+  const content = usefulReplyText(normalized.content)
+    ?? usefulReplyText(repliedContent.text)
+    ?? usefulReplyText(repliedContent.summary)
+    ?? usefulReplyText(repliedContent.title);
+  const processQueryKey = nonEmptyString(
+    message?.originalProcessQueryKey ?? repliedContent.processQueryKey,
+  );
+  const createdAt = dingtalkTimestampMs(replied.createdAt ?? replied.createTime);
+  const load = !content && attachments.length === 0
+    && typeof options?.loadReplyContent === 'function'
+    ? ({ signal } = {}) => options.loadReplyContent({
+        ...(messageId ? { messageId } : {}),
+        ...(processQueryKey ? { processQueryKey } : {}),
+        ...(createdAt === null ? {} : { createdAt }),
+      }, { signal })
+    : null;
+  const supported = [
+    'text', 'picture', 'file', 'richtext', 'voice', 'audio', 'video',
+    'interactivecard', 'chatrecord',
+  ]
+    .includes(msgtype);
+  return {
+    ...(messageId ? { messageId } : {}),
+    ...(authorId ? { authorId } : {}),
+    ...(authorName ? { authorName } : {}),
+    ...(content ? { content } : {}),
+    ...(attachments.length > 0 ? { attachments } : {}),
+    ...(load ? { load } : {}),
+    ...(!content && attachments.length === 0 && !load
+      ? { unavailableReason: supported ? 'not-delivered' : 'unsupported' }
+      : {}),
+  };
+}
+
 /** Normalize DingTalk picture and richText callbacks into lazy image references. */
 export function dingtalkInboundMessage(message, {
   api,
   clientId,
   clientSecret,
+  loadReplyContent,
 } = {}) {
   const msgtype = String(message?.msgtype ?? '').toLowerCase();
   const content = parsedMessageContent(message);
@@ -209,6 +298,12 @@ export function dingtalkInboundMessage(message, {
     }
   }
   const fileCode = msgtype === 'file' ? downloadCodeFor(content) : null;
+  const replyTo = dingtalkReplyReference(message, {
+    api,
+    clientId,
+    clientSecret,
+    loadReplyContent,
+  });
   return {
     content: text,
     images: imageCodes.map((downloadCode, index) => ({
@@ -242,6 +337,7 @@ export function dingtalkInboundMessage(message, {
         });
       },
     }] : [],
+    ...(replyTo ? { replyTo } : {}),
   };
 }
 
@@ -465,11 +561,7 @@ export class DingtalkHarnessBridge {
       // An unsafe reply route must never be able to submit an approval.
     }
     const pending = this.#pendingInteractions.get(key);
-    const promptMessage = dingtalkInboundMessage(message, {
-      api: this.#api,
-      clientId: this.#clientId,
-      clientSecret: this.#clientSecret,
-    });
+    const promptMessage = this.#inboundMessage(message, key);
     const commandText = nonEmptyString(promptMessage.content) ?? '';
     const addressed = String(message.conversationType) !== '2' || message?.isInAtList === true;
     const direct = String(message.conversationType) !== '2';
@@ -533,7 +625,8 @@ export class DingtalkHarnessBridge {
             plainText: Boolean(commandText)
               && String(message?.msgtype).toLowerCase() === 'text'
               && !hasInboundFiles(promptMessage)
-              && !hasInboundImages(promptMessage),
+              && !hasInboundImages(promptMessage)
+              && !hasReplyReference(promptMessage),
           });
       if (result.handled) {
         if (result.kind === 'submit') {
@@ -778,11 +871,7 @@ export class DingtalkHarnessBridge {
     }
     const addressed = String(message.conversationType) !== '2' || message.isInAtList === true;
     const preparedMessage = hasSafeReplyRoute && addressed
-      ? prefetchInboundFiles(dingtalkInboundMessage(message, {
-          api: this.#api,
-          clientId: this.#clientId,
-          clientSecret: this.#clientSecret,
-        }), { signal: this.#signal })
+      ? prefetchInboundFiles(this.#inboundMessage(message, key), { signal: this.#signal })
       : undefined;
     const previous = this.#queues.get(key) ?? Promise.resolve();
     const current = previous
@@ -801,6 +890,50 @@ export class DingtalkHarnessBridge {
     return current;
   }
 
+  #inboundMessage(message, key) {
+    return dingtalkInboundMessage(message, {
+      api: this.#api,
+      clientId: this.#clientId,
+      clientSecret: this.#clientSecret,
+      loadReplyContent: (reference, options) => this.#loadReplyContent(key, reference, options),
+    });
+  }
+
+  async #loadReplyContent(key, reference, { signal } = {}) {
+    const indexed = this.#state.recentOutboundTextFor?.({
+      conversationKey: key,
+      ...reference,
+    });
+    if (indexed) return { content: indexed };
+    const quotedAt = dingtalkTimestampMs(reference?.createdAt);
+    if (quotedAt === null) return { unavailableReason: 'not-delivered' };
+    const sessionId = this.#state.sessionFor(key);
+    const session = typeof sessionId === 'string' && sessionId
+      ? this.#harness.workspaceSession?.(sessionId)
+      : null;
+    const text = await recoverAssistantTextByTimestamp({
+      session,
+      quotedAt,
+      signal,
+      toleranceMs: DINGTALK_RECENT_OUTBOUND_MATCH_TOLERANCE_MS,
+    });
+    if (!text) return { unavailableReason: 'not-delivered' };
+    try {
+      await this.#state.rememberOutboundMessage?.({
+        conversationKey: key,
+        text,
+        sentAt: quotedAt,
+        completedAt: quotedAt,
+        providerMessageIds: [reference?.processQueryKey, reference?.messageId]
+          .map(nonEmptyString)
+          .filter(Boolean),
+      });
+    } catch (error) {
+      this.#logger.warn?.('[dsh-dingtalk] failed to remember a recovered quote:', error);
+    }
+    return { content: text };
+  }
+
   async waitForIdle() {
     await Promise.allSettled([
       ...this.#queues.values(),
@@ -936,20 +1069,18 @@ export class DingtalkHarnessBridge {
       return;
     }
 
-    const promptMessage = preparedMessage ?? dingtalkInboundMessage(message, {
-      api: this.#api,
-      clientId: this.#clientId,
-      clientSecret: this.#clientSecret,
-    });
+    const promptMessage = preparedMessage ?? this.#inboundMessage(message, key);
     const text = promptMessage.content;
     const hasImages = hasInboundImages(promptMessage);
     const hasFiles = hasInboundFiles(promptMessage);
+    const hasReply = hasReplyReference(promptMessage);
     const isPlainText = String(message?.msgtype).toLowerCase() === 'text';
     let cardStream = null;
     let cardStarted = false;
+    let cardStartedAt = null;
     let batchSettled = batchSubmission === null;
     try {
-      if (!text && !hasImages && !hasFiles) {
+      if (!text && !hasImages && !hasFiles && !hasReply) {
         await this.#send(sessionWebhook, t('目前支持文字、图片和文件消息。'), this.#atUsersFor(message));
         return;
       }
@@ -992,8 +1123,8 @@ export class DingtalkHarnessBridge {
         return;
       }
 
-      let content = hasImages
-        ? await promptContentForMessage(promptMessage, { signal: this.#signal })
+      let content = hasImages || hasReply
+        ? await promptContentForInboundMessage(promptMessage, { signal: this.#signal })
         : undefined;
       const snapshot = this.#acceptedMessageIds.get(messageId);
       let contextEnhanced = false;
@@ -1018,7 +1149,9 @@ export class DingtalkHarnessBridge {
           signal: this.#signal,
           logger: this.#logger,
         });
+        const startedAt = Date.now();
         cardStarted = await cardStream.start(t(CARD_INITIAL_TEXT));
+        if (cardStarted) cardStartedAt = startedAt;
       }
       const { answer, artifacts = [] } = await askInWorkspaceSession({
         harness: this.#harness,
@@ -1056,12 +1189,14 @@ export class DingtalkHarnessBridge {
       let textDeliveryError = null;
       let textReceipt = null;
       let streamed = false;
+      const deliveryStartedAt = cardStartedAt ?? Date.now();
       try {
         streamed = cardStarted && await cardStream.finish(answerText);
         if (streamed) {
           textReceipt = createDeliveryReceipt({
             deliveryId: messageId,
             presentation: 'dingtalk-card',
+            providerMessageIds: cardStream.providerMessageIds,
           });
         } else {
           textReceipt = createDeliveryReceipt({
@@ -1070,6 +1205,17 @@ export class DingtalkHarnessBridge {
             providerMessageIds: await this.#send(sessionWebhook, answerText, this.#atUsersFor(message)),
           });
         }
+        try {
+          await this.#state.rememberOutboundMessage?.({
+            conversationKey: key,
+            text: answerText,
+            sentAt: deliveryStartedAt,
+            completedAt: Date.now(),
+            providerMessageIds: providerMessageIdsFor(textReceipt),
+          });
+        } catch (error) {
+          this.#logger.warn?.('[dsh-dingtalk] failed to remember an outbound message:', error);
+        }
       } catch (error) {
         textDeliveryError = channelDeliveryFailure(error);
       }

package/src/channels/dingtalk/dingtalk-card-stream.mjs

@@ -32,7 +32,7 @@ function requiredCredential(value, name) {
  * @param {number} [options.updateIntervalMs=500] Minimum delay between updates.
  * @param {()=>number} [options.clock] Monotonic millisecond clock.
  * @param {{setTimeout: Function, clearTimeout: Function}} [options.timer] Timer implementation.
- * @returns {{start(initialText: string): Promise<boolean>, push(progressText: string): void, finish(finalText: string): Promise<boolean>}}
+ * @returns {{start(initialText: string): Promise<boolean>, push(progressText: string): void, finish(finalText: string): Promise<boolean>, readonly providerMessageIds: string[]}}
  * Card stream controller.
  */
 export function createDingTalkCardStream({
@@ -231,5 +231,12 @@ export function createDingTalkCardStream({
     return finishPromise;
   };
 
-  return Object.freeze({ start, push, finish });
+  return Object.freeze({
+    start,
+    push,
+    finish,
+    get providerMessageIds() {
+      return cardRequest?.cardInstanceId ? [cardRequest.cardInstanceId] : [];
+    },
+  });
 }

package/src/channels/dingtalk/state-store.mjs

@@ -9,8 +9,14 @@ const EMPTY_STATE = Object.freeze({
   sessions: {},
   seenMessageIds: [],
   pendingSenders: {},
+  recentOutboundMessages: [],
 });
 
+export const DINGTALK_RECENT_OUTBOUND_LIMIT = 200;
+export const DINGTALK_RECENT_OUTBOUND_TTL_MS = 30 * 24 * 60 * 60 * 1_000;
+export const DINGTALK_RECENT_OUTBOUND_TEXT_LIMIT = 8_000;
+export const DINGTALK_RECENT_OUTBOUND_MATCH_TOLERANCE_MS = 15_000;
+
 function nonEmptyString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
 }
@@ -19,6 +25,49 @@ function displayName(value) {
   return (nonEmptyString(value) ?? t('钉钉用户')).slice(0, 100);
 }
 
+function timestampMs(value) {
+  const number = typeof value === 'string' && value.trim() ? Number(value) : value;
+  if (!Number.isFinite(number) || number < 0) return null;
+  return Math.trunc(number < 10_000_000_000 ? number * 1_000 : number);
+}
+
+function providerMessageIds(value) {
+  if (!Array.isArray(value)) return [];
+  return [...new Set(value
+    .map((id) => (id === undefined || id === null ? null : nonEmptyString(String(id))))
+    .filter(Boolean))];
+}
+
+function truncateText(value) {
+  const text = nonEmptyString(value);
+  return text ? [...text].slice(0, DINGTALK_RECENT_OUTBOUND_TEXT_LIMIT).join('') : null;
+}
+
+function normalizeRecentOutboundMessage(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const conversationKey = nonEmptyString(value.conversationKey);
+  const text = truncateText(value.text);
+  const sentAt = timestampMs(value.sentAt);
+  const completedAt = timestampMs(value.completedAt) ?? sentAt;
+  if (!conversationKey || !text || sentAt === null || completedAt === null) return null;
+  return {
+    conversationKey,
+    text,
+    sentAt,
+    completedAt: Math.max(sentAt, completedAt),
+    providerMessageIds: providerMessageIds(value.providerMessageIds),
+  };
+}
+
+function recentOutboundMessages(value, now = Date.now()) {
+  if (!Array.isArray(value)) return [];
+  const cutoff = now - DINGTALK_RECENT_OUTBOUND_TTL_MS;
+  return value
+    .map(normalizeRecentOutboundMessage)
+    .filter((entry) => entry && entry.completedAt >= cutoff)
+    .slice(-DINGTALK_RECENT_OUTBOUND_LIMIT);
+}
+
 function normalizePendingSender(value, fallbackRequestId) {
   if (!value || typeof value !== 'object') return null;
   const requestId = nonEmptyString(value.requestId) ?? nonEmptyString(fallbackRequestId);
@@ -69,6 +118,7 @@ function normalizeState(value) {
       ? [...new Set(value.seenMessageIds.map(nonEmptyString).filter(Boolean))].slice(-1_000)
       : [],
     pendingSenders,
+    recentOutboundMessages: recentOutboundMessages(value.recentOutboundMessages),
   };
 }
 
@@ -140,6 +190,54 @@ export class DingtalkStateStore {
     await this.#persist();
   }
 
+  async rememberOutboundMessage({
+    conversationKey,
+    text,
+    sentAt = Date.now(),
+    completedAt = Date.now(),
+    providerMessageIds: messageIds = [],
+  } = {}) {
+    const entry = normalizeRecentOutboundMessage({
+      conversationKey,
+      text,
+      sentAt,
+      completedAt,
+      providerMessageIds: messageIds,
+    });
+    if (!entry) throw new TypeError('Invalid DingTalk outbound message');
+    this.#state.recentOutboundMessages = recentOutboundMessages([
+      ...this.#state.recentOutboundMessages,
+      entry,
+    ]);
+    await this.#persist();
+  }
+
+  recentOutboundTextFor({
+    conversationKey,
+    processQueryKey,
+    messageId,
+    createdAt,
+    now = Date.now(),
+  } = {}) {
+    const key = nonEmptyString(conversationKey);
+    if (!key) return null;
+    const active = recentOutboundMessages(this.#state.recentOutboundMessages, now)
+      .filter((entry) => entry.conversationKey === key);
+    const quotedIds = providerMessageIds([processQueryKey, messageId]);
+    for (const quotedId of quotedIds) {
+      const exact = active.filter((entry) => entry.providerMessageIds.includes(quotedId));
+      if (exact.length === 1) return exact[0].text;
+      if (exact.length > 1) return null;
+    }
+    const quotedAt = timestampMs(createdAt);
+    if (quotedAt === null) return null;
+    const candidates = active.filter((entry) => (
+      quotedAt >= entry.sentAt - DINGTALK_RECENT_OUTBOUND_MATCH_TOLERANCE_MS
+        && quotedAt <= entry.completedAt + DINGTALK_RECENT_OUTBOUND_MATCH_TOLERANCE_MS
+    ));
+    return candidates.length === 1 ? candidates[0].text : null;
+  }
+
   pendingSenders() {
     return Object.values(this.#state.pendingSenders)
       .sort((left, right) => left.requestedAt.localeCompare(right.requestedAt))

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

@@ -134,6 +134,13 @@ export class DiscordApi {
     });
   }
 
+  getMessage({ channelId, messageId, signal } = {}) {
+    return this.#request(
+      `channels/${snowflake(channelId, 'channel id')}/messages/${snowflake(messageId, 'message id')}`,
+      { method: 'GET', signal },
+    );
+  }
+
   startThreadFromMessage({ channelId, messageId, name, signal } = {}) {
     const threadName = cleanString(name);
     if (!threadName || [...threadName].length > 100) {

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

@@ -206,12 +206,101 @@ function discordFileSource(attachment, fetchImpl) {
   };
 }
 
-export function normalizeDiscordMessage(message, botId, { fetchImpl = fetch } = {}) {
+function discordReplyAttachment(attachment) {
+  if (!attachment || typeof attachment !== 'object') return null;
+  const mediaType = typeof attachment.content_type === 'string'
+    ? attachment.content_type.split(';', 1)[0].trim().toLowerCase() : '';
+  const kind = mediaType.startsWith('image/') ? 'image'
+    : mediaType.startsWith('audio/') ? 'audio'
+      : mediaType.startsWith('video/') ? 'video' : 'file';
+  const name = typeof attachment.filename === 'string' && attachment.filename
+    ? attachment.filename : undefined;
+  return { kind, ...(name ? { name } : {}) };
+}
+
+function discordReplySnapshot(message, fallbackMessageId) {
+  if (!message || typeof message !== 'object') return null;
+  const messageId = typeof message.id === 'string' && message.id
+    ? message.id : fallbackMessageId;
+  const authorId = typeof message.author?.id === 'string' && message.author.id
+    ? message.author.id : undefined;
+  const authorName = [message.member?.nick, message.author?.global_name, message.author?.username]
+    .find((value) => typeof value === 'string' && value.trim());
+  const attachments = Array.isArray(message.attachments)
+    ? message.attachments.map(discordReplyAttachment).filter(Boolean)
+    : [];
+  if (Array.isArray(message.sticker_items)) {
+    attachments.push(...message.sticker_items.map((sticker) => ({
+      kind: 'image',
+      ...(typeof sticker?.name === 'string' && sticker.name ? { name: sticker.name } : {}),
+    })));
+  }
+  return {
+    ...(messageId ? { messageId: String(messageId) } : {}),
+    ...(authorId ? { authorId } : {}),
+    ...(authorName ? { authorName } : {}),
+    content: typeof message.content === 'string' ? message.content : '',
+    attachments,
+  };
+}
+
+function discordReplyReference(message, loadReply) {
+  const channelId = String(message?.channel_id ?? '');
+  const referenceId = typeof message?.message_reference?.message_id === 'string'
+    && message.message_reference.message_id
+    ? message.message_reference.message_id : undefined;
+  const referenceChannelId = message?.message_reference?.channel_id;
+  if (referenceChannelId !== undefined && String(referenceChannelId) !== channelId) {
+    return {
+      ...(referenceId ? { messageId: referenceId } : {}),
+      unavailableReason: 'not-found',
+    };
+  }
+  if (Object.hasOwn(message ?? {}, 'referenced_message')) {
+    if (message.referenced_message === null) {
+      return {
+        ...(referenceId ? { messageId: referenceId } : {}),
+        unavailableReason: 'deleted',
+      };
+    }
+    if (message.referenced_message && typeof message.referenced_message === 'object') {
+      const snapshotId = typeof message.referenced_message.id === 'string'
+        && message.referenced_message.id ? message.referenced_message.id : undefined;
+      if (String(message.referenced_message.channel_id ?? '') !== channelId
+        || !snapshotId || (referenceId && snapshotId !== referenceId)) {
+        return {
+          ...(referenceId ? { messageId: referenceId } : {}),
+          unavailableReason: 'not-found',
+        };
+      }
+      return discordReplySnapshot(message.referenced_message, referenceId) ?? undefined;
+    }
+  }
+  if (!referenceId) return undefined;
+  if (typeof loadReply !== 'function') {
+    return { messageId: referenceId, unavailableReason: 'not-delivered' };
+  }
+  return {
+    messageId: referenceId,
+    load: async ({ signal } = {}) => {
+      const referenced = await loadReply({ channelId, messageId: referenceId, signal });
+      if (!referenced || String(referenced.id ?? '') !== referenceId
+        || String(referenced.channel_id ?? '') !== channelId) return null;
+      return discordReplySnapshot(referenced, referenceId);
+    },
+  };
+}
+
+export function normalizeDiscordMessage(message, botId, {
+  fetchImpl = fetch,
+  loadReply,
+} = {}) {
   if (!message?.id || !message?.channel_id || !message?.author?.id
     || Number(message.type) === 21) return null;
   const direct = !message.guild_id;
   const addressed = direct
     || message.mentions?.some((mention) => String(mention?.id) === String(botId));
+  const replyTo = discordReplyReference(message, loadReply);
   return {
     messageId: String(message.id),
     senderId: String(message.author.id),
@@ -232,6 +321,7 @@ export function normalizeDiscordMessage(message, botId, { fetchImpl = fetch } =
     files: Array.isArray(message.attachments)
       ? message.attachments.map((attachment) => discordFileSource(attachment, fetchImpl)).filter(Boolean)
       : [],
+    ...(replyTo ? { replyTo } : {}),
     addressed,
     replyTarget: {
       channelId: String(message.channel_id),
@@ -252,7 +342,12 @@ export async function resolveDiscordMessageRoute(message, botId, {
   signal,
   onChannel,
 } = {}) {
-  const normalized = normalizeDiscordMessage(message, botId, { fetchImpl });
+  const normalized = normalizeDiscordMessage(message, botId, {
+    fetchImpl,
+    loadReply: typeof api?.getMessage === 'function'
+      ? (options) => api.getMessage(options)
+      : undefined,
+  });
   if (!normalized || normalized.senderIsBot) return normalized;
   signal?.throwIfAborted();
   if (normalized.kind === 'direct') {

package/src/channels/feishu/bridge.mjs

@@ -11,8 +11,11 @@ import {
   hasInboundImages,
   imagePromptDiagnostic,
   imagePromptUserMessage,
-  promptContentForMessage,
 } from '../shared/image-prompt.mjs';
+import {
+  hasReplyReference,
+  promptContentForInboundMessage,
+} from '../shared/semantic/reply-reference.mjs';
 import {
   hasInboundFiles,
   inboundFileUserMessage,
@@ -626,7 +629,9 @@ export class FeishuHarnessBridge {
         && (this.#queues.has(key) || pending || this.#approvals.hasPending(key))
         ? { handled: true, kind: 'busy', message: batchInputBusyMessage() }
         : this.#batchInputs.handle(key, batchText, {
-            plainText: event.message.message_type === 'text' && Boolean(batchText),
+            plainText: event.message.message_type === 'text'
+              && Boolean(batchText)
+              && !hasReplyReference(commandMessage),
           });
       if (result.handled) {
         if (result.kind === 'submit') {
@@ -1032,11 +1037,12 @@ export class FeishuHarnessBridge {
     const text = message.content;
     const hasImages = hasInboundImages(message);
     const hasFiles = hasInboundFiles(message);
+    const hasReply = hasReplyReference(message);
     // 命令识别对 text 与纯文本 post 一视同仁：post 富文本若仅含单个
     // 文本段落（如复制粘贴的 /new），同样按命令处理；带图片/文件不认。
     // accept() 侧已用 nonEmptyString(content) 判定，两侧保持一致。
     const commandText = !hasImages && !hasFiles && text ? text.trim() : null;
-    if (!text && !hasImages && !hasFiles) {
+    if (!text && !hasImages && !hasFiles && !hasReply) {
       await this.#send(event.message.chat_id, t('目前支持文字、图片和文件消息。'), { replyTo: event.message.message_id });
       return;
     }
@@ -3289,8 +3295,8 @@ export class FeishuHarnessBridge {
       askCompleted = true;
       onAskComplete?.();
     };
-    let content = hasInboundImages(message)
-      ? await promptContentForMessage(message, { signal: this.#signal })
+    let content = hasInboundImages(message) || hasReplyReference(message)
+      ? await promptContentForInboundMessage(message, { signal: this.#signal })
       : undefined;
     const snapshot = this.#acceptedMessageIds.get(messageId);
     let contextEnhanced = false;