@superbenxxxh/feishu 1.0.0 → 2.0.1

package/README.md

@@ -93,17 +93,18 @@ channels:
     requireMention: true
     # Max media size in MB (default: 30)
     mediaMaxMb: 30
-    # Render mode for bot replies: "auto" | "raw" | "card"
-    renderMode: "auto"
+    # Render mode for bot replies: "post" | "auto" | "raw" | "card"
+    renderMode: "post"
 ```
 
 #### Render Mode
 
-| Mode | Description |
-|------|-------------|
-| `auto` | (Default) Automatically detect: use card for messages with code blocks or tables, plain text otherwise. |
-| `raw` | Always send replies as plain text. Markdown tables are converted to ASCII. |
-| `card` | Always send replies as interactive cards with full markdown rendering (syntax highlighting, tables, clickable links). |
+| Mode | Description |
+|------|-------------|
+| `post` | (Default) Send replies as rich text posts using `msg_type=post` + `tag=md`. |
+| `auto` | Automatically detect: use card for messages with code blocks or tables, plain text otherwise. |
+| `raw` | Always send replies as plain text. Markdown tables are converted to ASCII. |
+| `card` | Always send replies as interactive cards with full markdown rendering (syntax highlighting, tables, clickable links). |
 
 ### Features
 
@@ -256,17 +257,18 @@ channels:
     requireMention: true
     # 媒体文件最大大小 (MB, 默认 30)
     mediaMaxMb: 30
-    # 回复渲染模式: "auto" | "raw" | "card"
-    renderMode: "auto"
+    # 回复渲染模式: "post" | "auto" | "raw" | "card"
+    renderMode: "post"
 ```
 
 #### 渲染模式
 
-| 模式 | 说明 |
-|------|------|
-| `auto` | （默认）自动检测：有代码块或表格时用卡片，否则纯文本 |
-| `raw` | 始终纯文本，表格转为 ASCII |
-| `card` | 始终使用卡片，支持语法高亮、表格、链接等 |
+| 模式 | 说明 |
+|------|------|
+| `post` | （默认）使用富文本 post（`msg_type=post` + `tag=md`）。 |
+| `auto` | 自动检测：有代码块或表格时用卡片，否则纯文本 |
+| `raw` | 始终纯文本，表格转为 ASCII |
+| `card` | 始终使用卡片，支持语法高亮、表格、链接等 |
 
 ### 功能
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superbenxxxh/feishu",
-  "version": "1.0.0",
+  "version": "2.0.1",
   "type": "module",
   "description": "OpenClaw Feishu/Lark channel plugin",
   "license": "MIT",
@@ -39,7 +39,7 @@
       "order": 70
     },
     "install": {
-      "npmSpec": "@m1heng-clawd/feishu",
+      "npmSpec": "@superbenxxxh/feishu",
       "localPath": ".",
       "defaultChoice": "npm"
     }

package/src/bot.ts

@@ -7,8 +7,8 @@ import {
   type HistoryEntry,
 } from "openclaw/plugin-sdk";
 import type { FeishuConfig, FeishuMessageContext, FeishuMediaInfo } from "./types.js";
-import { getFeishuRuntime } from "./runtime.js";
-import { createFeishuClient } from "./client.js";
+import { getFeishuRuntime } from "./runtime.js";
+import { createFeishuClient } from "./client.js";
 import {
   resolveFeishuGroupConfig,
   resolveFeishuReplyPolicy,
@@ -18,11 +18,12 @@ import {
 import { createFeishuReplyDispatcher } from "./reply-dispatcher.js";
 import { getMessageFeishu } from "./send.js";
 import { downloadImageFeishu, downloadMessageResourceFeishu } from "./media.js";
-import {
-  extractMentionTargets,
-  extractMessageBody,
-  isMentionForwardRequest,
-} from "./mention.js";
+import {
+  extractMentionTargets,
+  extractMessageBody,
+  isMentionForwardRequest,
+} from "./mention.js";
+import { parsePostContent } from "./post.js";
 
 // --- Sender name resolution (so the agent can distinguish who is speaking in group chats) ---
 // Cache display names by open_id to avoid an API call on every message.
@@ -183,49 +184,9 @@ function parseMediaKeys(
  * Parse post (rich text) content and extract embedded image keys.
  * Post structure: { title?: string, content: [[{ tag, text?, image_key?, ... }]] }
  */
-function parsePostContent(content: string): {
-  textContent: string;
-  imageKeys: string[];
-} {
-  try {
-    const parsed = JSON.parse(content);
-    const title = parsed.title || "";
-    const contentBlocks = parsed.content || [];
-    let textContent = title ? `${title}\n\n` : "";
-    const imageKeys: string[] = [];
-
-    for (const paragraph of contentBlocks) {
-      if (Array.isArray(paragraph)) {
-        for (const element of paragraph) {
-          if (element.tag === "text") {
-            textContent += element.text || "";
-          } else if (element.tag === "a") {
-            // Link: show text or href
-            textContent += element.text || element.href || "";
-          } else if (element.tag === "at") {
-            // Mention: @username
-            textContent += `@${element.user_name || element.user_id || ""}`;
-          } else if (element.tag === "img" && element.image_key) {
-            // Embedded image
-            imageKeys.push(element.image_key);
-          }
-        }
-        textContent += "\n";
-      }
-    }
-
-    return {
-      textContent: textContent.trim() || "[富文本消息]",
-      imageKeys,
-    };
-  } catch {
-    return { textContent: "[富文本消息]", imageKeys: [] };
-  }
-}
-
-/**
- * Infer placeholder text based on message type.
- */
+/**
+ * Infer placeholder text based on message type.
+ */
 function inferPlaceholder(messageType: string): string {
   switch (messageType) {
     case "image":
@@ -467,27 +428,41 @@ export async function handleFeishuMessage(params: {
     feishuCfg?.historyLimit ?? cfg.messages?.groupChat?.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT,
   );
 
-  if (isGroup) {
-    const groupPolicy = feishuCfg?.groupPolicy ?? "open";
-    const groupAllowFrom = feishuCfg?.groupAllowFrom ?? [];
-    const groupConfig = resolveFeishuGroupConfig({ cfg: feishuCfg, groupId: ctx.chatId });
-
-    const senderAllowFrom = groupConfig?.allowFrom ?? groupAllowFrom;
-    const allowed = isFeishuGroupAllowed({
-      groupPolicy,
-      allowFrom: senderAllowFrom,
-      senderId: ctx.senderOpenId,
-      senderName: ctx.senderName,
-    });
-
-    if (!allowed) {
-      log(`feishu: sender ${ctx.senderOpenId} not in group allowlist`);
-      return;
-    }
-
-    const { requireMention } = resolveFeishuReplyPolicy({
-      isDirectMessage: false,
-      globalConfig: feishuCfg,
+  if (isGroup) {
+    const groupPolicy = feishuCfg?.groupPolicy ?? "open";
+    const groupAllowFrom = feishuCfg?.groupAllowFrom ?? [];
+    const groupConfig = resolveFeishuGroupConfig({ cfg: feishuCfg, groupId: ctx.chatId });
+
+    const groupAllowed = isFeishuGroupAllowed({
+      groupPolicy,
+      allowFrom: groupAllowFrom,
+      senderId: ctx.chatId,
+      senderName: undefined,
+    });
+
+    if (!groupAllowed) {
+      log(`feishu: group ${ctx.chatId} not in allowlist`);
+      return;
+    }
+
+    const senderAllowFrom = groupConfig?.allowFrom ?? [];
+    if (senderAllowFrom.length > 0) {
+      const senderAllowed = isFeishuGroupAllowed({
+        groupPolicy: "allowlist",
+        allowFrom: senderAllowFrom,
+        senderId: ctx.senderOpenId,
+        senderName: ctx.senderName,
+      });
+
+      if (!senderAllowed) {
+        log(`feishu: sender ${ctx.senderOpenId} not in group ${ctx.chatId} allowlist`);
+        return;
+      }
+    }
+
+    const { requireMention } = resolveFeishuReplyPolicy({
+      isDirectMessage: false,
+      globalConfig: feishuCfg,
       groupConfig,
     });
 

package/src/channel.ts

@@ -85,10 +85,10 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
         textChunkLimit: { type: "integer", minimum: 1 },
         chunkMode: { type: "string", enum: ["length", "newline"] },
         mediaMaxMb: { type: "number", minimum: 0 },
-        renderMode: { type: "string", enum: ["auto", "raw", "card"] },
-      },
-    },
-  },
+        renderMode: { type: "string", enum: ["auto", "raw", "post", "card"] },
+      },
+    },
+  },
   config: {
     listAccountIds: () => [DEFAULT_ACCOUNT_ID],
     resolveAccount: (cfg) => resolveFeishuAccount({ cfg }),

package/src/config-schema.ts

@@ -30,8 +30,8 @@ const MarkdownConfigSchema = z
   .strict()
   .optional();
 
-// Message render mode: auto (default) = detect markdown, raw = plain text, card = always card
-const RenderModeSchema = z.enum(["auto", "raw", "card"]).optional();
+// Message render mode: post (default) = rich text, auto = detect markdown, raw = plain text, card = interactive card
+const RenderModeSchema = z.enum(["auto", "raw", "post", "card"]).optional();
 
 const BlockStreamingCoalesceSchema = z
   .object({
@@ -89,8 +89,8 @@ export const FeishuConfigSchema = z
     blockStreamingCoalesce: BlockStreamingCoalesceSchema,
     mediaMaxMb: z.number().positive().optional(),
     heartbeat: ChannelHeartbeatVisibilitySchema,
-    renderMode: RenderModeSchema, // raw = plain text (default), card = interactive card with markdown
-  })
+    renderMode: RenderModeSchema, // post = rich text (default), raw = plain text, card = interactive card
+  })
   .strict()
   .superRefine((value, ctx) => {
     if (value.dmPolicy === "open") {

package/src/post.ts

@@ -0,0 +1,129 @@
+import type { MentionTarget } from "./mention.js";
+
+type PostElement = {
+  tag: "text" | "a" | "at" | "img" | "md";
+  text?: string;
+  href?: string;
+  user_id?: string;
+  user_name?: string;
+  image_key?: string;
+};
+
+type PostLocalePayload = {
+  title?: string;
+  content?: PostElement[][];
+};
+
+type PostPayload = {
+  zh_cn?: PostLocalePayload;
+  en_us?: PostLocalePayload;
+  post?: {
+    zh_cn?: PostLocalePayload;
+    en_us?: PostLocalePayload;
+  };
+  title?: string;
+  content?: PostElement[][];
+};
+
+function resolvePostPayload(parsed: PostPayload): PostLocalePayload {
+  return (
+    parsed.zh_cn ||
+    parsed.en_us ||
+    parsed.post?.zh_cn ||
+    parsed.post?.en_us ||
+    {
+      title: parsed.title,
+      content: parsed.content,
+    }
+  );
+}
+
+function buildPostElements(messageText: string, mentions?: MentionTarget[]): PostElement[][] {
+  const elements: PostElement[] = [];
+
+  if (mentions && mentions.length > 0) {
+    for (const mention of mentions) {
+      elements.push({
+        tag: "at",
+        user_id: mention.openId,
+        user_name: mention.name,
+      });
+      elements.push({ tag: "text", text: " " });
+    }
+  }
+
+  elements.push({
+    tag: "md",
+    text: messageText,
+  });
+
+  return [elements];
+}
+
+export function buildFeishuPostMessagePayload(params: {
+  messageText: string;
+  mentions?: MentionTarget[];
+}): {
+  content: string;
+  msgType: "post";
+} {
+  const { messageText, mentions } = params;
+  const contentBlocks = buildPostElements(messageText, mentions);
+
+  const payload = {
+    zh_cn: { content: contentBlocks },
+    en_us: { content: contentBlocks },
+  };
+
+  return {
+    content: JSON.stringify(payload),
+    msgType: "post",
+  };
+}
+
+/**
+ * Parse post (rich text) content and extract embedded image keys.
+ * Post structure: { title?: string, content: [[{ tag, text?, image_key?, ... }]] }
+ */
+export function parsePostContent(content: string): {
+  textContent: string;
+  imageKeys: string[];
+} {
+  try {
+    const parsed = JSON.parse(content) as PostPayload;
+    const resolved = resolvePostPayload(parsed);
+    const title = resolved.title || "";
+    const contentBlocks = resolved.content || [];
+    let textContent = title ? `${title}\n\n` : "";
+    const imageKeys: string[] = [];
+
+    for (const paragraph of contentBlocks) {
+      if (Array.isArray(paragraph)) {
+        for (const element of paragraph) {
+          if (element.tag === "text") {
+            textContent += element.text || "";
+          } else if (element.tag === "a") {
+            // Link: show text or href
+            textContent += element.text || element.href || "";
+          } else if (element.tag === "at") {
+            // Mention: @username
+            textContent += `@${element.user_name || element.user_id || ""}`;
+          } else if (element.tag === "img" && element.image_key) {
+            // Embedded image
+            imageKeys.push(element.image_key);
+          } else if (element.tag === "md") {
+            textContent += element.text || "";
+          }
+        }
+        textContent += "\n";
+      }
+    }
+
+    return {
+      textContent: textContent.trim() || "[富文本消息]",
+      imageKeys,
+    };
+  } catch {
+    return { textContent: "[富文本消息]", imageKeys: [] };
+  }
+}

package/src/reply-dispatcher.ts

@@ -106,13 +106,14 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
           return;
         }
 
-        // Check render mode: auto (default), raw, or card
-        const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-        const renderMode = feishuCfg?.renderMode ?? "auto";
-
-        // Determine if we should use card for this message
-        const useCard =
-          renderMode === "card" || (renderMode === "auto" && shouldUseCard(text));
+        // Check render mode: post (default), auto, raw, or card
+        const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+        const renderMode = feishuCfg?.renderMode ?? "post";
+
+        // Determine if we should use card for this message
+        const useCard =
+          renderMode === "card" || (renderMode === "auto" && shouldUseCard(text));
+        const usePost = renderMode === "post";
 
         // Only include @mentions in the first chunk (avoid duplicate @s)
         let isFirstChunk = true;
@@ -131,22 +132,25 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
             });
             isFirstChunk = false;
           }
-        } else {
-          // Raw mode: send as plain text with table conversion
-          const converted = core.channel.text.convertMarkdownTables(text, tableMode);
-          const chunks = core.channel.text.chunkTextWithMode(converted, textChunkLimit, chunkMode);
-          params.runtime.log?.(`feishu deliver: sending ${chunks.length} text chunks to ${chatId}`);
-          for (const chunk of chunks) {
-            await sendMessageFeishu({
-              cfg,
-              to: chatId,
-              text: chunk,
-              replyToMessageId,
-              mentions: isFirstChunk ? mentionTargets : undefined,
-            });
-            isFirstChunk = false;
-          }
-        }
+        } else {
+          // Raw or post mode: send as plain text or rich post with table conversion
+          const converted = core.channel.text.convertMarkdownTables(text, tableMode);
+          const chunks = core.channel.text.chunkTextWithMode(converted, textChunkLimit, chunkMode);
+          params.runtime.log?.(
+            `feishu deliver: sending ${chunks.length} ${usePost ? "post" : "text"} chunks to ${chatId}`,
+          );
+          for (const chunk of chunks) {
+            await sendMessageFeishu({
+              cfg,
+              to: chatId,
+              text: chunk,
+              replyToMessageId,
+              mentions: isFirstChunk ? mentionTargets : undefined,
+              messageType: usePost ? "post" : "text",
+            });
+            isFirstChunk = false;
+          }
+        }
       },
       onError: (err, info) => {
         params.runtime.error?.(`feishu ${info.kind} reply failed: ${String(err)}`);

package/src/send.ts

@@ -1,11 +1,16 @@
-import type { ClawdbotConfig } from "openclaw/plugin-sdk";
-import type { FeishuConfig, FeishuSendResult } from "./types.js";
-import type { MentionTarget } from "./mention.js";
-import { buildMentionedMessage, buildMentionedCardContent } from "./mention.js";
-import { createFeishuClient } from "./client.js";
-import { resolveReceiveIdType, normalizeFeishuTarget } from "./targets.js";
-import { getFeishuRuntime } from "./runtime.js";
-
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import type { FeishuConfig, FeishuSendResult } from "./types.js";
+import type { MentionTarget } from "./mention.js";
+import { buildMentionedMessage, buildMentionedCardContent } from "./mention.js";
+import { createFeishuClient } from "./client.js";
+import { resolveReceiveIdType, normalizeFeishuTarget } from "./targets.js";
+import { getFeishuRuntime } from "./runtime.js";
+import { buildFeishuPostMessagePayload, parsePostContent } from "./post.js";
+
+type MarkdownTableMode = ReturnType<
+  ReturnType<typeof getFeishuRuntime>["channel"]["text"]["resolveMarkdownTableMode"]
+>;
+
 export type FeishuMessageInfo = {
   messageId: string;
   chatId: string;
@@ -63,16 +68,20 @@ export async function getMessageFeishu(params: {
       return null;
     }
 
-    // Parse content based on message type
-    let content = item.body?.content ?? "";
-    try {
-      const parsed = JSON.parse(content);
-      if (item.msg_type === "text" && parsed.text) {
-        content = parsed.text;
-      }
-    } catch {
-      // Keep raw content if parsing fails
-    }
+    // Parse content based on message type
+    let content = item.body?.content ?? "";
+    if (item.msg_type === "post") {
+      content = parsePostContent(content).textContent;
+    } else {
+      try {
+        const parsed = JSON.parse(content);
+        if (item.msg_type === "text" && parsed.text) {
+          content = parsed.text;
+        }
+      } catch {
+        // Keep raw content if parsing fails
+      }
+    }
 
     return {
       messageId: item.message_id ?? messageId,
@@ -88,22 +97,42 @@ export async function getMessageFeishu(params: {
   }
 }
 
-export type SendFeishuMessageParams = {
-  cfg: ClawdbotConfig;
-  to: string;
-  text: string;
-  replyToMessageId?: string;
-  /** Mention target users */
-  mentions?: MentionTarget[];
-};
-
-export async function sendMessageFeishu(params: SendFeishuMessageParams): Promise<FeishuSendResult> {
-  const { cfg, to, text, replyToMessageId, mentions } = params;
-  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg) {
-    throw new Error("Feishu channel not configured");
-  }
-
+export type SendFeishuMessageParams = {
+  cfg: ClawdbotConfig;
+  to: string;
+  text: string;
+  replyToMessageId?: string;
+  /** Mention target users */
+  mentions?: MentionTarget[];
+  /** Send as text (default) or post (rich text) */
+  messageType?: "text" | "post";
+};
+
+function buildFeishuTextMessagePayload(params: {
+  rawText: string;
+  tableMode: MarkdownTableMode;
+  mentions?: MentionTarget[];
+}): {
+  content: string;
+  msgType: "text";
+} {
+  const { rawText, tableMode, mentions } = params;
+  const textWithMentions =
+    mentions && mentions.length > 0 ? buildMentionedMessage(mentions, rawText) : rawText;
+  const text = getFeishuRuntime().channel.text.convertMarkdownTables(textWithMentions, tableMode);
+  return {
+    content: JSON.stringify({ text }),
+    msgType: "text",
+  };
+}
+
+export async function sendMessageFeishu(params: SendFeishuMessageParams): Promise<FeishuSendResult> {
+  const { cfg, to, text, replyToMessageId, mentions, messageType } = params;
+  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+  if (!feishuCfg) {
+    throw new Error("Feishu channel not configured");
+  }
+
   const client = createFeishuClient(feishuCfg);
   const receiveId = normalizeFeishuTarget(to);
   if (!receiveId) {
@@ -111,28 +140,34 @@ export async function sendMessageFeishu(params: SendFeishuMessageParams): Promis
   }
 
   const receiveIdType = resolveReceiveIdType(receiveId);
-  const tableMode = getFeishuRuntime().channel.text.resolveMarkdownTableMode({
-    cfg,
-    channel: "feishu",
-  });
-
-  // Build message content (with @mention support)
-  let rawText = text ?? "";
-  if (mentions && mentions.length > 0) {
-    rawText = buildMentionedMessage(mentions, rawText);
-  }
-  const messageText = getFeishuRuntime().channel.text.convertMarkdownTables(rawText, tableMode);
-
-  const content = JSON.stringify({ text: messageText });
-
-  if (replyToMessageId) {
-    const response = await client.im.message.reply({
-      path: { message_id: replyToMessageId },
-      data: {
-        content,
-        msg_type: "text",
-      },
-    });
+  const tableMode = getFeishuRuntime().channel.text.resolveMarkdownTableMode({
+    cfg,
+    channel: "feishu",
+  });
+
+  const rawText = text ?? "";
+  const baseMessageText = getFeishuRuntime().channel.text.convertMarkdownTables(rawText, tableMode);
+
+  const payload =
+    messageType === "post"
+      ? buildFeishuPostMessagePayload({
+          messageText: baseMessageText,
+          mentions,
+        })
+      : buildFeishuTextMessagePayload({
+          rawText,
+          tableMode,
+          mentions,
+        });
+
+  if (replyToMessageId) {
+    const response = await client.im.message.reply({
+      path: { message_id: replyToMessageId },
+      data: {
+        content: payload.content,
+        msg_type: payload.msgType,
+      },
+    });
 
     if (response.code !== 0) {
       throw new Error(`Feishu reply failed: ${response.msg || `code ${response.code}`}`);
@@ -144,14 +179,14 @@ export async function sendMessageFeishu(params: SendFeishuMessageParams): Promis
     };
   }
 
-  const response = await client.im.message.create({
-    params: { receive_id_type: receiveIdType },
-    data: {
-      receive_id: receiveId,
-      content,
-      msg_type: "text",
-    },
-  });
+  const response = await client.im.message.create({
+    params: { receive_id_type: receiveIdType },
+    data: {
+      receive_id: receiveId,
+      content: payload.content,
+      msg_type: payload.msgType,
+    },
+  });
 
   if (response.code !== 0) {
     throw new Error(`Feishu send failed: ${response.msg || `code ${response.code}`}`);
@@ -292,32 +327,37 @@ export async function sendMarkdownCardFeishu(params: {
  * Edit an existing text message.
  * Note: Feishu only allows editing messages within 24 hours.
  */
-export async function editMessageFeishu(params: {
-  cfg: ClawdbotConfig;
-  messageId: string;
-  text: string;
-}): Promise<void> {
-  const { cfg, messageId, text } = params;
-  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-  if (!feishuCfg) {
-    throw new Error("Feishu channel not configured");
-  }
-
+export async function editMessageFeishu(params: {
+  cfg: ClawdbotConfig;
+  messageId: string;
+  text: string;
+  messageType?: "text" | "post";
+}): Promise<void> {
+  const { cfg, messageId, text, messageType } = params;
+  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+  if (!feishuCfg) {
+    throw new Error("Feishu channel not configured");
+  }
+
   const client = createFeishuClient(feishuCfg);
-  const tableMode = getFeishuRuntime().channel.text.resolveMarkdownTableMode({
-    cfg,
-    channel: "feishu",
-  });
-  const messageText = getFeishuRuntime().channel.text.convertMarkdownTables(text ?? "", tableMode);
-  const content = JSON.stringify({ text: messageText });
-
-  const response = await client.im.message.update({
-    path: { message_id: messageId },
-    data: {
-      msg_type: "text",
-      content,
-    },
-  });
+  const tableMode = getFeishuRuntime().channel.text.resolveMarkdownTableMode({
+    cfg,
+    channel: "feishu",
+  });
+  const rawText = text ?? "";
+  const baseMessageText = getFeishuRuntime().channel.text.convertMarkdownTables(rawText, tableMode);
+  const payload =
+    messageType === "post"
+      ? buildFeishuPostMessagePayload({ messageText: baseMessageText })
+      : buildFeishuTextMessagePayload({ rawText, tableMode });
+
+  const response = await client.im.message.update({
+    path: { message_id: messageId },
+    data: {
+      msg_type: payload.msgType,
+      content: payload.content,
+    },
+  });
 
   if (response.code !== 0) {
     throw new Error(`Feishu message edit failed: ${response.msg || `code ${response.code}`}`);