work-ally 0.2.0-alpha.1

package/bridge/src/channels/feishu/adapter.ts

@@ -0,0 +1,411 @@
+import { EventEmitter } from 'node:events';
+import lark from '@larksuiteoapi/node-sdk';
+import type { ChannelAdapter, InboundHandler, OutboundEnvelope } from '../../channel-types.ts';
+import type { ConnectionLifecycleEvent, InboundMessage } from '../../types.ts';
+import { renderFeishuMessages, renderFeishuPlainText, toInteractiveCard } from './formatter.ts';
+import { buildApprovalCardText } from './approvals.ts';
+import { extractFeishuMessageId, extractTextFromPayload, normalizeFeishuEvent, summarizeFeishuEvent } from './normalize.ts';
+import { logDebug, logError, logInfo, logWarn } from '../../logger.ts';
+import { normalizeChannelDeliveryError } from '../../channel-delivery.ts';
+
+export interface FeishuAdapterOptions {
+  appId: string;
+  appSecret: string;
+  reactEmoji: string;
+  allowedUserIds: string[];
+}
+
+interface FeishuSdkClient {
+  im: {
+    v1: {
+      messageReaction: {
+        create(payload: any): Promise<unknown>;
+      };
+      message: {
+        create(payload: any): Promise<unknown>;
+        get?(payload: any): Promise<any>;
+      };
+    };
+  };
+}
+
+interface FeishuWsClient {
+  start(options: any): void;
+  close?(params?: { force?: boolean }): void;
+  wsConfig?: {
+    getWSInstance?: () => {
+      terminate?: () => void;
+      on?: (event: string, handler: (...args: any[]) => void) => void;
+      off?: (event: string, handler: (...args: any[]) => void) => void;
+      removeListener?: (event: string, handler: (...args: any[]) => void) => void;
+    } | null;
+  };
+}
+
+interface FeishuAdapterDeps {
+  client?: FeishuSdkClient;
+  wsClientFactory?: (config: { appId: string; appSecret: string }) => FeishuWsClient;
+}
+
+export class FeishuAdapter implements ChannelAdapter {
+  private readonly inboundHandler: InboundHandler;
+  private readonly options: FeishuAdapterOptions;
+  private readonly client: FeishuSdkClient;
+  private readonly wsClientFactory: (config: { appId: string; appSecret: string }) => FeishuWsClient;
+  private wsClient: FeishuWsClient | null = null;
+  private readonly connectionEmitter = new EventEmitter();
+  private wsMonitorTimer: NodeJS.Timeout | null = null;
+  private observedWsInstance: any = null;
+  private sawOpenSinceStart = false;
+  private readonly handleWsOpen = () => {
+    const state = this.sawOpenSinceStart ? 'reconnected' : null;
+    this.sawOpenSinceStart = true;
+    if (!state) {
+      return;
+    }
+    this.emitConnectionEvent({ source: 'feishu', state, reason: null, attempt: null, nextRetryDelayMs: null });
+  };
+  private readonly handleWsClose = () => {
+    this.emitConnectionEvent({ source: 'feishu', state: 'disconnected', reason: 'connection closed', attempt: null, nextRetryDelayMs: null });
+    this.emitConnectionEvent({ source: 'feishu', state: 'reconnecting', reason: null, attempt: null, nextRetryDelayMs: null });
+  };
+  private readonly handleWsError = () => {
+    this.emitConnectionEvent({ source: 'feishu', state: 'disconnected', reason: 'connection error', attempt: null, nextRetryDelayMs: null });
+  };
+  private readonly dedupe = new Set<string>();
+  private readonly processing = new Set<string>();
+  private readonly reacted = new Set<string>();
+  private readonly debugEnabled = process.env.WORK_ALLY_FEISHU_DEBUG === '1';
+
+  constructor(inboundHandler: InboundHandler, options: FeishuAdapterOptions, deps: FeishuAdapterDeps = {}) {
+    this.inboundHandler = inboundHandler;
+    this.options = options;
+    this.client = deps.client ?? new lark.Client({
+      appId: options.appId,
+      appSecret: options.appSecret,
+      disableTokenCache: false,
+    }) as FeishuSdkClient;
+    this.wsClientFactory = deps.wsClientFactory ?? ((config) => new lark.WSClient(config) as FeishuWsClient);
+  }
+
+  private remember(set: Set<string>, value: string, limit = 2000): void {
+    set.add(value);
+    if (set.size > limit) {
+      const first = set.values().next().value;
+      if (first) {
+        set.delete(first);
+      }
+    }
+  }
+
+  private emitConnectionEvent(event: ConnectionLifecycleEvent): void {
+    this.connectionEmitter.emit('connectionLifecycle', event);
+  }
+
+  onConnectionEvent(listener: (event: ConnectionLifecycleEvent) => void): void {
+    this.connectionEmitter.on('connectionLifecycle', listener);
+  }
+
+  offConnectionEvent(listener: (event: ConnectionLifecycleEvent) => void): void {
+    this.connectionEmitter.off('connectionLifecycle', listener);
+  }
+
+  private detachObservedWsInstance(): void {
+    const instance = this.observedWsInstance;
+    if (!instance) {
+      return;
+    }
+    instance.off?.('open', this.handleWsOpen);
+    instance.removeListener?.('open', this.handleWsOpen);
+    instance.off?.('close', this.handleWsClose);
+    instance.removeListener?.('close', this.handleWsClose);
+    instance.off?.('error', this.handleWsError);
+    instance.removeListener?.('error', this.handleWsError);
+    this.observedWsInstance = null;
+  }
+
+  private attachWsLifecycle(instance: any): void {
+    if (!instance || this.observedWsInstance === instance) {
+      return;
+    }
+    this.detachObservedWsInstance();
+    instance.on?.('open', this.handleWsOpen);
+    instance.on?.('close', this.handleWsClose);
+    instance.on?.('error', this.handleWsError);
+    this.observedWsInstance = instance;
+  }
+
+  private startWsMonitor(): void {
+    this.stopWsMonitor();
+    const bindLatest = () => {
+      const instance = this.wsClient?.wsConfig?.getWSInstance?.() || null;
+      if (instance) {
+        this.attachWsLifecycle(instance);
+      }
+    };
+    bindLatest();
+    this.wsMonitorTimer = setInterval(bindLatest, 1000);
+    this.wsMonitorTimer.unref?.();
+  }
+
+  private stopWsMonitor(): void {
+    if (this.wsMonitorTimer) {
+      clearInterval(this.wsMonitorTimer);
+      this.wsMonitorTimer = null;
+    }
+    this.detachObservedWsInstance();
+  }
+
+  private debug(message: string, meta?: unknown): void {
+    if (!this.debugEnabled) {
+      return;
+    }
+    if (meta === undefined) {
+      console.log(`[feishu-debug] ${message}`);
+      return;
+    }
+    console.log(`[feishu-debug] ${message}`, JSON.stringify(meta));
+  }
+
+  async start(): Promise<void> {
+    logInfo('feishu', 'ws_starting', {
+      allowlistSize: this.options.allowedUserIds.length,
+    });
+    const dispatcher = new lark.EventDispatcher({}).register({
+      'im.message.receive_v1': async (data: any) => {
+        const summary = summarizeFeishuEvent(data);
+        this.debug('dispatcher received event', summary);
+        logInfo('feishu', 'event_received', summary);
+        await this.handleEvent(data);
+      },
+    });
+
+    this.wsClient = this.wsClientFactory({
+      appId: this.options.appId,
+      appSecret: this.options.appSecret,
+    });
+    this.sawOpenSinceStart = false;
+    this.wsClient.start({ eventDispatcher: dispatcher });
+    this.startWsMonitor();
+    logInfo('feishu', 'ws_started');
+  }
+
+  async stop(): Promise<void> {
+    logInfo('feishu', 'ws_stopping');
+    this.stopWsMonitor();
+    this.wsClient?.close?.({ force: true });
+    const instance = this.wsClient?.wsConfig?.getWSInstance?.();
+    instance?.terminate?.();
+  }
+
+  private async addReaction(messageId: string, emojiType = this.options.reactEmoji): Promise<void> {
+    const reactionKey = `${messageId}:${emojiType}`;
+    if (this.reacted.has(reactionKey)) {
+      return;
+    }
+    try {
+      await this.client.im.v1.messageReaction.create({
+        path: { message_id: messageId },
+        data: { reaction_type: { emoji_type: emojiType } },
+      });
+      this.remember(this.reacted, reactionKey);
+    } catch (error: any) {
+      const meta = {
+        messageId,
+        emojiType,
+        error: error?.message || String(error),
+      };
+      this.debug('reaction create failed', meta);
+      logWarn('feishu', 'reaction_failed', meta);
+    }
+  }
+
+  private resolveReceiveTarget(conversationRef: OutboundEnvelope['conversationRef']): { receiveId: string; receiveIdType: 'chat_id' | 'open_id' } {
+    const receiveId = String(conversationRef.conversationId || '').trim();
+    const chatType = String(conversationRef.chatType || '').trim().toLowerCase();
+    if ((chatType === 'p2p' || chatType === 'single' || chatType === 'dm') && receiveId.startsWith('ou_')) {
+      return { receiveId, receiveIdType: 'open_id' };
+    }
+    return { receiveId, receiveIdType: 'chat_id' };
+  }
+
+  private async sendMessage(receiveId: string, receiveIdType: 'chat_id' | 'open_id', messageType: string, content: string): Promise<void> {
+    try {
+      await this.client.im.v1.message.create({
+        params: { receive_id_type: receiveIdType },
+        data: {
+          receive_id: receiveId,
+          msg_type: messageType,
+          content,
+        },
+      });
+      logInfo('feishu', 'message_sent', {
+        receiveId,
+        receiveIdType,
+        messageType,
+        contentLength: content.length,
+      });
+    } catch (error) {
+      logError('feishu', 'message_send_failed', {
+        receiveId,
+        receiveIdType,
+        messageType,
+        error: error instanceof Error ? (error.stack || error.message) : String(error),
+      });
+      throw normalizeChannelDeliveryError('feishu', error);
+    }
+  }
+
+  private async fetchMessageSnapshot(messageId: string): Promise<{ text: string | null }> {
+    const getter = this.client.im.v1.message.get;
+    if (typeof getter !== 'function') {
+      return { text: null };
+    }
+
+    try {
+      const response = await getter({ path: { message_id: messageId } });
+      const rawData = response?.data;
+      const rawItems = Array.isArray(rawData?.items) ? rawData.items : null;
+      if (rawItems && rawItems.length > 0) {
+        const text = extractTextFromPayload(JSON.stringify({ items: rawItems }), 'merge_forward').trim() || null;
+        if (text) {
+          return { text };
+        }
+      }
+
+      const rawItem = rawItems?.[0] ?? rawData;
+      if (!rawItem) {
+        return { text: null };
+      }
+      const messageType = String(rawItem.msg_type || rawItem.message_type || 'text');
+      const rawContent = String(rawItem.body?.content || rawItem.content || '');
+      return { text: extractTextFromPayload(rawContent, messageType).trim() || null };
+    } catch (error) {
+      logWarn('feishu', 'reply_context_fetch_failed', {
+        messageId,
+        error: error instanceof Error ? (error.stack || error.message) : String(error),
+      });
+      return { text: null };
+    }
+  }
+
+  private async hydrateInboundTextIfNeeded(inbound: InboundMessage): Promise<InboundMessage> {
+    if (inbound.text.trim()) {
+      return inbound;
+    }
+
+    const snapshot = await this.fetchMessageSnapshot(inbound.messageId);
+    if (!snapshot.text) {
+      return inbound;
+    }
+
+    return {
+      ...inbound,
+      text: snapshot.text,
+    };
+  }
+
+  private async enrichReplyContext(inbound: InboundMessage): Promise<InboundMessage> {
+    if (!inbound.replyToMessageId) {
+      return inbound;
+    }
+    const snapshot = await this.fetchMessageSnapshot(inbound.replyToMessageId);
+    return {
+      ...inbound,
+      replyToText: snapshot.text,
+    };
+  }
+
+  async handleEvent(event: any): Promise<void> {
+    const summary = summarizeFeishuEvent(event);
+    const messageId = extractFeishuMessageId(event);
+    if (!messageId) {
+      this.debug('skipping event without messageId', summary);
+      logWarn('feishu', 'event_skipped_missing_message_id', summary);
+      return;
+    }
+    if (this.dedupe.has(messageId)) {
+      this.debug('skipping duplicate event', summary);
+      logDebug('feishu', 'event_deduped', summary);
+      return;
+    }
+    if (this.processing.has(messageId)) {
+      this.debug('skipping inflight duplicate event', summary);
+      logDebug('feishu', 'event_inflight_duplicate', summary);
+      return;
+    }
+    this.remember(this.processing, messageId);
+
+    try {
+      const inbound = normalizeFeishuEvent(event, this.options.allowedUserIds);
+      if (!inbound) {
+        const meta = {
+          ...summary,
+          allowlistSize: this.options.allowedUserIds.length,
+        };
+        this.debug('rejected inbound event', meta);
+        logWarn('feishu', 'event_rejected', meta);
+        this.remember(this.dedupe, messageId);
+        return;
+      }
+
+      const hydratedInbound = await this.hydrateInboundTextIfNeeded(inbound);
+      const enriched = await this.enrichReplyContext(hydratedInbound);
+      const acceptanceReason = enriched.conversationRef.chatType === 'group'
+        ? 'group_platform_filtered'
+        : 'direct_chat';
+      this.debug('accepted inbound event', {
+        ...summary,
+        reason: acceptanceReason,
+        replyToMessageId: enriched.replyToMessageId || null,
+        hasReplyToText: Boolean(enriched.replyToText),
+      });
+      logInfo('feishu', 'event_accepted', {
+        ...summary,
+        reason: acceptanceReason,
+        replyToMessageId: enriched.replyToMessageId || null,
+        hasReplyToText: Boolean(enriched.replyToText),
+      });
+      await this.addReaction(enriched.messageId);
+      await this.inboundHandler.handleInbound(enriched);
+      this.remember(this.dedupe, messageId);
+    } catch (error) {
+      logError('feishu', 'event_handle_failed', {
+        ...summary,
+        error: error instanceof Error ? (error.stack || error.message) : String(error),
+      });
+      throw error;
+    } finally {
+      this.processing.delete(messageId);
+    }
+  }
+
+  async send(outbound: OutboundEnvelope): Promise<void> {
+    const target = this.resolveReceiveTarget(outbound.conversationRef);
+    if (outbound.type === 'ack_received') {
+      logDebug('feishu', 'ack_reaction_requested', {
+        messageId: outbound.messageId,
+        emoji: outbound.emoji || this.options.reactEmoji,
+      });
+      await this.addReaction(outbound.messageId, outbound.emoji || this.options.reactEmoji);
+      return;
+    }
+
+    if (outbound.type === 'approval_requested') {
+      const cardText = String(outbound.text || '').trim() || buildApprovalCardText(outbound.approval);
+      await this.sendMessage(target.receiveId, target.receiveIdType, 'interactive', toInteractiveCard(cardText));
+      return;
+    }
+
+    if (outbound.type === 'user_input_requested') {
+      for (const rendered of renderFeishuPlainText(outbound.text)) {
+        await this.sendMessage(target.receiveId, target.receiveIdType, rendered.messageType, rendered.content);
+      }
+      return;
+    }
+
+    for (const rendered of renderFeishuMessages(outbound.text)) {
+      await this.sendMessage(target.receiveId, target.receiveIdType, rendered.messageType, rendered.content);
+    }
+  }
+}

package/bridge/src/channels/feishu/approvals.ts

@@ -0,0 +1,6 @@
+import type { ApprovalRequest } from '../../types.ts';
+import { approvalMessage } from '../../translator.ts';
+
+export function buildApprovalCardText(approval: ApprovalRequest): string {
+  return approvalMessage(approval);
+}

package/bridge/src/channels/feishu/formatter.ts

@@ -0,0 +1,276 @@
+export interface FeishuRenderedMessage {
+  messageType: 'post' | 'interactive' | 'text';
+  content: string;
+}
+
+const TEXT_MAX_LEN = 4000;
+const TABLE_RE = /((?:^[ \t]*\|.+\|[ \t]*\n)(?:^[ \t]*\|[-:\s|]+\|[ \t]*\n)(?:^[ \t]*\|.+\|[ \t]*\n?)+)/gm;
+const HEADING_RE = /^(#{1,6})\s+(.+)$/gm;
+const CODE_BLOCK_RE = /```(?:[a-zA-Z0-9_+-]+)?\n?([\s\S]*?)```/g;
+const TABLE_DETECT_RE = /(?:^[ \t]*\|.+\|[ \t]*\n)(?:^[ \t]*\|[-:\s|]+\|[ \t]*\n)(?:^[ \t]*\|.+\|[ \t]*\n?)+/m;
+const SYSTEM_NOTICE_RE = /^\s*(?:\*\*)?【系统消息】(?:\*\*)?/;
+const WORKING_NOTICE_RE = /^\s*(?:\*\*)?(?:【工作中】|⏳ 工作中)(?:\*\*)?/;
+
+function buildLarkDiv(content: string): Record<string, unknown> {
+  return {
+    tag: 'div',
+    text: {
+      tag: 'lark_md',
+      content,
+    },
+  };
+}
+
+function buildLarkHr(): Record<string, unknown> {
+  return { tag: 'hr' };
+}
+
+function buildLarkNote(content: string): Record<string, unknown> {
+  return {
+    tag: 'note',
+    elements: [
+      {
+        tag: 'plain_text',
+        content,
+      },
+    ],
+  };
+}
+
+function stripNoticePrefix(content: string, pattern: RegExp): string {
+  return content.replace(pattern, '').trim();
+}
+
+function buildWorkingNoticeCard(content: string): string {
+  const body = stripNoticePrefix(content.trim(), WORKING_NOTICE_RE) || '正在处理中';
+  return buildCard([
+    buildLarkDiv('**工作进展**'),
+    buildLarkHr(),
+    buildLarkDiv(body),
+    buildLarkNote('状态提示，不是最终回复'),
+  ]);
+}
+
+function buildCard(elements: Record<string, unknown>[]): string {
+  return JSON.stringify({
+    config: { wide_screen_mode: true },
+    elements,
+  });
+}
+
+function buildPostMessage(content: string): FeishuRenderedMessage {
+  return {
+    messageType: 'post',
+    content: JSON.stringify({
+      zh_cn: {
+        content: [
+          [
+            {
+              tag: 'md',
+              text: content,
+            },
+          ],
+        ],
+      },
+    }),
+  };
+}
+
+function parseMarkdownTable(tableText: string): Record<string, unknown> | null {
+  const lines = tableText.trim().split('\n').map((line) => line.trim()).filter(Boolean);
+  if (lines.length < 3) {
+    return null;
+  }
+  const split = (line: string) => line.replace(/^\|/, '').replace(/\|$/, '').split('|').map((cell) => cell.trim());
+  const headers = split(lines[0]);
+  const rows = lines.slice(2).map(split);
+  return {
+    tag: 'table',
+    page_size: rows.length + 1,
+    columns: headers.map((header, index) => ({
+      tag: 'column',
+      name: `c${index}`,
+      display_name: header,
+      width: 'auto',
+    })),
+    rows: rows.map((row) => Object.fromEntries(headers.map((_, index) => [`c${index}`, row[index] ?? '']))),
+  };
+}
+
+function splitHeadings(content: string): Record<string, unknown>[] {
+  let protectedContent = content;
+  const codeBlocks: string[] = [];
+  for (const match of content.matchAll(CODE_BLOCK_RE)) {
+    const block = match[0];
+    const token = `\u0000CODE${codeBlocks.length}\u0000`;
+    codeBlocks.push(block);
+    protectedContent = protectedContent.replace(block, token);
+  }
+
+  const elements: Record<string, unknown>[] = [];
+  let lastIndex = 0;
+  for (const match of protectedContent.matchAll(HEADING_RE)) {
+    const start = match.index ?? 0;
+    const before = protectedContent.slice(lastIndex, start).trim();
+    if (before) {
+      elements.push(buildLarkDiv(before));
+    }
+    const headingText = match[2].trim();
+    elements.push(buildLarkDiv(`**${headingText}**`));
+    lastIndex = start + match[0].length;
+  }
+  const rest = protectedContent.slice(lastIndex).trim();
+  if (rest) {
+    elements.push(buildLarkDiv(rest));
+  }
+
+  for (const element of elements) {
+    const text = (element.text as { content?: string } | undefined)?.content;
+    if (!text) {
+      continue;
+    }
+    let restored = text;
+    codeBlocks.forEach((block, index) => {
+      restored = restored.replace(`\u0000CODE${index}\u0000`, block);
+    });
+    (element.text as { content: string }).content = restored;
+  }
+
+  return elements.length ? elements : [buildLarkDiv(content.trim())];
+}
+
+function buildCardElements(content: string): Record<string, unknown>[] {
+  const elements: Record<string, unknown>[] = [];
+  let lastIndex = 0;
+  for (const match of content.matchAll(TABLE_RE)) {
+    const start = match.index ?? 0;
+    const before = content.slice(lastIndex, start);
+    if (before.trim()) {
+      elements.push(...splitHeadings(before));
+    }
+    elements.push(parseMarkdownTable(match[1]) ?? buildLarkDiv(match[1].trim()));
+    lastIndex = start + match[1].length;
+  }
+  const rest = content.slice(lastIndex);
+  if (rest.trim()) {
+    elements.push(...splitHeadings(rest));
+  }
+  return elements.length ? elements : [buildLarkDiv(content.trim())];
+}
+
+function splitElementsByTableLimit(elements: Record<string, unknown>[], maxTables = 1): Record<string, unknown>[][] {
+  if (!elements.length) {
+    return [[]];
+  }
+  const groups: Record<string, unknown>[][] = [];
+  let current: Record<string, unknown>[] = [];
+  let tableCount = 0;
+
+  for (const element of elements) {
+    if (element.tag === 'table') {
+      if (tableCount >= maxTables) {
+        if (current.length) {
+          groups.push(current);
+        }
+        current = [];
+        tableCount = 0;
+      }
+      current.push(element);
+      tableCount += 1;
+      continue;
+    }
+    current.push(element);
+  }
+
+  if (current.length) {
+    groups.push(current);
+  }
+  return groups.length ? groups : [[]];
+}
+
+function normalizeRichMarkdown(content: string): string {
+  return content
+    .replace(/\r\n/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+function splitMarkdownChunks(content: string, limit = TEXT_MAX_LEN): string[] {
+  const trimmed = normalizeRichMarkdown(content);
+  if (!trimmed) {
+    return [];
+  }
+
+  const chunks: string[] = [];
+  let remaining = trimmed;
+  while (remaining.length > limit) {
+    let cursor = remaining.lastIndexOf('\n\n', limit);
+    if (cursor < 0) cursor = remaining.lastIndexOf('\n', limit);
+    if (cursor < 0) cursor = remaining.lastIndexOf(' ', limit);
+    if (cursor < 0 || cursor < Math.floor(limit * 0.5)) cursor = limit;
+    chunks.push(remaining.slice(0, cursor).trim());
+    remaining = remaining.slice(cursor).trim();
+  }
+  if (remaining) {
+    chunks.push(remaining);
+  }
+  return chunks.filter(Boolean);
+}
+
+function toTextMessage(content: string): FeishuRenderedMessage {
+  return {
+    messageType: 'text',
+    content: JSON.stringify({ text: content }),
+  };
+}
+
+export function splitMarkdown(content: string, limit = TEXT_MAX_LEN): string[] {
+  return splitMarkdownChunks(content, limit);
+}
+
+function renderInteractiveCards(content: string): FeishuRenderedMessage[] {
+  const trimmed = content.trim();
+  if (WORKING_NOTICE_RE.test(trimmed)) {
+    return [{
+      messageType: 'interactive' as const,
+      content: buildWorkingNoticeCard(trimmed),
+    }];
+  }
+  return splitElementsByTableLimit(buildCardElements(trimmed))
+    .filter((group) => group.length > 0)
+    .map((group) => ({
+      messageType: 'interactive' as const,
+      content: buildCard(group),
+    }));
+}
+
+function shouldUseInteractiveCard(content: string): boolean {
+  return TABLE_DETECT_RE.test(content) || SYSTEM_NOTICE_RE.test(content) || WORKING_NOTICE_RE.test(content);
+}
+
+export function toInteractiveCard(content: string): string {
+  const trimmed = content.trim();
+  if (WORKING_NOTICE_RE.test(trimmed)) {
+    return buildWorkingNoticeCard(trimmed);
+  }
+  return buildCard(splitElementsByTableLimit(buildCardElements(trimmed)).flat());
+}
+
+export function renderFeishuMessages(content: string): FeishuRenderedMessage[] {
+  const trimmed = content.trim();
+  if (!trimmed) {
+    return [];
+  }
+  if (shouldUseInteractiveCard(trimmed)) {
+    return renderInteractiveCards(trimmed);
+  }
+  return splitMarkdownChunks(trimmed).map((chunk) => buildPostMessage(chunk));
+}
+
+export function renderFeishuPlainText(content: string): FeishuRenderedMessage[] {
+  const trimmed = content.trim();
+  if (!trimmed) {
+    return [];
+  }
+  return splitMarkdownChunks(trimmed).map((chunk) => toTextMessage(chunk));
+}