@xmanrui/dsh-im 4.29.1 → 4.31.0

package/plugin-src/host/channels/feishu/production.mjs

@@ -253,7 +253,7 @@ export async function createProductionController(ctx, config = {}, internals = {
         domain: botConfig.domain,
         botOpenId: botConfig.botOpenId,
         groupResponseMode: botConfig.groupResponseMode,
-        groupTopicReply: botConfig.groupTopicReply,
+        mentionTopicReply: botConfig.mentionTopicReply,
         stepPush: botConfig.stepPush,
         stepPushMode: botConfig.stepPushMode,
         voice: voiceSource,
@@ -267,6 +267,7 @@ export async function createProductionController(ctx, config = {}, internals = {
         }),
         replyTimeoutMs: config.replyTimeoutMs ?? 600_000,
         slashCommands: config.slashCommands !== false,
+        slashPanel: botConfig.slashPanel,
         ...(wsAgent ? { wsAgent } : {}),
         logger: {
           error: (...args) => logger.error?.(`[${botId ?? botConfig.id}]`, ...args),

package/plugin-src/host/channels/feishu/rpc.mjs

@@ -31,6 +31,10 @@ import {
   normalizeFeishuStepPushMode,
 } from '../../../../src/channels/feishu/step-push-mode.mjs';
 import { normalizeFeishuVoiceConfig } from '../../../../src/channels/feishu/voice-config.mjs';
+import {
+  isSlashPanelConfig,
+  normalizeSlashPanelConfig,
+} from '../../../../src/channels/feishu/slash-command-panel.mjs';
 import {
   FEISHU_ENDPOINTS as FEISHU_CLIENT_ENDPOINTS,
   FEISHU_RPC_CHANNEL,
@@ -305,10 +309,11 @@ function publicBotEntry(entry) {
     contextEnhancement: normalizeContextEnhancementConfig(source.contextEnhancement),
     accessPolicy: normalizeAccessPolicy(source.accessPolicy),
     groupResponseMode: normalizeFeishuGroupResponseMode(source.groupResponseMode),
-    groupTopicReply: source.groupTopicReply === true,
+    mentionTopicReply: source.mentionTopicReply !== false,
     stepPush: source.stepPush === true,
     stepPushMode: normalizeFeishuStepPushMode(source.stepPushMode),
     voice: normalizeFeishuVoiceConfig(source.voice),
+    slashPanel: normalizeSlashPanelConfig(source.slashPanel),
     groupMessagePermissionGranted: source.groupMessagePermissionGranted === true,
     bot: publicBot(source.bot),
     health: publicHealth(source, connected),
@@ -471,10 +476,10 @@ function validPayload(endpoint, payload) {
       ? null
       : '请选择群聊响应方式。';
   }
-  if (endpoint === FEISHU_ENDPOINTS.setGroupTopicReply) {
-    return hasOnlyKeys(payload, new Set(['botId', 'groupTopicReply']))
+  if (endpoint === FEISHU_ENDPOINTS.setMentionTopicReply) {
+    return hasOnlyKeys(payload, new Set(['botId', 'mentionTopicReply']))
       && safeOpaqueId(payload.botId)
-      && typeof payload.groupTopicReply === 'boolean'
+      && typeof payload.mentionTopicReply === 'boolean'
       ? null
       : '请选择是否以话题方式回复。';
   }
@@ -503,6 +508,13 @@ function validPayload(endpoint, payload) {
       ? null
       : '语音配置无效。';
   }
+  if (endpoint === FEISHU_ENDPOINTS.setSlashPanel) {
+    return hasOnlyKeys(payload, new Set(['botId', 'slashPanel']))
+      && safeOpaqueId(payload.botId)
+      && isSlashPanelConfig(payload.slashPanel)
+      ? null
+      : '请选择面板要显示的指令与顺序。';
+  }
   return 'Unknown Feishu endpoint.';
 }
 
@@ -786,12 +798,12 @@ export function createFeishuRpcHandler(controller, { encodeQr = qrCodeDataUrl }
           await controller.updateGroupResponseMode(payload.botId, payload.groupResponseMode),
           { encodeQr: cachedEncodeQr },
         );
-      } else if (endpoint === FEISHU_ENDPOINTS.setGroupTopicReply) {
-        if (typeof controller.updateGroupTopicReply !== 'function') {
-          throw new Error('Group topic reply update is unavailable');
+      } else if (endpoint === FEISHU_ENDPOINTS.setMentionTopicReply) {
+        if (typeof controller.updateMentionTopicReply !== 'function') {
+          throw new Error('Mention topic reply update is unavailable');
         }
         value = await toPublicFeishuStatus(
-          await controller.updateGroupTopicReply(payload.botId, payload.groupTopicReply),
+          await controller.updateMentionTopicReply(payload.botId, payload.mentionTopicReply),
           { encodeQr: cachedEncodeQr },
         );
       } else if (endpoint === FEISHU_ENDPOINTS.setStepPush) {
@@ -818,6 +830,14 @@ export function createFeishuRpcHandler(controller, { encodeQr = qrCodeDataUrl }
           await controller.updateVoice(payload.botId, payload.voice),
           { encodeQr: cachedEncodeQr },
         );
+      } else if (endpoint === FEISHU_ENDPOINTS.setSlashPanel) {
+        if (typeof controller.updateSlashPanel !== 'function') {
+          throw new Error('Slash panel update is unavailable');
+        }
+        value = await toPublicFeishuStatus(
+          await controller.updateSlashPanel(payload.botId, payload.slashPanel),
+          { encodeQr: cachedEncodeQr },
+        );
       } else {
         if (typeof controller.deleteBot !== 'function') throw new Error('Multi-bot delete is unavailable');
         value = await toPublicFeishuStatus(await controller.deleteBot(payload.botId), { encodeQr: cachedEncodeQr });

package/scripts/verify-package.mjs

@@ -219,7 +219,7 @@ const directDependencies = {
   '@tencent-connect/qqbot-nodejs': '1.0.4',
   '@wecom/aibot-node-sdk': '1.0.7',
   qrcode: '1.5.4',
-  undici: '7.29.0',
+  undici: '7.29.1',
 };
 for (const [name, version] of Object.entries(directDependencies)) {
   if (manifest.dependencies?.[name] !== version) {

package/src/channels/feishu/bridge.mjs

@@ -1,12 +1,14 @@
 import QRCode from 'qrcode';
 import {
   conversationKey,
+  conversationScope,
   extractInboundMessage,
   extractText,
   isAllowedSender,
   isBotSender,
-  isTopicGroupKey,
-  managedGroupKey,
+  isTopicKey,
+  managedTopicKey,
+  managedTopicRoot,
   splitText,
 } from './message-utils.mjs';
 import {
@@ -331,6 +333,26 @@ function isBareMentionMenuRequest(event, text, {
   return !String(text ?? '').trim();
 }
 
+/**
+ * A message that is nothing but a mention of the bot, with no body of its own.
+ * There is no question to answer — a direct chat opens the menu card for it and
+ * a group gets the "text, image and file only" notice — so it must not open a
+ * topic either: an empty topic would leave an empty session behind, and every
+ * look at the menu would create another one.
+ *
+ * Mirrors the reply-reference test (`feishuReplyTargetId`): an explicit quote
+ * keeps the message a real question even when the mention is all the text it
+ * carries.
+ */
+function isBareMentionMessage(event) {
+  if (event?.message?.message_type !== 'text') return false;
+  const messageId = nonEmptyString(event?.message?.message_id);
+  const parentId = nonEmptyString(event?.message?.parent_id);
+  const rootId = nonEmptyString(event?.message?.root_id);
+  if (parentId || (rootId && rootId !== messageId)) return false;
+  return !String(extractText(event) ?? '').trim();
+}
+
 /** Canonical workspace/session help advertised by every bridge family. */
 const WORKSPACE_HELP_LINES = [
   '/workspace 工作区序号或绝对路径  切换工作区',
@@ -639,8 +661,13 @@ export class FeishuHarnessBridge {
   #appId;
   #botOpenId;
   #groupResponseMode;
-  /** When true, group replies that belong to a Feishu topic ask reply_in_thread. */
-  #groupTopicReply = false;
+  /**
+   * When true (the default), a question addressed to the bot opens a Feishu
+   * topic of its own — in groups and in direct chats alike — and the answer
+   * stays inside it. Turning it off keeps every question in the chat's main
+   * session and answers it in the main feed.
+   */
+  #mentionTopicReply = true;
   /** When true, streaming turns push tool calls and interim notes as discrete messages. */
   #stepPush = false;
   /** Step push presentation: discrete posts, a CardKit card, or native live CoT. */
@@ -706,7 +733,7 @@ export class FeishuHarnessBridge {
     appId,
     botOpenId,
     groupResponseMode = FEISHU_GROUP_RESPONSE_MODES.ALL,
-    groupTopicReply = false,
+    mentionTopicReply = true,
     stepPush = false,
     stepPushMode = FEISHU_STEP_PUSH_MODES.POST,
     stepPushClock = null,
@@ -764,7 +791,7 @@ export class FeishuHarnessBridge {
     this.#appId = nonEmptyString(appId);
     this.#botOpenId = nonEmptyString(botOpenId);
     this.#groupResponseMode = normalizeFeishuGroupResponseMode(groupResponseMode);
-    this.#groupTopicReply = groupTopicReply === true;
+    this.#mentionTopicReply = mentionTopicReply !== false;
     this.#stepPush = stepPush === true;
     this.#stepPushMode = normalizeFeishuStepPushMode(stepPushMode);
     this.#stepPushClock = stepPushClock ?? DEFAULT_STEP_PUSH_CLOCK;
@@ -850,8 +877,8 @@ export class FeishuHarnessBridge {
     this.#groupResponseMode = normalizeFeishuGroupResponseMode(value);
   }
 
-  setGroupTopicReply(value) {
-    this.#groupTopicReply = value === true;
+  setMentionTopicReply(value) {
+    this.#mentionTopicReply = value !== false;
   }
 
   setStepPush(value) {
@@ -872,6 +899,16 @@ export class FeishuHarnessBridge {
 
   #isAddressed(event) {
     if (event?.message?.chat_type === 'p2p') return true;
+    return this.#isMentioned(event);
+  }
+
+  /**
+   * Whether this message mentions the bot. Unlike #isAddressed — which answers
+   * "does this chat expect a reply at all" and is therefore always true in a
+   * direct chat — this asks the literal question, so a topic is only opened for
+   * a message the reader actually addressed to the bot.
+   */
+  #isMentioned(event) {
     const mentions = Array.isArray(event?.message?.mentions) ? event.message.mentions : [];
     if (!this.#botOpenId) return mentions.length > 0;
     return mentions.some((mention) => mention?.id?.open_id === this.#botOpenId
@@ -879,27 +916,31 @@ export class FeishuHarnessBridge {
   }
 
   /**
-   * Conversation key for one inbound event. When group-topic replies are on,
-   * a main-feed question addressed to the bot opens a fresh managed topic
-   * session instead of joining the shared group session, and messages inside
-   * a topic we already opened resolve back to that same managed session.
+   * Conversation key for one inbound event, for groups and direct chats alike.
+   *
+   * - A message inside a topic resolves back to the managed key when the bot
+   *   rooted that topic, so the whole topic keeps one session; every other
+   *   thread keeps the key the channel would have used without managed topics.
+   * - A main-feed message that mentions the bot opens a fresh managed topic
+   *   session instead of joining the chat's shared session. A bare "@bot" is
+   *   excluded: it is a menu request, not a question.
+   * - Everything else stays in the chat's shared session.
    */
   #resolveKey(event) {
-    const chatType = event?.message?.chat_type;
-    const chatId = nonEmptyString(event?.message?.chat_id);
-    if (chatType !== 'group') return conversationKey(event);
     const messageId = nonEmptyString(event?.message?.message_id);
     const threadId = nonEmptyString(event?.message?.thread_id);
     if (threadId) {
       const root = this.#state?.topicRootFor?.(threadId) ?? null;
-      return root && chatId
-        ? managedGroupKey(chatId, root.rootMessageId)
-        : `group:${chatId}:thread:${threadId}`;
+      if (root) return managedTopicKey(conversationScope(event), root.rootMessageId);
+      return conversationKey(event);
     }
-    if (this.#groupTopicReply && chatId && messageId && this.#isAddressed(event)) {
-      return managedGroupKey(chatId, messageId);
+    if (this.#mentionTopicReply
+      && messageId
+      && this.#isMentioned(event)
+      && !isBareMentionMessage(event)) {
+      return managedTopicKey(conversationScope(event), messageId);
     }
-    return `group:${chatId}`;
+    return conversationKey(event);
   }
 
   /**
@@ -911,7 +952,7 @@ export class FeishuHarnessBridge {
    */
   #rememberTopicReply(messageId, key) {
     if (!nonEmptyString(messageId)) return;
-    this.#anchorTopicReply.set(messageId, isTopicGroupKey(key));
+    this.#anchorTopicReply.set(messageId, isTopicKey(key));
     if (this.#anchorTopicReply.size > 2048) {
       const oldest = this.#anchorTopicReply.keys().next().value;
       if (oldest !== undefined) this.#anchorTopicReply.delete(oldest);
@@ -960,13 +1001,62 @@ export class FeishuHarnessBridge {
 
   /** Persist thread_id once Feishu auto-opened a topic from a managed root. */
   async #registerTopicFromReply(replyTo, chatId, response) {
-    const threadId = nonEmptyString(response?.data?.thread_id);
+    await this.#registerTopicReply(replyTo, chatId, response?.data?.thread_id);
+  }
+
+  /**
+   * Record the topic for a root this bot asked Feishu to open. The reply
+   * response carries the thread_id in most cases; when it does not — we have
+   * seen a topic come back without one — read it back from the message we
+   * replied to. Feishu opened the topic either way, and a topic left
+   * unrecorded would answer its follow-ups from the chat's own session instead
+   * of the topic's.
+   */
+  async #registerTopicReply(rootMessageId, chatId, threadId) {
+    const known = nonEmptyString(threadId);
+    if (known) {
+      await this.#registerTopicThreadId(known, rootMessageId, chatId);
+      return;
+    }
+    await this.#ensureTopicRegistered(rootMessageId, chatId);
+  }
+
+  /**
+   * Fallback for a threaded reply that reported no thread_id: ask Feishu which
+   * topic the replied-to message now belongs to. Only runs while that message
+   * is still a pending root candidate, so a topic already recorded — or a
+   * conversation that has no topics at all — costs no extra API call.
+   */
+  async #ensureTopicRegistered(rootMessageId, chatId) {
+    this.#pruneRootCandidates();
+    if (!nonEmptyString(rootMessageId) || !this.#rootCandidates.has(rootMessageId)) return;
+    const threadId = await this.#readTopicThreadId(rootMessageId);
     if (threadId) {
-      await this.#registerTopicThreadId(threadId, replyTo, chatId);
-    } else {
-      // No thread_id means the topic did not open; drop the candidate so a
-      // later addressed question opens a fresh session, not a stale slot.
-      this.#forgetTopicRoot(replyTo);
+      await this.#registerTopicThreadId(threadId, rootMessageId, chatId);
+      return;
+    }
+    // Still no topic: drop the candidate so a later addressed question opens a
+    // fresh session rather than reusing a stale slot.
+    this.#forgetTopicRoot(rootMessageId);
+  }
+
+  /** The topic a message belongs to, or null when it is not in one. */
+  async #readTopicThreadId(messageId) {
+    const read = this.#client?.im?.v1?.message?.get;
+    if (typeof read !== 'function') return null;
+    try {
+      const response = await read({ path: { message_id: messageId } });
+      if (response?.code && response.code !== 0) return null;
+      const items = Array.isArray(response?.data?.items) ? response.data.items : [];
+      const item = items.find((candidate) => nonEmptyString(candidate?.message_id) === messageId)
+        ?? items[0];
+      return nonEmptyString(item?.thread_id);
+    } catch (error) {
+      this.#logger.warn?.(
+        '[dsh-feishu] could not read the topic of a replied-to message:',
+        error?.message ?? String(error),
+      );
+      return null;
     }
   }
 
@@ -1053,10 +1143,9 @@ export class FeishuHarnessBridge {
     }
     // Register a managed-topic root only after access is allowed, so a
     // rejected or ignored question never reserves a candidate slot.
-    if (this.#groupTopicReply
-      && event?.message?.chat_type === 'group'
+    if (this.#mentionTopicReply
       && !nonEmptyString(event?.message?.thread_id)
-      && isTopicGroupKey(key)
+      && isTopicKey(key)
       && key.includes(':managed:')) {
       this.#rememberTopicRoot(messageId);
     }
@@ -1175,7 +1264,7 @@ export class FeishuHarnessBridge {
       this.#commandTasks.add(current);
       return current;
     }
-    if (this.#isResolvedQuestionReply(event, key)) {
+    if (!hasImages && this.#isResolvedQuestionReply(event, key)) {
       const current = Promise.resolve()
         .then(() => this.#discardResolvedInteractionReply(event, messageId))
         .then(() => this.#finishReaction(messageId, processingReaction, 'DONE'))
@@ -1228,6 +1317,19 @@ export class FeishuHarnessBridge {
     if (pending && senderOpenId(event) !== pending.actor) {
       return this.#enqueueMessage(event, messageId, key, processingReaction);
     }
+    if (pending && hasImages) {
+      const previous = pending.queue ?? Promise.resolve();
+      const interruption = previous.catch(() => undefined)
+        .then(() => this.#interruptQuestionForImage(event, key, pending))
+        .finally(() => {
+          if (pending.queue === interruption) pending.queue = null;
+          this.#interactionTasks.delete(interruption);
+        });
+      pending.queue = interruption;
+      this.#interactionTasks.add(interruption);
+      // Reserve the image's FIFO position before stopping releases the original turn.
+      return this.#enqueueMessage(event, messageId, key, processingReaction);
+    }
     if (pending?.submitting || pending?.claimedReplyMessageId) {
       return this.#enqueueMessage(event, messageId, key, processingReaction);
     }
@@ -3448,7 +3550,9 @@ export class FeishuHarnessBridge {
 
   async #deliverDeferredOutcome(entry, outcome) {
     this.#rememberTopicReply(entry.replyToMessageId, entry.key);
-    if (entry.key === managedGroupKey(entry.chatId, entry.replyToMessageId)) {
+    // A late answer still has to open the topic it was rooted at, so re-arm the
+    // root candidate: the key alone says whether this route was a managed topic.
+    if (managedTopicRoot(entry.key) === nonEmptyString(entry.replyToMessageId)) {
       this.#rememberTopicRoot(entry.replyToMessageId);
     }
     const text = deferredOutcomeText(outcome);
@@ -3470,10 +3574,10 @@ export class FeishuHarnessBridge {
           ...(replyToMessageId ? { replyTo: replyToMessageId } : {}),
           ...(this.#replyInThreadFor(replyToMessageId) ? {
             replyInThread: true,
-            onReplyThreadId: async (threadId) => this.#registerTopicThreadId(
-              threadId,
+            onReplyThreadId: async (threadId) => this.#registerTopicReply(
               replyToMessageId,
               chatId,
+              threadId,
             ),
           } : {}),
         });
@@ -4280,7 +4384,7 @@ export class FeishuHarnessBridge {
             replyTo,
             signal: this.#signal,
             ...(this.#replyInThreadFor(replyTo)
-              ? { replyInThread: true, onReplyThreadId: async (threadId) => this.#registerTopicThreadId(threadId, replyTo, chatId) }
+              ? { replyInThread: true, onReplyThreadId: async (threadId) => this.#registerTopicReply(replyTo, chatId, threadId) }
               : {}),
           })
         : undefined,
@@ -4289,7 +4393,7 @@ export class FeishuHarnessBridge {
             replyTo,
             signal: this.#signal,
             ...(this.#replyInThreadFor(replyTo)
-              ? { replyInThread: true, onReplyThreadId: async (threadId) => this.#registerTopicThreadId(threadId, replyTo, chatId) }
+              ? { replyInThread: true, onReplyThreadId: async (threadId) => this.#registerTopicReply(replyTo, chatId, threadId) }
               : {}),
           })
         : undefined,
@@ -4832,10 +4936,11 @@ export class FeishuHarnessBridge {
       error.feishuCode = response.code;
       throw error;
     }
-    const threadId = nonEmptyString(response?.data?.thread_id);
-    if (threadId) {
-      await this.#registerTopicThreadId(threadId, messageId, chatId);
-    }
+    // 与其他回复路径同一条登记逻辑：响应通常带 thread_id，没带就回读被回复的消息
+    // （#registerTopicReply → #ensureTopicRegistered）。逐步消息以前只认响应，
+    // 于是话题开出来了却没登记，话题内的追问会从托管键掉回聊天自己的会话。
+    // 两个分支都以「该消息仍是待开话题的候选根」为前提，不是候选就是空操作。
+    await this.#registerTopicReply(messageId, chatId, response?.data?.thread_id);
     return response;
   }
 
@@ -5539,7 +5644,7 @@ export class FeishuHarnessBridge {
       }, {
         replyTo: messageId,
         ...(this.#replyInThreadFor(messageId)
-          ? { replyInThread: true, onReplyThreadId: async (threadId) => this.#registerTopicThreadId(threadId, messageId, chatId) }
+          ? { replyInThread: true, onReplyThreadId: async (threadId) => this.#registerTopicReply(messageId, chatId, threadId) }
           : {}),
       });
     } catch (error) {
@@ -5717,6 +5822,40 @@ export class FeishuHarnessBridge {
     });
   }
 
+  async #interruptQuestionForImage(event, key, pending) {
+    if (this.#signal?.aborted || this.#pendingInteractions.get(key) !== pending) return;
+    const question = pending.questions[pending.index];
+    const questionMessageId = pending.questionCardMessageId;
+    const index = pending.index;
+    const wasSubmitting = pending.submitting;
+    pending.submitting = true;
+    try {
+      await runControlCommand('/stop', this.#harness, this.#state, key, {
+        signal: this.#signal,
+        control: { owner: this, key },
+      });
+    } catch (error) {
+      if (this.#pendingInteractions.get(key) === pending) pending.submitting = wasSubmitting;
+      this.#logger.warn?.('[dsh-feishu] could not stop the question turn for an image:', error.message);
+      await this.#send(event.message.chat_id,
+        t('图片已排队，但暂时无法结束当前提问。请先回答问题或发送 /stop，结束后会继续处理图片。'),
+        { replyTo: event.message.message_id }).catch(() => undefined);
+      return;
+    }
+    await this.#cancelPendingInteraction(key, pending.interactionId);
+    const resolvedText = t('已结束本轮提问，将在当前会话中继续处理图片。');
+    if (questionMessageId) {
+      await this.#patchCardMessage(event.message.chat_id, questionMessageId, questionCard({
+        ...question,
+        interactionId: pending.interactionId,
+        index,
+        total: pending.questions.length,
+        resolvedText,
+      }));
+    }
+    await this.#send(event.message.chat_id, resolvedText, { replyTo: event.message.message_id }).catch(() => undefined);
+  }
+
   async #submitQuestionAnswer(pending, answerText, { chatId, messageId, questionMessageId } = {}) {
     const question = pending.questions[pending.index];
     if (!question) return;
@@ -6054,8 +6193,8 @@ export class FeishuHarnessBridge {
     return this.#takePendingInteraction(key, interactionId) !== null;
   }
 
-  async #cancelPendingInteraction(key) {
-    const pending = this.#takePendingInteraction(key);
+  async #cancelPendingInteraction(key, interactionId) {
+    const pending = this.#takePendingInteraction(key, interactionId);
     if (!pending || pending.kind !== 'question') return;
     this.#rememberResolvedInteraction(key, pending);
     try {

package/src/channels/feishu/feishu-cards.mjs

@@ -1211,9 +1211,10 @@ export function splitStepStreamCardBlocks(
  * rendered as its own button; the selected option label is submitted via a
  * card callback. Multi-select questions fall back to the plain-text flow (the
  * caller decides), because a multi-select needs a confirm step.
+ * A resolvedText replaces the buttons when an image ends the question flow.
  * Action: answer:<interactionId>:<optionLabel>
  */
-export function questionCard({ interactionId, header, question, detail, options, index, total }) {
+export function questionCard({ interactionId, header, question, detail, options, index, total, resolvedText }) {
   const elements = [];
   const progress = total > 1 ? `（${index + 1}/${total}）` : '';
   if (header) elements.push({ tag: 'div', text: markdown(String(header)) });
@@ -1221,6 +1222,11 @@ export function questionCard({ interactionId, header, question, detail, options,
   elements.push({ tag: 'div', text: markdown(String(qText)) });
   if (detail) elements.push({ tag: 'div', text: markdown(String(detail)) });
 
+  if (resolvedText) {
+    elements.push({ tag: 'hr' }, { tag: 'div', text: markdown(resolvedText) });
+    return cardWith(t('⏹ 提问已结束{progress}', { progress }), elements);
+  }
+
   if (Array.isArray(options) && options.length > 0) {
     elements.push({ tag: 'hr' });
     for (const option of options) {

package/src/channels/feishu/feishu-channel.mjs

@@ -516,9 +516,12 @@ export class VerifiedFeishuChannel {
     if (typeof messageId !== 'string' || !messageId) {
       throw fileDeliveryError('message send', undefined, undefined, { uncertain: true });
     }
-    if (replyTo && typeof onReplyThreadId === 'function') {
+    if (replyTo && replyInThread && typeof onReplyThreadId === 'function') {
+      // The reply itself opens the topic, and the response reports its
+      // thread_id only sometimes (a direct-chat topic comes back without one).
+      // Hand over what we have and let the bridge read it back when missing.
       const threadId = response?.data?.thread_id;
-      if (typeof threadId === 'string' && threadId) await onReplyThreadId(threadId);
+      await onReplyThreadId(typeof threadId === 'string' && threadId ? threadId : null);
     }
     return createDeliveryReceipt({
       deliveryId: file.deliveryKey,
@@ -596,9 +599,11 @@ export class VerifiedFeishuChannel {
     assertApiSuccess('Feishu message send', response);
     const messageId = response?.data?.message_id;
     if (!messageId) throw new Error('Feishu message send returned no message_id');
-    if (replyTo && typeof options.onReplyThreadId === 'function') {
+    if (replyTo && replyInThread && typeof options.onReplyThreadId === 'function') {
+      // See #sendArtifact: the topic is created by the reply, but the response
+      // may omit its thread_id, so pass it through as it came.
       const threadId = response?.data?.thread_id;
-      if (typeof threadId === 'string' && threadId) await options.onReplyThreadId(threadId);
+      await options.onReplyThreadId(typeof threadId === 'string' && threadId ? threadId : null);
     }
     return messageId;
   }