@m1heng-clawd/feishu 0.1.16 → 0.1.17

package/README.md

@@ -16,6 +16,22 @@ Feishu/Lark (飞书) channel plugin for [OpenClaw](https://github.com/openclaw/o
 
 ---
 
+## Sponsor
+
+![YouYun Zhisuan](./assets/sponsor-youyunzhisuan.png)
+
+Thanks to our sponsors for supporting the project.
+
+If you need an API key platform whose models can be used as an OpenClaw provider and work with Kimi, MiniMax, Claude Code, Codex, or direct API usage, YouYun Zhisuan is worth considering:
+
+> UCloud's YouYun Zhisuan is an AI cloud platform that provides stable and comprehensive domestic and international model APIs through a single API key. Its high-value Coding Plan offers both monthly and pay-as-you-go options, typically at 20% to 50% of official pricing. It supports Claude Code, Codex, and direct API integrations, as well as enterprise-grade high concurrency, 24/7 technical support, and self-service invoicing. Register through [this link](https://passport.compshare.cn/register?referral_code=5oWQU772rtSCeExpcLFxwy&ytag=GPU_YY_YX_git_clawdbot-feishu) to receive a free RMB 5 platform trial credit.
+
+感谢赞助方对本项目的支持。
+
+如果你需要一个可作为 OpenClaw 模型 provider，并适用于 Kimi、MiniMax、Claude Code、Codex 或直接 API 调用的稳定 API Key 平台，可以了解一下优云智算：
+
+> 优云智算是UCloud旗下AI云平台，提供稳定、全面的国内外模型API，仅一个key即可调用。主打包月、按量的高性价比 Coding Plan 套餐，基于官方2~5折优惠。支持接入 Claude Code、Codex 及 API 调用。支持企业高并发、7*24技术支持、自助开票。通过[此链接](https://passport.compshare.cn/register?referral_code=5oWQU772rtSCeExpcLFxwy&ytag=GPU_YY_YX_git_clawdbot-feishu)注册的用户，可得免费5元平台体验金！
+
 ## English
 
 ### Installation
@@ -113,6 +129,9 @@ openclaw plugins list | rg -i feishu
 | `task:attachment:read` | `feishu_task_attachment_list`, `feishu_task_attachment_get` | List/get task attachments |
 | `im:chat.announcement:read` | `feishu_chat` | Read group announcement |
 | `im:chat:readonly` | `feishu_chat` | Get chat info, check bot membership |
+| `im:message` or `im:message:readonly` | `feishu_message` | Read single/DM messages |
+| `im:message.group_at_msg:readonly` | `feishu_message` | Read all messages in group chats |
+| `im:message.reactions:read` | `feishu_reaction` | List reactions on messages |
 
 **Read-write** (optional, for create/edit/delete operations):
 
@@ -131,6 +150,7 @@ openclaw plugins list | rg -i feishu
 | `im:chat.announcement` | `feishu_chat` | Write/update group announcement |
 | `im:chat` | `feishu_chat` | Create and delete group chats |
 | `im:chat.members` | `feishu_chat` | Add members to group chats |
+| `im:message.reactions:write_only` | `feishu_reaction` | Add and remove reactions |
 
 > Task scope names may vary slightly in Feishu console UI. If needed, search for Task / Tasklist / Comment / Attachment-related permissions and grant read/write accordingly.
 
@@ -479,6 +499,8 @@ session:
 - **Task tools**: Create, get details, update, and delete tasks via Feishu Task v2 API
 - **Chat tools**: Read and write group announcements, create group chats, add members, check bot membership, delete chats (`feishu_chat`)
 - **Urgent notification tools**: Send buzz/urgent notifications (app, SMS, voice call) via `feishu_urgent`
+- **Message tools**: Read single messages or list recent chat history with time range and pagination (`feishu_message`)
+- **Reaction tools**: Add, remove, and list emoji reactions on messages (`feishu_reaction`)
 - **@mention forwarding**: When you @mention someone in your message, the bot's reply will automatically @mention them too
 - **Permission error notification**: When the bot encounters a Feishu API permission error, it automatically notifies the user with the permission grant URL
 - **Dynamic agent creation**: Each DM user can have their own isolated agent instance with dedicated workspace (optional)
@@ -629,6 +651,9 @@ openclaw plugins list | rg -i feishu
 | `task:attachment:read` | `feishu_task_attachment_list`, `feishu_task_attachment_get` | 列出/获取任务附件 |
 | `im:chat.announcement:read` | `feishu_chat` | 读取群公告 |
 | `im:chat:readonly` | `feishu_chat` | 获取群信息、检查机器人是否在群内 |
+| `im:message` 或 `im:message:readonly` | `feishu_message` | 读取单条/私聊消息 |
+| `im:message.group_at_msg:readonly` | `feishu_message` | 读取群聊中所有消息 |
+| `im:message.reactions:read` | `feishu_reaction` | 查看消息表情回复 |
 
 **读写权限**（可选，用于创建/编辑/删除操作）：
 
@@ -647,6 +672,7 @@ openclaw plugins list | rg -i feishu
 | `im:chat.announcement` | `feishu_chat` | 写入/更新群公告 |
 | `im:chat` | `feishu_chat` | 创建和删除群聊 |
 | `im:chat.members` | `feishu_chat` | 向群聊添加成员 |
+| `im:message.reactions:write_only` | `feishu_reaction` | 发送、删除消息表情回复 |
 
 > 飞书控制台中任务权限的显示名称可能略有差异，必要时可按关键字 `task` / `tasklist` / `comment` / `attachment` 搜索并授予对应读写权限。
 
@@ -994,6 +1020,8 @@ session:
 - **任务工具**：基于 Task v2 API 支持任务创建、获取详情、更新和删除
 - **群聊工具**：读写群公告、创建群聊、添加成员、检查机器人是否在群内、删除群聊（`feishu_chat`）
 - **加急通知工具**：发送应用内加急（buzz）、短信、语音电话加急通知（`feishu_urgent`）
+- **消息工具**：读取单条消息或列出聊天历史记录，支持时间范围和分页（`feishu_message`）
+- **表情工具**：添加、删除、列出消息上的表情回复（`feishu_reaction`）
 - **@ 转发功能**：在消息中 @ 某人，机器人的回复会自动 @ 该用户
 - **权限错误提示**：当机器人遇到飞书 API 权限错误时，会自动通知用户并提供权限授权链接
 - **动态 Agent 创建**：每个私聊用户可拥有独立的 agent 实例和专属 workspace（可选）

package/index.ts

@@ -9,6 +9,8 @@ import { registerFeishuPermTools } from "./src/perm-tools/index.js";
 import { registerFeishuTaskTools } from "./src/task-tools/index.js";
 import { registerFeishuChatTools } from "./src/chat-tools/index.js";
 import { registerFeishuUrgentTools } from "./src/urgent-tools/index.js";
+import { registerFeishuMessageTools } from "./src/message-tools/index.js";
+import { registerFeishuReactionTools } from "./src/reaction-tools/index.js";
 import { registerFeishuWikiTools } from "./src/wiki-tools/index.js";
 
 export { monitorFeishuProvider } from "./src/monitor.js";
@@ -64,6 +66,8 @@ const plugin = {
     registerFeishuTaskTools(api);
     registerFeishuChatTools(api);
     registerFeishuUrgentTools(api);
+    registerFeishuMessageTools(api);
+    registerFeishuReactionTools(api);
   },
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m1heng-clawd/feishu",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "type": "module",
   "description": "OpenClaw Feishu/Lark channel plugin",
   "scripts": {
@@ -57,6 +57,7 @@
     "@larksuiteoapi/node-sdk": "^1.59.0",
     "@sinclair/typebox": "0.34.48",
     "https-proxy-agent": "^7.0.6",
+    "music-metadata": "^11.12.1",
     "zod": "^4.3.6"
   },
   "devDependencies": {

package/skills/feishu-message/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: feishu-message
+description: |
+  Feishu message reading. Activate when user mentions reading messages, chat history, message lookup, or finding previous messages.
+---
+
+# Feishu Message Tool
+
+Single tool `feishu_message` for reading Feishu messages — get a single message by ID or list recent messages in a chat.
+
+## Actions
+
+### Get Single Message
+
+```json
+{
+  "action": "get",
+  "message_id": "om_xxx"
+}
+```
+
+Returns:
+
+```json
+{
+  "ok": true,
+  "action": "get",
+  "found": true,
+  "message_id": "om_xxx",
+  "msg_type": "text",
+  "content": "Hello world",
+  "sender_id": "ou_xxx",
+  "sender_type": "user",
+  "chat_id": "oc_xxx",
+  "create_time": "1710000000000",
+  "update_time": "1710000000000",
+  "mentions": []
+}
+```
+
+### List Recent Messages
+
+List recent messages in a chat (DM or group), newest first by default.
+Omit `chat_id` to use the current conversation's chat:
+
+```json
+{
+  "action": "list"
+}
+```
+
+With custom page size, sort order, and time range:
+
+```json
+{
+  "action": "list",
+  "chat_id": "oc_xxx",
+  "page_size": 20,
+  "sort_type": "ByCreateTimeAsc",
+  "start_time": "1710000000",
+  "end_time": "1710086400"
+}
+```
+
+Returns:
+
+```json
+{
+  "ok": true,
+  "action": "list",
+  "chat_id": "oc_xxx",
+  "total": 10,
+  "messages": [
+    {
+      "message_id": "om_xxx",
+      "msg_type": "text",
+      "content_preview": "Hello world",
+      "sender_id": "ou_xxx",
+      "sender_type": "user",
+      "create_time": "1710000000000",
+      "chat_id": "oc_xxx"
+    }
+  ]
+}
+```
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `action` | Yes | `get` or `list` |
+| `message_id` | get: Yes | Feishu message ID (e.g., `om_xxx`) |
+| `chat_id` | list: Optional | Chat ID (e.g., `oc_xxx`). Omit to use current chat. |
+| `page_size` | list: Optional | Number of messages (default: 10, max: 50) |
+| `sort_type` | list: Optional | `ByCreateTimeDesc` (default) or `ByCreateTimeAsc` |
+| `start_time` | list: Optional | Unix timestamp in seconds (e.g., `"1710000000"`). No lower bound if omitted. |
+| `end_time` | list: Optional | Unix timestamp in seconds (e.g., `"1710086400"`). No upper bound if omitted. |
+
+## Configuration
+
+```yaml
+channels:
+  feishu:
+    tools:
+      message: true  # default: true
+```
+
+## Permissions
+
+- `im:message` or `im:message:readonly` — read single/DM messages
+- `im:message.group_at_msg:readonly` — read all messages in group chats (not just @bot messages)

package/skills/feishu-reaction/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: feishu-reaction
+description: |
+  Feishu message emoji reactions. Activate when user mentions emoji, reaction, thumbsup, like, or responding to messages with emoji.
+---
+
+# Feishu Reaction Tool
+
+Single tool `feishu_reaction` for adding, removing, and listing emoji reactions on Feishu messages.
+
+## Workflow: Reacting to Previous Messages
+
+To react to a message other than the current one, first use `feishu_message` with `action: "list"` to fetch recent messages and find the target `message_id`, then use `feishu_reaction` with that `message_id`.
+
+## Actions
+
+### Add Reaction
+
+```json
+{
+  "action": "add",
+  "message_id": "om_xxx",
+  "emoji_type": "THUMBSUP"
+}
+```
+
+Returns:
+
+```json
+{
+  "ok": true,
+  "action": "add",
+  "message_id": "om_xxx",
+  "emoji_type": "THUMBSUP",
+  "reaction_id": "ZCaCIjUBVVWSrm5L-3ZTw"
+}
+```
+
+### Remove Reaction
+
+```json
+{
+  "action": "remove",
+  "message_id": "om_xxx",
+  "reaction_id": "ZCaCIjUBVVWSrm5L-3ZTw"
+}
+```
+
+### List Reactions
+
+List all reactions on a message:
+
+```json
+{
+  "action": "list",
+  "message_id": "om_xxx"
+}
+```
+
+Filter by emoji type:
+
+```json
+{
+  "action": "list",
+  "message_id": "om_xxx",
+  "emoji_type": "THUMBSUP"
+}
+```
+
+Returns:
+
+```json
+{
+  "ok": true,
+  "action": "list",
+  "message_id": "om_xxx",
+  "emoji_type_filter": "THUMBSUP",
+  "total": 2,
+  "reactions": [
+    {
+      "reaction_id": "ZCaCIjUBVVWSrm5L-3ZTw",
+      "emoji_type": "THUMBSUP",
+      "operator_type": "user",
+      "operator_id": "ou_xxx"
+    }
+  ]
+}
+```
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `action` | Yes | `add`, `remove`, or `list` |
+| `message_id` | Yes | Feishu message ID (e.g., `om_xxx`) |
+| `emoji_type` | add: Yes, list: Optional | Emoji type (e.g., `THUMBSUP`, `HEART`, `SMILE`) |
+| `reaction_id` | remove: Yes | Reaction ID from add or list results |
+
+## Common Emoji Types
+
+| Emoji | Type |
+|-------|------|
+| THUMBSUP | THUMBSDOWN | HEART | SMILE | GRINNING |
+| FIRE | CLAP | OK | CHECK | CROSS |
+| PARTY | PRAY | CRY | ANGRY | THINKING |
+| SURPRISED | LAUGHING | FIST | QUESTION | EXCLAMATION |
+
+## Configuration
+
+```yaml
+channels:
+  feishu:
+    tools:
+      reaction: true  # default: true
+```
+
+## Permissions
+
+- `im:message.reactions:write_only` — add and remove reactions
+- `im:message.reactions:read` — list reactions on messages

package/src/bot.ts

@@ -1489,6 +1489,7 @@ export async function handleFeishuMessage(params: {
           accountId: account.accountId,
           sessionKey: route.sessionKey,
           senderOpenId: ctx.senderOpenId,
+          chatId: ctx.chatId,
         },
         // Keep account context available while the agent executes plugin tools.
         () =>
@@ -1576,6 +1577,7 @@ export async function handleFeishuMessage(params: {
         accountId: account.accountId,
         sessionKey: route.sessionKey,
         senderOpenId: ctx.senderOpenId,
+        chatId: ctx.chatId,
       },
       // Tool calls produced by this turn should resolve to the same inbound account.
       () =>

package/src/channel.ts

@@ -60,6 +60,8 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
     messageToolHints: () => [
       "- Feishu targeting: omit `target` to reply to the current conversation (auto-inferred). Explicit targets: `user:open_id` or `chat:chat_id`.",
       "- Feishu supports interactive cards for rich messages.",
+      "- To send a file from the OpenClaw agent's local filesystem workspace (or another allowed local path) as a Feishu attachment, reply with a standalone `MEDIA:<absolute-path-or-url>` line.",
+      "- `feishu_drive` is for Feishu cloud Drive content, not for the OpenClaw agent's local filesystem workspace.",
     ],
   },
   groups: {

package/src/config-schema.ts

@@ -91,6 +91,8 @@ const FeishuToolsConfigSchema = z
     task: z.boolean().optional(), // Task operations (default: true)
     chat: z.boolean().optional(), // Chat management operations (default: true)
     urgent: z.boolean().optional(), // Buzz/urgent notifications (default: true)
+    message: z.boolean().optional(), // Message reading (default: true)
+    reaction: z.boolean().optional(), // Emoji reactions (default: true)
   })
   .strict()
   .optional();

package/src/drive-tools/register.ts

@@ -59,7 +59,7 @@ export function registerFeishuDriveTools(api: OpenClawPluginApi) {
     name: "feishu_drive",
     label: "Feishu Drive",
     description:
-      "Feishu cloud storage operations. Actions: list, info, create_folder, move, delete, import_document. Use 'import_document' to create documents from Markdown with better structure preservation than block-by-block writing.",
+      "Feishu cloud Drive operations. This tool works with Feishu Drive folders/files/documents, not the OpenClaw agent's local filesystem workspace. Actions: list, info, create_folder, move, delete, import_document. Use 'import_document' to create documents from Markdown with better structure preservation than block-by-block writing.",
     parameters: FeishuDriveSchema,
     run: async ({ client, account }, params) => {
       const mediaMaxBytes = (account.config?.mediaMaxMb ?? 30) * 1024 * 1024;

package/src/media-duration.ts

@@ -1,3 +1,5 @@
+import { parseBuffer } from "music-metadata";
+
 /**
  * Media duration parsers for Feishu file upload.
  *
@@ -9,11 +11,38 @@
  *   - MP4  (ISO base media) — MP4, MOV, QuickTime, M4A, M4V, 3GP share this format
  *   - WAV  (RIFF PCM)       — uncompressed audio
  *
- * Formats intentionally skipped (complex frame-level parsing, rare in practice):
- *   - MP3 (VBR makes byte-count estimation unreliable without scanning all frames)
- *   - Raw AAC / ADTS
+ * Raw AAC / ADTS is delegated to music-metadata on the audio path.
  */
 
+async function parseAudioDurationWithMusicMetadata(params: {
+  buffer: Buffer;
+  fileName?: string;
+  contentType?: string;
+}): Promise<number | undefined> {
+  const { buffer, fileName, contentType } = params;
+  try {
+    const metadata = await parseBuffer(
+      buffer,
+      {
+        mimeType: contentType,
+        path: fileName,
+        size: buffer.length,
+      },
+      {
+        duration: true,
+        skipCovers: true,
+      },
+    );
+    const seconds = metadata.format.duration;
+    if (typeof seconds !== "number" || !Number.isFinite(seconds) || seconds <= 0) {
+      return undefined;
+    }
+    return Math.round(seconds * 1000);
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * Parse duration from an OGG container (Opus or Vorbis).
  * Reads the granule position from the last OGG page and divides by sample rate.
@@ -174,17 +203,23 @@ export function parseWavDurationMs(buffer: Buffer): number | undefined {
  *
  * Routes to the appropriate parser based on Feishu's file type:
  *   - "mp4"  → MP4/MOV/QuickTime container parser
- *   - "opus" → OGG parser, then MP4 container (covers M4A), then WAV
+ *   - "opus" → music-metadata first, then OGG parser, then MP4 container, then WAV
  *
  * Returns duration in milliseconds, or undefined if not determinable.
  */
-export function parseFeishuMediaDurationMs(
+export async function parseFeishuMediaDurationMs(
   buffer: Buffer,
   fileType: "opus" | "mp4",
-): number | undefined {
+  options?: { fileName?: string; contentType?: string },
+): Promise<number | undefined> {
   if (fileType === "mp4") {
     return parseMp4DurationMs(buffer);
   }
-  // fileType === "opus": try each container format in likelihood order
-  return parseOggDurationMs(buffer) ?? parseMp4DurationMs(buffer) ?? parseWavDurationMs(buffer);
+  return (
+    await parseAudioDurationWithMusicMetadata({
+      buffer,
+      fileName: options?.fileName,
+      contentType: options?.contentType,
+    })
+  ) ?? parseOggDurationMs(buffer) ?? parseMp4DurationMs(buffer) ?? parseWavDurationMs(buffer);
 }

package/src/media.ts

@@ -192,6 +192,12 @@ export type SendMediaResult = {
   chatId: string;
 };
 
+function assertNonEmptyMediaBuffer(buffer: Buffer, name: string): void {
+  if (buffer.length === 0) {
+    throw new Error(`Feishu media upload failed: "${name}" is empty (0 bytes)`);
+  }
+}
+
 /**
  * Upload an image to Feishu and get an image_key for sending.
  * Supports: JPEG, PNG, WEBP, GIF, TIFF, BMP, ICO
@@ -210,15 +216,16 @@ export async function uploadImageFeishu(params: {
 
   const client = createFeishuClient(account);
 
-  // SDK expects a Readable stream, not a Buffer
-  // Use type assertion since SDK actually accepts any Readable at runtime
-  const imageStream =
-    typeof image === "string" ? fs.createReadStream(image) : Readable.from(image);
+  if (Buffer.isBuffer(image)) {
+    assertNonEmptyMediaBuffer(image, "image");
+  }
+
+  const imagePayload = typeof image === "string" ? fs.createReadStream(image) : image;
 
   const response = await client.im.image.create({
     data: {
       image_type: imageType,
-      image: imageStream as any,
+      image: imagePayload as any,
     },
   });
 
@@ -258,16 +265,17 @@ export async function uploadFileFeishu(params: {
 
   const client = createFeishuClient(account);
 
-  // SDK expects a Readable stream, not a Buffer
-  // Use type assertion since SDK actually accepts any Readable at runtime
-  const fileStream =
-    typeof file === "string" ? fs.createReadStream(file) : Readable.from(file);
+  if (Buffer.isBuffer(file)) {
+    assertNonEmptyMediaBuffer(file, fileName);
+  }
+
+  const filePayload = typeof file === "string" ? fs.createReadStream(file) : file;
 
   const response = await client.im.file.create({
     data: {
       file_type: fileType,
       file_name: fileName,
-      file: fileStream as any,
+      file: filePayload as any,
       ...(duration !== undefined && { duration }),
     },
   });
@@ -512,6 +520,8 @@ export async function sendMediaFeishu(params: {
     throw new Error("Either mediaUrl or mediaBuffer must be provided");
   }
 
+  assertNonEmptyMediaBuffer(buffer, name);
+
   // Determine if it's an image based on extension
   const ext = path.extname(name).toLowerCase();
   const isImage = [".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".ico", ".tiff"].includes(ext);
@@ -530,7 +540,7 @@ export async function sendMediaFeishu(params: {
     const msgType = fileType === "opus" ? "audio" : fileType === "mp4" ? "media" : "file";
     const duration =
       fileType === "opus" || fileType === "mp4"
-        ? parseFeishuMediaDurationMs(buffer, fileType)
+        ? await parseFeishuMediaDurationMs(buffer, fileType, { fileName: name, contentType })
         : undefined;
     const { fileKey } = await uploadFileFeishu({
       cfg,

package/src/message-tools/actions.ts

@@ -0,0 +1,154 @@
+import type * as Lark from "@larksuiteoapi/node-sdk";
+import { runFeishuApiCall, type FeishuApiResponse } from "../tools-common/feishu-api.js";
+import type { FeishuMessageParams } from "./schemas.js";
+
+interface MessageGetResponse extends FeishuApiResponse {
+  data?: {
+    items?: Array<{
+      message_id?: string;
+      root_id?: string;
+      parent_id?: string;
+      msg_type?: string;
+      create_time?: string;
+      update_time?: string;
+      deleted?: boolean;
+      chat_id?: string;
+      sender?: { id: string; id_type: string; sender_type: string };
+      body?: { content: string };
+      mentions?: Array<{ key: string; id: string; id_type: string; name: string }>;
+    }>;
+  };
+}
+
+interface MessageListResponse extends FeishuApiResponse {
+  data?: {
+    has_more?: boolean;
+    page_token?: string;
+    items?: Array<{
+      message_id?: string;
+      root_id?: string;
+      parent_id?: string;
+      msg_type?: string;
+      create_time?: string;
+      deleted?: boolean;
+      chat_id?: string;
+      sender?: { id: string; id_type: string; sender_type: string };
+      body?: { content: string };
+    }>;
+  };
+}
+
+export async function runMessageAction(
+  client: Lark.Client,
+  params: FeishuMessageParams,
+): Promise<unknown> {
+  switch (params.action) {
+    case "get":
+      return getMessage(client, params);
+    case "list":
+      return listMessages(client, params);
+  }
+}
+
+function parseMessageContent(msgType: string | undefined, rawContent: string | undefined): string {
+  if (!rawContent) return "";
+  try {
+    const parsed = JSON.parse(rawContent);
+    if (msgType === "text") return (parsed.text as string) ?? rawContent;
+    if (msgType === "post") {
+      const title = (parsed.title as string) ?? "";
+      const lines: string[] = [];
+      for (const paragraph of (parsed.content as Array<Array<{ tag: string; text?: string }>>) ?? []) {
+        lines.push(paragraph.map((el) => el.text ?? "").join(""));
+      }
+      return title ? `${title}\n${lines.join("\n")}` : lines.join("\n");
+    }
+    if (msgType === "image") return "[image]";
+    if (msgType === "file") return `[file: ${(parsed.file_name as string) ?? ""}]`;
+    if (msgType === "audio") return "[audio]";
+    if (msgType === "sticker") return "[sticker]";
+    if (msgType === "share_chat") return "[share_chat]";
+    if (msgType === "share_user") return "[share_user]";
+    return `[${msgType ?? "unknown"}]`;
+  } catch {
+    return rawContent;
+  }
+}
+
+async function getMessage(client: Lark.Client, params: FeishuMessageParams) {
+  if (!params.message_id) {
+    throw new Error("message_id is required for action=get");
+  }
+
+  const response = await runFeishuApiCall<MessageGetResponse>(
+    "Feishu get message",
+    () =>
+      client.im.message.get({
+        path: { message_id: params.message_id! },
+      }) as Promise<MessageGetResponse>,
+  );
+
+  const item = response.data?.items?.[0];
+  if (!item) {
+    return { ok: true, action: "get", message_id: params.message_id, found: false };
+  }
+
+  return {
+    ok: true,
+    action: "get",
+    found: true,
+    message_id: item.message_id ?? params.message_id,
+    msg_type: item.msg_type ?? "",
+    content: parseMessageContent(item.msg_type, item.body?.content),
+    sender_id: item.sender?.id ?? "",
+    sender_type: item.sender?.sender_type ?? "",
+    chat_id: item.chat_id ?? "",
+    create_time: item.create_time ?? "",
+    update_time: item.update_time ?? "",
+    mentions: item.mentions?.map((m) => ({ id: m.id, name: m.name })) ?? [],
+  };
+}
+
+async function listMessages(client: Lark.Client, params: FeishuMessageParams) {
+  if (!params.chat_id) {
+    throw new Error("chat_id is required for action=list");
+  }
+
+  const pageSize = Math.min(Math.max(params.page_size ?? 10, 1), 50);
+  const sortType = params.sort_type ?? "ByCreateTimeDesc";
+
+  const response = await runFeishuApiCall<MessageListResponse>(
+    "Feishu list messages",
+    () =>
+      client.im.message.list({
+        params: {
+          container_id_type: "chat",
+          container_id: params.chat_id!,
+          sort_type: sortType,
+          page_size: pageSize,
+          ...(params.start_time ? { start_time: params.start_time } : {}),
+          ...(params.end_time ? { end_time: params.end_time } : {}),
+        },
+      }) as Promise<MessageListResponse>,
+  );
+
+  const messages = (response.data?.items ?? [])
+    .filter((item) => !item.deleted)
+    .map((item) => ({
+      message_id: item.message_id ?? "",
+      msg_type: item.msg_type ?? "",
+      content_preview: parseMessageContent(item.msg_type, item.body?.content),
+      sender_id: item.sender?.id ?? "",
+      sender_type: item.sender?.sender_type ?? "",
+      create_time: item.create_time ?? "",
+      chat_id: item.chat_id ?? "",
+    }));
+
+  return {
+    ok: true,
+    action: "list",
+    chat_id: params.chat_id,
+    total: messages.length,
+    messages,
+  };
+}

package/src/message-tools/index.ts

@@ -0,0 +1,2 @@
+export { registerFeishuMessageTools } from "./register.js";
+export { FeishuMessageSchema, type FeishuMessageParams } from "./schemas.js";

package/src/message-tools/register.ts

@@ -0,0 +1,58 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { hasFeishuToolEnabledForAnyAccount, withFeishuToolClient } from "../tools-common/tool-exec.js";
+import { getCurrentFeishuToolContext } from "../tools-common/tool-context.js";
+import { errorResult, json } from "../tools-common/feishu-api.js";
+import { runMessageAction } from "./actions.js";
+import { FeishuMessageSchema, type FeishuMessageParams } from "./schemas.js";
+
+export function registerFeishuMessageTools(api: OpenClawPluginApi) {
+  if (!api.config) {
+    api.logger.debug?.("feishu_message: No config available, skipping");
+    return;
+  }
+
+  if (!hasFeishuToolEnabledForAnyAccount(api.config)) {
+    api.logger.debug?.("feishu_message: No Feishu accounts configured, skipping");
+    return;
+  }
+
+  if (!hasFeishuToolEnabledForAnyAccount(api.config, "message")) {
+    api.logger.debug?.("feishu_message: message tool disabled in config");
+    return;
+  }
+
+  api.registerTool(
+    {
+      name: "feishu_message",
+      label: "Feishu Message",
+      description:
+        "Read Feishu messages. Actions: get (get a single message by message_id), list (list recent messages in a chat). " +
+        "Use list to discover message_ids for use with other tools (e.g., feishu_reaction).",
+      parameters: FeishuMessageSchema,
+      async execute(_toolCallId, params) {
+        const p = params as FeishuMessageParams;
+        if (p.action === "list") {
+          const isValidChatId = p.chat_id?.startsWith("oc_");
+          if (!isValidChatId) {
+            const ctx = getCurrentFeishuToolContext();
+            if (ctx?.chatId) p.chat_id = ctx.chatId;
+          }
+        }
+
+        try {
+          return await withFeishuToolClient({
+            api,
+            toolName: "feishu_message",
+            requiredTool: "message",
+            run: async ({ client }) => json(await runMessageAction(client, p)),
+          });
+        } catch (err) {
+          return errorResult(err);
+        }
+      },
+    },
+    { name: "feishu_message" },
+  );
+
+  api.logger.debug?.("feishu_message: Registered feishu_message tool");
+}

package/src/message-tools/schemas.ts

@@ -0,0 +1,56 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+function stringEnum<T extends readonly string[]>(
+  values: T,
+  options: { description?: string; default?: T[number] } = {},
+) {
+  return Type.Unsafe<T[number]>({ type: "string", enum: [...values], ...options });
+}
+
+const ACTION_VALUES = ["get", "list"] as const;
+const SORT_VALUES = ["ByCreateTimeAsc", "ByCreateTimeDesc"] as const;
+
+export const FeishuMessageSchema = Type.Object({
+  action: stringEnum(ACTION_VALUES, {
+    description:
+      "Action to perform: get (get a single message by message_id), list (list recent messages in a chat by chat_id).",
+  }),
+  message_id: Type.Optional(
+    Type.String({
+      description: "Feishu message ID (e.g. om_xxx). Required for action=get.",
+    }),
+  ),
+  chat_id: Type.Optional(
+    Type.String({
+      description: "Chat ID (e.g. oc_xxx). Required for action=list. Omit to use the current conversation's chat.",
+    }),
+  ),
+  page_size: Type.Optional(
+    Type.Integer({
+      description: "Number of messages to fetch for action=list (default: 10, max: 50).",
+      minimum: 1,
+      maximum: 50,
+      default: 10,
+    }),
+  ),
+  sort_type: Type.Optional(
+    stringEnum(SORT_VALUES, {
+      description: "Sort order for action=list. Default: ByCreateTimeDesc (newest first).",
+      default: "ByCreateTimeDesc",
+    }),
+  ),
+  start_time: Type.Optional(
+    Type.String({
+      description:
+        "Start of time range for action=list, as Unix timestamp in seconds (e.g. \"1710000000\"). Omit for no lower bound.",
+    }),
+  ),
+  end_time: Type.Optional(
+    Type.String({
+      description:
+        "End of time range for action=list, as Unix timestamp in seconds (e.g. \"1710086400\"). Omit for no upper bound.",
+    }),
+  ),
+});
+
+export type FeishuMessageParams = Static<typeof FeishuMessageSchema>;

package/src/reaction-tools/actions.ts

@@ -0,0 +1,127 @@
+import type * as Lark from "@larksuiteoapi/node-sdk";
+import { runFeishuApiCall, type FeishuApiResponse } from "../tools-common/feishu-api.js";
+import type { FeishuReactionParams } from "./schemas.js";
+
+interface ReactionCreateResponse extends FeishuApiResponse {
+  data?: { reaction_id?: string };
+}
+
+interface ReactionListResponse extends FeishuApiResponse {
+  data?: {
+    items?: Array<{
+      reaction_id?: string;
+      reaction_type?: { emoji_type?: string };
+      operator_type?: string;
+      operator_id?: { open_id?: string; user_id?: string; union_id?: string };
+    }>;
+    has_more?: boolean;
+    page_token?: string;
+  };
+}
+
+export async function runReactionAction(
+  client: Lark.Client,
+  params: FeishuReactionParams,
+): Promise<unknown> {
+  switch (params.action) {
+    case "add":
+      return addReaction(client, params);
+    case "remove":
+      return removeReaction(client, params);
+    case "list":
+      return listReactions(client, params);
+  }
+}
+
+async function addReaction(client: Lark.Client, params: FeishuReactionParams) {
+  if (!params.emoji_type) {
+    throw new Error("emoji_type is required for action=add");
+  }
+
+  const response = await runFeishuApiCall<ReactionCreateResponse>(
+    "Feishu add reaction",
+    () =>
+      client.im.messageReaction.create({
+        path: { message_id: params.message_id },
+        data: { reaction_type: { emoji_type: params.emoji_type! } },
+      }) as Promise<ReactionCreateResponse>,
+  );
+
+  return {
+    ok: true,
+    action: "add",
+    message_id: params.message_id,
+    emoji_type: params.emoji_type,
+    reaction_id: response.data?.reaction_id ?? null,
+  };
+}
+
+async function removeReaction(client: Lark.Client, params: FeishuReactionParams) {
+  if (!params.reaction_id) {
+    throw new Error("reaction_id is required for action=remove");
+  }
+
+  await runFeishuApiCall<FeishuApiResponse>(
+    "Feishu remove reaction",
+    () =>
+      client.im.messageReaction.delete({
+        path: {
+          message_id: params.message_id,
+          reaction_id: params.reaction_id!,
+        },
+      }) as Promise<FeishuApiResponse>,
+  );
+
+  return {
+    ok: true,
+    action: "remove",
+    message_id: params.message_id,
+    reaction_id: params.reaction_id,
+  };
+}
+
+async function listReactions(client: Lark.Client, params: FeishuReactionParams) {
+  const allItems: Array<{
+    reaction_id: string;
+    emoji_type: string;
+    operator_type: string;
+    operator_id: string;
+  }> = [];
+
+  let pageToken: string | undefined;
+  do {
+    const response = await runFeishuApiCall<ReactionListResponse>(
+      "Feishu list reactions",
+      () =>
+        client.im.messageReaction.list({
+          path: { message_id: params.message_id },
+          params: {
+            ...(params.emoji_type ? { reaction_type: params.emoji_type } : {}),
+            ...(pageToken ? { page_token: pageToken } : {}),
+            page_size: 50,
+          },
+        }) as Promise<ReactionListResponse>,
+    );
+
+    for (const item of response.data?.items ?? []) {
+      allItems.push({
+        reaction_id: item.reaction_id ?? "",
+        emoji_type: item.reaction_type?.emoji_type ?? "",
+        operator_type: item.operator_type ?? "user",
+        operator_id:
+          item.operator_id?.open_id ?? item.operator_id?.user_id ?? item.operator_id?.union_id ?? "",
+      });
+    }
+
+    pageToken = response.data?.has_more ? (response.data.page_token ?? undefined) : undefined;
+  } while (pageToken);
+
+  return {
+    ok: true,
+    action: "list",
+    message_id: params.message_id,
+    emoji_type_filter: params.emoji_type ?? null,
+    total: allItems.length,
+    reactions: allItems,
+  };
+}

package/src/reaction-tools/index.ts

@@ -0,0 +1,2 @@
+export { registerFeishuReactionTools } from "./register.js";
+export { FeishuReactionSchema, type FeishuReactionParams } from "./schemas.js";

package/src/reaction-tools/register.ts

@@ -0,0 +1,51 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { hasFeishuToolEnabledForAnyAccount, withFeishuToolClient } from "../tools-common/tool-exec.js";
+import { errorResult, json } from "../tools-common/feishu-api.js";
+import { runReactionAction } from "./actions.js";
+import { FeishuReactionSchema, type FeishuReactionParams } from "./schemas.js";
+
+export function registerFeishuReactionTools(api: OpenClawPluginApi) {
+  if (!api.config) {
+    api.logger.debug?.("feishu_reaction: No config available, skipping");
+    return;
+  }
+
+  if (!hasFeishuToolEnabledForAnyAccount(api.config)) {
+    api.logger.debug?.("feishu_reaction: No Feishu accounts configured, skipping");
+    return;
+  }
+
+  if (!hasFeishuToolEnabledForAnyAccount(api.config, "reaction")) {
+    api.logger.debug?.("feishu_reaction: reaction tool disabled in config");
+    return;
+  }
+
+  api.registerTool(
+    {
+      name: "feishu_reaction",
+      label: "Feishu Reaction",
+      description:
+        "Add, remove, or list emoji reactions on Feishu messages. " +
+        "Supported actions: add (add an emoji reaction), remove (remove a reaction by ID), list (list all reactions). " +
+        "Common emoji types: THUMBSUP, THUMBSDOWN, HEART, SMILE, GRINNING, FIRE, CLAP, OK, CHECK, CROSS, PARTY, PRAY. " +
+        "To react to a previous message, first use feishu_message list to find the target message_id.",
+      parameters: FeishuReactionSchema,
+      async execute(_toolCallId, params) {
+        const p = params as FeishuReactionParams;
+        try {
+          return await withFeishuToolClient({
+            api,
+            toolName: "feishu_reaction",
+            requiredTool: "reaction",
+            run: async ({ client }) => json(await runReactionAction(client, p)),
+          });
+        } catch (err) {
+          return errorResult(err);
+        }
+      },
+    },
+    { name: "feishu_reaction" },
+  );
+
+  api.logger.debug?.("feishu_reaction: Registered feishu_reaction tool");
+}

package/src/reaction-tools/schemas.ts

@@ -0,0 +1,34 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+function stringEnum<T extends readonly string[]>(
+  values: T,
+  options: { description?: string; default?: T[number] } = {},
+) {
+  return Type.Unsafe<T[number]>({ type: "string", enum: [...values], ...options });
+}
+
+const ACTION_VALUES = ["add", "remove", "list"] as const;
+
+export const FeishuReactionSchema = Type.Object({
+  action: stringEnum(ACTION_VALUES, {
+    description:
+      "Action to perform: add (add emoji reaction to a message), remove (remove a reaction by reaction_id), list (list all reactions on a message).",
+  }),
+  message_id: Type.String({
+    description: "Feishu message ID (e.g. om_xxx). Use feishu_message list to find message_ids from chat history.",
+  }),
+  emoji_type: Type.Optional(
+    Type.String({
+      description:
+        "Emoji type to add or filter by (e.g. THUMBSUP, HEART, SMILE, GRINNING, FIRE, CLAP, OK, CHECK, CROSS). " +
+        "Required for action=add. Optional filter for action=list.",
+    }),
+  ),
+  reaction_id: Type.Optional(
+    Type.String({
+      description: "Reaction ID to remove. Required for action=remove. Obtained from add or list results.",
+    }),
+  ),
+});
+
+export type FeishuReactionParams = Static<typeof FeishuReactionSchema>;

package/src/reply-dispatcher.ts

@@ -12,7 +12,7 @@ import { buildMentionedCardContent, type MentionTarget } from "./mention.js";
 import { normalizeFeishuMarkdownLinks } from "./text/markdown-links.js";
 import { getFeishuRuntime } from "./runtime.js";
 import { sendMarkdownCardFeishu, sendMessageFeishu } from "./send.js";
-import { FeishuStreamingSession } from "./streaming-card.js";
+import { FeishuStreamingSession, mergeStreamingText } from "./streaming-card.js";
 import { resolveReceiveIdType } from "./targets.js";
 import { addTypingIndicator, removeTypingIndicator, type TypingIndicatorState } from "./typing.js";
 
@@ -119,39 +119,15 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
   let streaming: FeishuStreamingSession | null = null;
   let streamText = "";
   let lastPartial = "";
+  let streamingCompleted = false;
   let partialUpdateQueue: Promise<void> = Promise.resolve();
   let streamingStartPromise: Promise<void> | null = null;
 
-  const mergeStreamingText = (nextText: string) => {
-    if (!streamText) {
-      streamText = nextText;
-      return;
-    }
-    if (nextText.startsWith(streamText)) {
-      // Handle cumulative partial payloads where nextText already includes prior text.
-      streamText = nextText;
-      return;
-    }
-    if (streamText.endsWith(nextText)) {
-      return;
-    }
-    streamText += nextText;
+  const mergeIntoStreamText = (nextText: string) => {
+    streamText = mergeStreamingText(streamText, nextText);
   };
 
-  const queueStreamingUpdate = (
-    nextText: string,
-    options?: { dedupeWithLastPartial?: boolean },
-  ) => {
-    if (!nextText) {
-      return;
-    }
-    if (options?.dedupeWithLastPartial && nextText === lastPartial) {
-      return;
-    }
-    if (options?.dedupeWithLastPartial) {
-      lastPartial = nextText;
-    }
-    mergeStreamingText(nextText);
+  const enqueueStreamingFlush = () => {
     partialUpdateQueue = partialUpdateQueue.then(async () => {
       if (streamingStartPromise) {
         await streamingStartPromise;
@@ -163,7 +139,7 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
   };
 
   const startStreaming = () => {
-    if (!streamingEnabled || streamingStartPromise || streaming) {
+    if (!streamingEnabled || streamingStartPromise || streaming || streamingCompleted) {
       return;
     }
     streamingStartPromise = (async () => {
@@ -198,6 +174,7 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
         text = buildMentionedCardContent(mentionTargets, text);
       }
       await streaming.close(normalizeFeishuMarkdownLinks(text));
+      streamingCompleted = true;
     }
     streaming = null;
     streamingStartPromise = null;
@@ -247,7 +224,8 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
           if (info?.kind === "block") {
             // Some runtimes emit block payloads without onPartial/final callbacks.
             // Mirror block text into streamText so onIdle close still sends content.
-            queueStreamingUpdate(text);
+            mergeIntoStreamText(text);
+            enqueueStreamingFlush();
           }
           if (info?.kind === "final") {
             streamText = text;
@@ -256,6 +234,13 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
           return;
         }
 
+        // Streaming card already delivered the content — skip regular send to
+        // avoid a duplicate card when the runtime delivers a second payload
+        // after the streaming session has closed (#399).
+        if (streamingCompleted) {
+          return;
+        }
+
         let first = true;
         if (useCard) {
           for (const chunk of core.channel.text.chunkTextWithMode(text, textChunkLimit, chunkMode)) {
@@ -312,10 +297,15 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
       onPartialReply: streamingEnabled
         ? (payload: ReplyPayload) => {
             const partialText = normalizeFeishuMarkdownLinks(payload.text ?? "");
-            if (!partialText) {
+            if (!partialText || partialText === lastPartial) {
               return;
             }
-            queueStreamingUpdate(partialText, { dedupeWithLastPartial: true });
+            lastPartial = partialText;
+            // Partials are cumulative — replace streamText directly instead of
+            // merging, which avoids duplication when segment boundaries shift
+            // (e.g. after a tool call mid-stream).
+            streamText = partialText;
+            enqueueStreamingFlush();
           }
         : undefined,
     },

package/src/streaming-card.ts

@@ -44,6 +44,21 @@ async function getToken(creds: Credentials): Promise<string> {
   return data.tenant_access_token;
 }
 
+/**
+ * Find the length of the longest suffix of `a` that equals a prefix of `b`.
+ * Used to detect partial overlaps between consecutive streaming segments.
+ * Capped at 500 chars to keep cost bounded.
+ */
+function findOverlapLength(a: string, b: string): number {
+  const max = Math.min(a.length, b.length, 500);
+  for (let len = max; len > 0; len--) {
+    if (a.endsWith(b.slice(0, len))) {
+      return len;
+    }
+  }
+  return 0;
+}
+
 export function mergeStreamingText(
   previousText: string | undefined,
   nextText: string | undefined,
@@ -59,7 +74,14 @@ export function mergeStreamingText(
   if (previous.includes(next)) {
     return previous;
   }
-  // Fallback for fragmented partial chunks: append to avoid losing tokens.
+  // Detect partial overlap: the end of previous matches the start of next.
+  // This happens when partials are cumulative within a segment but don't
+  // include prior segments (e.g. after a tool call mid-stream).
+  const overlap = findOverlapLength(previous, next);
+  if (overlap > 0) {
+    return previous + next.slice(overlap);
+  }
+  // No overlap — truly incremental chunk, just append.
   return `${previous}${next}`;
 }
 
@@ -147,30 +169,30 @@ export class FeishuStreamingSession {
   }
 
   async update(text: string): Promise<void> {
-    if (!this.state || this.closed) {
+    if (!this.state || this.closed || !text) {
       return;
     }
-    const mergedInput = mergeStreamingText(this.pendingText ?? this.state.currentText, text);
-    if (!mergedInput || mergedInput === this.state.currentText) {
+    // Caller sends cumulative full text — no merge needed, just throttle.
+    if (text === this.state.currentText) {
       return;
     }
     const now = Date.now();
     if (now - this.lastUpdateTime < this.updateThrottleMs) {
-      this.pendingText = mergedInput;
+      this.pendingText = text;
       return;
     }
     this.pendingText = null;
     this.lastUpdateTime = now;
 
+    const toSend = text;
     this.queue = this.queue.then(async () => {
       if (!this.state || this.closed) {
         return;
       }
-      const mergedText = mergeStreamingText(this.state.currentText, mergedInput);
-      if (!mergedText || mergedText === this.state.currentText) {
+      if (toSend === this.state.currentText) {
         return;
       }
-      this.state.currentText = mergedText;
+      this.state.currentText = toSend;
       this.state.sequence += 1;
       const apiBase = resolveApiBase(this.creds.domain);
       await fetch(`${apiBase}/cardkit/v1/cards/${this.state.cardId}/elements/content/content`, {
@@ -180,7 +202,7 @@ export class FeishuStreamingSession {
           "Content-Type": "application/json",
         },
         body: JSON.stringify({
-          content: mergedText,
+          content: toSend,
           sequence: this.state.sequence,
           uuid: `s_${this.state.cardId}_${this.state.sequence}`,
         }),
@@ -196,8 +218,9 @@ export class FeishuStreamingSession {
     this.closed = true;
     await this.queue;
 
-    const pendingMerged = mergeStreamingText(this.state.currentText, this.pendingText ?? undefined);
-    const text = finalText ? mergeStreamingText(pendingMerged, finalText) : pendingMerged;
+    // finalText is authoritative when provided (from deliver kind=final).
+    // Fall back to pending or current text when closing via onIdle.
+    const text = finalText || this.pendingText || this.state.currentText;
     const apiBase = resolveApiBase(this.creds.domain);
 
     if (text && text !== this.state.currentText) {

package/src/tools-common/tool-context.ts

@@ -5,6 +5,7 @@ export type FeishuToolContext = {
   accountId: string;
   sessionKey?: string;
   senderOpenId?: string;
+  chatId?: string;
 };
 
 const toolContextStorage = new AsyncLocalStorage<FeishuToolContext>();

package/src/tools-config.ts

@@ -14,6 +14,8 @@ export const DEFAULT_TOOLS_CONFIG: Required<FeishuToolsConfig> = {
   task: true,
   chat: true,
   urgent: true,
+  message: true,
+  reaction: true,
 };
 
 /**

package/src/types.ts

@@ -76,6 +76,10 @@ export type FeishuToolsConfig = {
   chat?: boolean;
   /** Enable the feishu_urgent tool (buzz/urgent notifications). Enabled by default. */
   urgent?: boolean;
+  /** Enable the feishu_message tool (get/list messages). Enabled by default. */
+  message?: boolean;
+  /** Enable the feishu_reaction tool (add/remove/list emoji reactions). Enabled by default. */
+  reaction?: boolean;
 };
 
 export type DynamicAgentCreationConfig = {