@m1heng-clawd/feishu 0.1.14 → 0.1.15

package/src/bot.ts

@@ -53,6 +53,7 @@ function extractFirstUrl(raw: string): string | undefined {
   return urlMatch?.[0];
 }
 
+
 function extractPermissionError(err: unknown): PermissionError | null {
   if (!err || typeof err !== "object") return null;
 
@@ -254,9 +255,7 @@ async function resolveFeishuSenderName(params: {
 
     const name: string | undefined =
       res?.data?.user?.name ||
-      res?.data?.user?.display_name ||
-      res?.data?.user?.nickname ||
-      res?.data?.user?.en_name;
+      res?.data?.user?.nickname;
 
     if (name && typeof name === "string") {
       senderNameCache.set(senderOpenId, { name, expireAt: now + SENDER_NAME_TTL_MS });
@@ -281,6 +280,67 @@ async function resolveFeishuSenderName(params: {
 // Cache group bot counts for command mention bypass policy checks.
 const GROUP_BOT_COUNT_TTL_MS = 10 * 60 * 1000;
 const groupBotCountCache = new Map<string, { count: number; expireAt: number }>();
+// Fallback flush only for standalone forwarded messages.
+// Quote-reply merging should rely on parent_id relation instead of time windows.
+const FORWARDED_COALESCE_WINDOW_MS = 1500;
+const FORWARDED_COMPANION_TTL_MS = 20 * 1000;
+type PendingForwardedDispatchEntry = {
+  token: string;
+  timer: ReturnType<typeof setTimeout>;
+  content: string;
+  messageKeys: Set<string>;
+};
+const pendingForwardedDispatch = new Map<string, PendingForwardedDispatchEntry>();
+const pendingForwardedDispatchByMessageId = new Map<string, string>();
+const recentForwardedCompanionReplies = new Map<string, number>();
+
+function getForwardedKey(params: {
+  accountId: string;
+  chatId: string;
+  forwardedMessageId: string;
+}): string {
+  return `${params.accountId}:${params.chatId}:${params.forwardedMessageId}`;
+}
+
+function clearPendingForwardedDispatchEntry(dispatchKey: string, entry: PendingForwardedDispatchEntry): void {
+  clearTimeout(entry.timer);
+  pendingForwardedDispatch.delete(dispatchKey);
+  for (const key of entry.messageKeys) {
+    pendingForwardedDispatchByMessageId.delete(key);
+  }
+}
+
+function markForwardedCompanionReply(params: {
+  accountId: string;
+  chatId: string;
+  forwardedMessageId: string;
+}): void {
+  const now = Date.now();
+  for (const [key, expireAt] of recentForwardedCompanionReplies) {
+    if (expireAt <= now) recentForwardedCompanionReplies.delete(key);
+  }
+  recentForwardedCompanionReplies.set(
+    getForwardedKey(params),
+    now + FORWARDED_COMPANION_TTL_MS,
+  );
+}
+
+function consumeForwardedCompanionReply(params: {
+  accountId: string;
+  chatId: string;
+  forwardedMessageId: string;
+}): boolean {
+  const key = getForwardedKey(params);
+  const now = Date.now();
+  const expireAt = recentForwardedCompanionReplies.get(key);
+  if (!expireAt) return false;
+  if (expireAt <= now) {
+    recentForwardedCompanionReplies.delete(key);
+    return false;
+  }
+  recentForwardedCompanionReplies.delete(key);
+  return true;
+}
 
 async function resolveFeishuGroupBotCount(params: {
   account: ResolvedFeishuAccount;
@@ -327,7 +387,8 @@ export type FeishuMessageEvent = {
     root_id?: string;
     parent_id?: string;
     chat_id: string;
-    chat_type: "p2p" | "group";
+    chat_type: "p2p" | "group" | "private";
+    create_time?: string;
     message_type: string;
     content: string;
     mentions?: Array<{
@@ -354,24 +415,64 @@ export type FeishuBotAddedEvent = {
   operator_tenant_key?: string;
 };
 
-function parseMessageContent(content: string, messageType: string): string {
+function isForwardedMessageType(messageType: string): boolean {
+  return messageType === "forwarded" || messageType === "merged_forwarded" || messageType === "merge_forward";
+}
+
+type ParsedFeishuMessageContent = {
+  text: string;
+  placeholder?: string;
+  rawPayload?: string;
+};
+
+function parseMessageContent(content: string, messageType: string): ParsedFeishuMessageContent {
   try {
     const parsed = JSON.parse(content);
     const normalizedMessageType = normalizeFeishuInboundMessageType(messageType);
     if (normalizedMessageType === "text") {
-      return parsed.text || "";
+      return { text: parsed.text || "", rawPayload: content };
     }
     if (normalizedMessageType === "post") {
       // Extract text content from rich text post
       const { textContent } = parsePostContent(content);
-      return textContent;
+      return { text: textContent, rawPayload: content };
     }
     if (["image", "file", "audio", "video", "sticker"].includes(normalizedMessageType)) {
-      return inferPlaceholder(normalizedMessageType);
+      const ph = inferPlaceholder(normalizedMessageType);
+      return { text: ph, placeholder: ph, rawPayload: content };
+    }
+    // Handle forwarded messages (single message forwarded)
+    if (messageType === "forwarded") {
+      const senderName = parsed.sender_name || parsed.sender?.name || "unknown";
+      const text = parsed.text || parsed.title || "";
+      const forwarded = text ? `[Forwarded from ${senderName}]: ${text.substring(0, 100)}` : `[Forwarded from ${senderName}]`;
+      return { text: forwarded, rawPayload: content };
+    }
+    // Handle merged_forwarded messages (multiple messages merged)
+    // Note: Feishu uses "merge_forward" for merged forwarded messages
+    if (messageType === "merged_forwarded" || messageType === "merge_forward") {
+      const messageCount = parsed.message_count || parsed.messages?.length || 0;
+      const senderNames = parsed.messages
+        ?.map((m: any) => m.sender_name || m.sender?.name)
+        .filter(Boolean)
+        .join(", ") || "unknown";
+      // Extract preview of first few messages
+      let preview = "";
+      if (parsed.messages && parsed.messages.length > 0) {
+        const previews = parsed.messages
+          .slice(0, 3)
+          .map((m: any) => m.text || m.title || "")
+          .filter(Boolean)
+          .map((t: string) => t.substring(0, 50));
+        if (previews.length > 0) {
+          preview = `\n└ ${previews.join("\n└ ")}`;
+        }
+      }
+      return { text: `[Merged forward (${messageCount} messages), from: ${senderNames}]${preview}`, rawPayload: content };
     }
-    return content;
+    return { text: content, rawPayload: content };
   } catch {
-    return content;
+    return { text: content, rawPayload: content };
   }
 }
 
@@ -502,12 +603,33 @@ function parsePostContent(content: string): {
     }
 
     return {
-      textContent: textContent.trim() || "[富文本消息]",
+      textContent: textContent.trim() || "[Rich text message]",
       imageKeys,
       mentionIds,
     };
   } catch {
-    return { textContent: "[富文本消息]", imageKeys: [], mentionIds: [] };
+    return { textContent: "[Rich text message]", imageKeys: [], mentionIds: [] };
+  }
+}
+
+function isGenericMimeType(mime?: string): boolean {
+  if (!mime) return true;
+  const normalized = mime.split(";")[0]?.trim().toLowerCase();
+  return !normalized || normalized === "application/octet-stream";
+}
+
+function resolveFallbackMimeType(messageType: string): string | undefined {
+  switch (messageType) {
+    case "audio":
+      // Feishu voice messages are typically opus in ogg container.
+      return "audio/ogg; codecs=opus";
+    case "video":
+      return "video/mp4";
+    case "image":
+    case "post":
+      return "image/jpeg";
+    default:
+      return undefined;
   }
 }
 
@@ -578,8 +700,12 @@ async function resolveFeishuMediaList(params: {
         });
 
         let contentType = result.contentType;
-        if (!contentType) {
-          contentType = await core.media.detectMime({ buffer: result.buffer });
+        if (!contentType || isGenericMimeType(contentType)) {
+          contentType =
+            (await core.media.detectMime({
+              buffer: result.buffer,
+              headerMime: contentType,
+            })) ?? resolveFallbackMimeType("image");
         }
 
         const saved = await core.channel.media.saveMediaBuffer(
@@ -634,9 +760,17 @@ async function resolveFeishuMediaList(params: {
     contentType = result.contentType;
     fileName = result.fileName || mediaKeys.fileName;
 
-    // Detect mime type if not provided
-    if (!contentType) {
-      contentType = await core.media.detectMime({ buffer });
+    // Detect MIME type and apply message-type fallback when needed.
+    if (!contentType || isGenericMimeType(contentType)) {
+      contentType =
+        (await core.media.detectMime({
+          buffer,
+          headerMime: contentType,
+          filePath: fileName,
+        })) ?? resolveFallbackMimeType(normalizedMessageType);
+    }
+    if (isGenericMimeType(contentType)) {
+      contentType = resolveFallbackMimeType(normalizedMessageType) ?? contentType;
     }
 
     // Save to disk using core's saveMediaBuffer
@@ -689,17 +823,44 @@ function buildFeishuMediaPayload(
   };
 }
 
+function skipGroupMessageForMentionGate(params: {
+  accountId: string;
+  chatId: string;
+  senderOpenId: string;
+  senderName?: string;
+  content: string;
+  messageId: string;
+  historyLimit: number;
+  chatHistories?: Map<string, HistoryEntry[]>;
+  log: (...args: any[]) => void;
+}): void {
+  params.log(`feishu[${params.accountId}]: message in group ${params.chatId} skipped (mention required)`);
+  if (params.chatHistories) {
+    recordPendingHistoryEntryIfEnabled({
+      historyMap: params.chatHistories,
+      historyKey: params.chatId,
+      limit: params.historyLimit,
+      entry: {
+        sender: params.senderOpenId,
+        body: `${params.senderName ?? params.senderOpenId}: ${params.content}`,
+        timestamp: Date.now(),
+        messageId: params.messageId,
+      },
+    });
+  }
+}
+
 export function parseFeishuMessageEvent(
   event: FeishuMessageEvent,
   botOpenId?: string,
 ): FeishuMessageContext {
   const parsedPost =
     event.message.message_type === "post" ? parsePostContent(event.message.content) : undefined;
-  const rawContent = parseMessageContent(event.message.content, event.message.message_type);
+  const parsedContent = parseMessageContent(event.message.content, event.message.message_type);
   const mentionedBot = checkBotMentioned(event, botOpenId, parsedPost?.mentionIds ?? []);
   const hasAnyMention =
     (event.message.mentions?.length ?? 0) > 0 || (parsedPost?.mentionIds.length ?? 0) > 0;
-  const content = stripBotMention(rawContent, event.message.mentions);
+  const content = stripBotMention(parsedContent.text, event.message.mentions);
 
   const ctx: FeishuMessageContext = {
     chatId: event.message.chat_id,
@@ -712,6 +873,8 @@ export function parseFeishuMessageEvent(
     parentId: event.message.parent_id || undefined,
     content,
     contentType: event.message.message_type,
+    placeholder: parsedContent.placeholder,
+    rawPayload: parsedContent.rawPayload,
     hasAnyMention,
   };
 
@@ -736,8 +899,9 @@ export async function handleFeishuMessage(params: {
   runtime?: RuntimeEnv;
   chatHistories?: Map<string, HistoryEntry[]>;
   accountId?: string;
+  replyToMessageIdOverride?: string;
 }): Promise<void> {
-  const { cfg, event, botOpenId, runtime, chatHistories, accountId } = params;
+  const { cfg, event, botOpenId, runtime, chatHistories, accountId, replyToMessageIdOverride } = params;
 
   // Resolve account with merged config
   const account = resolveFeishuAccount({ cfg, accountId });
@@ -755,6 +919,144 @@ export async function handleFeishuMessage(params: {
   }
 
   let ctx = parseFeishuMessageEvent(event, botOpenId);
+
+  // Parse message create_time (Feishu uses millisecond epoch string).
+  const messageCreateTimeMs = event.message.create_time
+    ? parseInt(event.message.create_time, 10)
+    : undefined;
+
+  const messageType = event.message.message_type;
+  const isForwardedInbound = isForwardedMessageType(messageType);
+  const forwardedDispatchKey = getForwardedKey({
+    accountId: account.accountId,
+    chatId: ctx.chatId,
+    forwardedMessageId: ctx.messageId,
+  });
+  if (!isForwardedInbound && ctx.parentId) {
+    markForwardedCompanionReply({
+      accountId: account.accountId,
+      chatId: ctx.chatId,
+      forwardedMessageId: ctx.parentId,
+    });
+  }
+
+  // For forwarded/merged_forwarded messages, fetch full message details via API
+  // Note: Feishu uses "merge_forward" for merged forwarded messages
+  if (isForwardedInbound) {
+    if (
+      consumeForwardedCompanionReply({
+        accountId: account.accountId,
+        chatId: ctx.chatId,
+        forwardedMessageId: ctx.messageId,
+      })
+    ) {
+      log(
+        `feishu[${account.accountId}]: skipping companion forwarded message ${ctx.messageId} (covered by parent reply)`,
+      );
+      return;
+    }
+    try {
+      const fullMessage = await getMessageFeishu({
+        cfg,
+        messageId,
+        accountId: account.accountId,
+      });
+      if (fullMessage?.content) {
+        // Use the already-parsed content from getMessageFeishu (includes all child messages for merge_forward)
+        ctx = { ...ctx, content: fullMessage.content };
+      }
+    } catch (err) {
+      log(`feishu: failed to fetch forwarded message details: ${err}`);
+    }
+    // Handle race: parent-reply may arrive and be processed while we're awaiting getMessageFeishu above.
+    // In that case, do not enqueue deferred forwarded flush again.
+    if (
+      consumeForwardedCompanionReply({
+        accountId: account.accountId,
+        chatId: ctx.chatId,
+        forwardedMessageId: ctx.messageId,
+      })
+    ) {
+      log(
+        `feishu[${account.accountId}]: skipping companion forwarded message ${ctx.messageId} (covered during fetch)`,
+      );
+      return;
+    }
+    const existing = pendingForwardedDispatch.get(forwardedDispatchKey);
+    if (existing) clearPendingForwardedDispatchEntry(forwardedDispatchKey, existing);
+    const mergedMessageKeys = new Set<string>([forwardedDispatchKey]);
+    const token = `${ctx.messageId}:${Date.now()}`;
+    const deferredMessageIdBase = ctx.messageId;
+    const timer = setTimeout(() => {
+      const current = pendingForwardedDispatch.get(forwardedDispatchKey);
+      if (!current || current.token !== token) return;
+      clearPendingForwardedDispatchEntry(forwardedDispatchKey, current);
+
+      const syntheticEvent: FeishuMessageEvent = {
+        ...event,
+        message: {
+          ...event.message,
+          message_id: `${deferredMessageIdBase}:forwarded-flush:${Date.now()}`,
+          message_type: "text",
+          content: JSON.stringify({ text: current.content }),
+        },
+      };
+
+      void handleFeishuMessage({
+        cfg,
+        event: syntheticEvent,
+        botOpenId,
+        runtime,
+        chatHistories,
+        accountId: account.accountId,
+        replyToMessageIdOverride: deferredMessageIdBase,
+      }).catch((err) => {
+        error(`feishu[${account.accountId}]: failed deferred forwarded dispatch: ${String(err)}`);
+      });
+    }, FORWARDED_COALESCE_WINDOW_MS);
+
+    pendingForwardedDispatch.set(forwardedDispatchKey, {
+      token,
+      timer,
+      content: ctx.content,
+      messageKeys: mergedMessageKeys,
+    });
+    for (const messageKey of mergedMessageKeys) {
+      pendingForwardedDispatchByMessageId.set(messageKey, forwardedDispatchKey);
+    }
+    log(
+      `feishu[${account.accountId}]: queued forwarded message ${ctx.messageId} for deferred dispatch`,
+    );
+    return;
+  } else {
+    let pending: PendingForwardedDispatchEntry | undefined;
+    let pendingDispatchKey: string | undefined;
+    if (ctx.parentId) {
+      const parentMessageKey = getForwardedKey({
+        accountId: account.accountId,
+        chatId: ctx.chatId,
+        forwardedMessageId: ctx.parentId,
+      });
+      const parentDispatchKey = pendingForwardedDispatchByMessageId.get(parentMessageKey);
+      if (parentDispatchKey) {
+        pendingDispatchKey = parentDispatchKey;
+        pending = pendingForwardedDispatch.get(parentDispatchKey);
+      } else {
+        pendingForwardedDispatchByMessageId.delete(parentMessageKey);
+      }
+    }
+    if (pending && pendingDispatchKey) {
+      clearPendingForwardedDispatchEntry(pendingDispatchKey, pending);
+      ctx = {
+        ...ctx,
+        content: `${pending.content}\n\n---\n\n${ctx.content}`,
+      };
+      log(
+        `feishu[${account.accountId}]: merged pending forwarded context into follow-up ${ctx.messageId}`,
+      );
+    }
+  }
+
   const isGroup = ctx.chatType === "group";
 
   // Resolve sender display name (best-effort) so the agent can attribute messages correctly.
@@ -835,7 +1137,7 @@ export async function handleFeishuMessage(params: {
           try {
             await sendMessageFeishu({
               cfg,
-              to: `user:${ctx.senderOpenId}`,
+              to: `chat:${ctx.chatId}`,
               text: core.channel.pairing.buildPairingReply({
                 channel: "feishu",
                 idLine: `Your Feishu user id: ${ctx.senderOpenId}`,
@@ -914,7 +1216,7 @@ export async function handleFeishuMessage(params: {
         }
       }
 
-      const { requireMention } = resolveFeishuReplyPolicy({
+      const { requireMention, allowMentionlessInMultiBotGroup } = resolveFeishuReplyPolicy({
         isDirectMessage: false,
         globalConfig: feishuCfg,
         groupConfig,
@@ -954,22 +1256,49 @@ export async function handleFeishuMessage(params: {
         effectiveWasMentioned = mentionGate.effectiveWasMentioned;
 
         if (mentionGate.shouldSkip) {
-          log(
-            `feishu[${account.accountId}]: message in group ${ctx.chatId} skipped (mention required)`,
-          );
-          if (chatHistories) {
-            recordPendingHistoryEntryIfEnabled({
-              historyMap: chatHistories,
-              historyKey: ctx.chatId,
-              limit: historyLimit,
-              entry: {
-                sender: ctx.senderOpenId,
-                body: `${ctx.senderName ?? ctx.senderOpenId}: ${ctx.content}`,
-                timestamp: Date.now(),
-                messageId: ctx.messageId,
-              },
-            });
+          skipGroupMessageForMentionGate({
+            accountId: account.accountId,
+            chatId: ctx.chatId,
+            senderOpenId: ctx.senderOpenId,
+            senderName: ctx.senderName,
+            content: ctx.content,
+            messageId: ctx.messageId,
+            historyLimit,
+            chatHistories,
+            log,
+          });
+          return;
+        }
+      } else if (!ctx.mentionedBot && !allowMentionlessInMultiBotGroup) {
+        // Safety default for mention-free mode: only allow non-@ traffic when the group has <= 1 bot.
+        // In multi-bot groups, explicit @ is required unless allowMentionlessInMultiBotGroup=true.
+        const botCount = await resolveFeishuGroupBotCount({
+          account,
+          chatId: ctx.chatId,
+          log,
+        });
+        const singleBotGroup = botCount !== undefined && botCount <= 1;
+        if (!singleBotGroup) {
+          if (botCount === undefined) {
+            log(
+              `feishu[${account.accountId}]: unable to resolve bot_count for ${ctx.chatId}, mention-free mode disabled for safety`,
+            );
+          } else {
+            log(
+              `feishu[${account.accountId}]: group ${ctx.chatId} has ${botCount} bots, explicit @ required unless allowMentionlessInMultiBotGroup=true`,
+            );
           }
+          skipGroupMessageForMentionGate({
+            accountId: account.accountId,
+            chatId: ctx.chatId,
+            senderOpenId: ctx.senderOpenId,
+            senderName: ctx.senderName,
+            content: ctx.content,
+            messageId: ctx.messageId,
+            historyLimit,
+            chatHistories,
+            log,
+          });
           return;
         }
       }
@@ -1066,7 +1395,7 @@ export async function handleFeishuMessage(params: {
         const quotedMsg = await getMessageFeishu({ cfg, messageId: ctx.parentId, accountId: account.accountId });
         if (quotedMsg) {
           quotedContent = quotedMsg.content;
-          log(`feishu[${account.accountId}]: fetched quoted message: ${quotedContent?.slice(0, 100)}`);
+          log(`feishu[${account.accountId}]: fetched quoted message ${ctx.parentId}`);
         }
       } catch (err) {
         log(`feishu[${account.accountId}]: failed to fetch quoted message: ${String(err)}`);
@@ -1075,12 +1404,23 @@ export async function handleFeishuMessage(params: {
 
     const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
 
-    // Build message body with quoted content if available
-    let messageBody = ctx.content;
+    // Build core message content with quoted content if available.
+    // Keep this separate from speaker/system prefixes so RawBody preserves quote context.
+    let rawBody = ctx.content;
     if (quotedContent) {
-      messageBody = `[Replying to: "${quotedContent}"]\n\n${ctx.content}`;
+      const normalizedQuoted = quotedContent.replace(/\s+/g, " ").trim();
+      const normalizedBody = ctx.content.replace(/\s+/g, " ").trim();
+      const quoteAlreadyInBody =
+        normalizedQuoted.length > 16 && normalizedBody.length > 0 && normalizedBody.includes(normalizedQuoted);
+      if (quoteAlreadyInBody) {
+        log(`feishu[${account.accountId}]: skip duplicate quote merge for message ${ctx.messageId}`);
+      } else {
+        rawBody = `[Replying to: "${quotedContent}"]\n\n${ctx.content}`;
+      }
     }
 
+    let messageBody = rawBody;
+
     // Include a readable speaker label so the model can attribute instructions.
     // (DMs already have per-sender sessions, but the prefix is still useful for clarity.)
     const speaker = ctx.senderName ?? ctx.senderOpenId;
@@ -1093,6 +1433,7 @@ export async function handleFeishuMessage(params: {
     }
 
     const envelopeFrom = isGroup ? `${ctx.chatId}:${ctx.senderOpenId}` : ctx.senderOpenId;
+    const replyToMessageId = replyToMessageIdOverride ?? ctx.rootId ?? ctx.messageId;
 
     // If there's a permission error, dispatch a separate notification first
     if (permissionErrorForAgent) {
@@ -1135,8 +1476,9 @@ export async function handleFeishuMessage(params: {
           agentId: route.agentId,
           runtime: runtime as RuntimeEnv,
           chatId: ctx.chatId,
-          replyToMessageId: ctx.messageId,
+          replyToMessageId,
           accountId: account.accountId,
+          messageCreateTimeMs,
         });
 
       log(`feishu[${account.accountId}]: dispatching permission error notification to agent`);
@@ -1191,8 +1533,8 @@ export async function handleFeishuMessage(params: {
 
     const ctxPayload = core.channel.reply.finalizeInboundContext({
       Body: combinedBody,
-      RawBody: ctx.content,
-      CommandBody: ctx.content,
+      RawBody: rawBody,
+      CommandBody: rawBody,
       From: feishuFrom,
       To: feishuTo,
       SessionKey: route.sessionKey,
@@ -1209,6 +1551,7 @@ export async function handleFeishuMessage(params: {
       CommandAuthorized: commandAuthorized,
       OriginatingChannel: "feishu" as const,
       OriginatingTo: feishuTo,
+      GroupSystemPrompt: isGroup ? groupConfig?.systemPrompt?.trim() || undefined : undefined,
       ReplyToBody: quotedContent,
       ...mediaPayload,
     });
@@ -1218,9 +1561,10 @@ export async function handleFeishuMessage(params: {
       agentId: route.agentId,
       runtime: runtime as RuntimeEnv,
       chatId: ctx.chatId,
-      replyToMessageId: ctx.messageId,
+      replyToMessageId,
       mentionTargets: ctx.mentionTargets,
       accountId: account.accountId,
+      messageCreateTimeMs,
     });
 
     log(`feishu[${account.accountId}]: dispatching to agent (session=${route.sessionKey})`);

package/src/channel.ts

@@ -91,6 +91,7 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
         groupAllowFrom: { type: "array", items: { oneOf: [{ type: "string" }, { type: "number" }] } },
         requireMention: { type: "boolean" },
         groupCommandMentionBypass: { type: "string", enum: ["never", "single_bot", "always"] },
+        allowMentionlessInMultiBotGroup: { type: "boolean" },
         topicSessionMode: { type: "string", enum: ["disabled", "enabled"] },
         historyLimit: { type: "integer", minimum: 0 },
         dmHistoryLimit: { type: "integer", minimum: 0 },
@@ -114,6 +115,7 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
               connectionMode: { type: "string", enum: ["websocket", "webhook"] },
               mediaLocalRoots: { type: "array", items: { type: "string" } },
               groupCommandMentionBypass: { type: "string", enum: ["never", "single_bot", "always"] },
+              allowMentionlessInMultiBotGroup: { type: "boolean" },
             },
           },
         },