@openclaw/feishu 2026.2.25 → 2026.3.2

package/src/send-target.test.ts

@@ -0,0 +1,74 @@
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { resolveFeishuSendTarget } from "./send-target.js";
+
+const resolveFeishuAccountMock = vi.hoisted(() => vi.fn());
+const createFeishuClientMock = vi.hoisted(() => vi.fn());
+
+vi.mock("./accounts.js", () => ({
+  resolveFeishuAccount: resolveFeishuAccountMock,
+}));
+
+vi.mock("./client.js", () => ({
+  createFeishuClient: createFeishuClientMock,
+}));
+
+describe("resolveFeishuSendTarget", () => {
+  const cfg = {} as ClawdbotConfig;
+  const client = { id: "client" };
+
+  beforeEach(() => {
+    resolveFeishuAccountMock.mockReset().mockReturnValue({
+      accountId: "default",
+      enabled: true,
+      configured: true,
+    });
+    createFeishuClientMock.mockReset().mockReturnValue(client);
+  });
+
+  it("keeps explicit group targets as chat_id even when ID shape is ambiguous", () => {
+    const result = resolveFeishuSendTarget({
+      cfg,
+      to: "feishu:group:group_room_alpha",
+    });
+
+    expect(result.receiveId).toBe("group_room_alpha");
+    expect(result.receiveIdType).toBe("chat_id");
+    expect(result.client).toBe(client);
+  });
+
+  it("maps dm-prefixed open IDs to open_id", () => {
+    const result = resolveFeishuSendTarget({
+      cfg,
+      to: "lark:dm:ou_123",
+    });
+
+    expect(result.receiveId).toBe("ou_123");
+    expect(result.receiveIdType).toBe("open_id");
+  });
+
+  it("maps dm-prefixed non-open IDs to user_id", () => {
+    const result = resolveFeishuSendTarget({
+      cfg,
+      to: "  feishu:dm:user_123  ",
+    });
+
+    expect(result.receiveId).toBe("user_123");
+    expect(result.receiveIdType).toBe("user_id");
+  });
+
+  it("throws when target account is not configured", () => {
+    resolveFeishuAccountMock.mockReturnValue({
+      accountId: "default",
+      enabled: true,
+      configured: false,
+    });
+
+    expect(() =>
+      resolveFeishuSendTarget({
+        cfg,
+        to: "feishu:group:oc_123",
+      }),
+    ).toThrow('Feishu account "default" not configured');
+  });
+});

package/src/send-target.ts

@@ -8,18 +8,22 @@ export function resolveFeishuSendTarget(params: {
   to: string;
   accountId?: string;
 }) {
+  const target = params.to.trim();
   const account = resolveFeishuAccount({ cfg: params.cfg, accountId: params.accountId });
   if (!account.configured) {
     throw new Error(`Feishu account "${account.accountId}" not configured`);
   }
   const client = createFeishuClient(account);
-  const receiveId = normalizeFeishuTarget(params.to);
+  const receiveId = normalizeFeishuTarget(target);
   if (!receiveId) {
     throw new Error(`Invalid Feishu target: ${params.to}`);
   }
+  // Preserve explicit routing prefixes (chat/group/user/dm/open_id) when present.
+  // normalizeFeishuTarget strips these prefixes, so infer type from the raw target first.
+  const withoutProviderPrefix = target.replace(/^(feishu|lark):/i, "");
   return {
     client,
     receiveId,
-    receiveIdType: resolveReceiveIdType(receiveId),
+    receiveIdType: resolveReceiveIdType(withoutProviderPrefix),
   };
 }

package/src/send.reply-fallback.test.ts

@@ -0,0 +1,105 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const resolveFeishuSendTargetMock = vi.hoisted(() => vi.fn());
+const resolveMarkdownTableModeMock = vi.hoisted(() => vi.fn(() => "preserve"));
+const convertMarkdownTablesMock = vi.hoisted(() => vi.fn((text: string) => text));
+
+vi.mock("./send-target.js", () => ({
+  resolveFeishuSendTarget: resolveFeishuSendTargetMock,
+}));
+
+vi.mock("./runtime.js", () => ({
+  getFeishuRuntime: () => ({
+    channel: {
+      text: {
+        resolveMarkdownTableMode: resolveMarkdownTableModeMock,
+        convertMarkdownTables: convertMarkdownTablesMock,
+      },
+    },
+  }),
+}));
+
+import { sendCardFeishu, sendMessageFeishu } from "./send.js";
+
+describe("Feishu reply fallback for withdrawn/deleted targets", () => {
+  const replyMock = vi.fn();
+  const createMock = vi.fn();
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resolveFeishuSendTargetMock.mockReturnValue({
+      client: {
+        im: {
+          message: {
+            reply: replyMock,
+            create: createMock,
+          },
+        },
+      },
+      receiveId: "ou_target",
+      receiveIdType: "open_id",
+    });
+  });
+
+  it("falls back to create for withdrawn post replies", async () => {
+    replyMock.mockResolvedValue({
+      code: 230011,
+      msg: "The message was withdrawn.",
+    });
+    createMock.mockResolvedValue({
+      code: 0,
+      data: { message_id: "om_new" },
+    });
+
+    const result = await sendMessageFeishu({
+      cfg: {} as never,
+      to: "user:ou_target",
+      text: "hello",
+      replyToMessageId: "om_parent",
+    });
+
+    expect(replyMock).toHaveBeenCalledTimes(1);
+    expect(createMock).toHaveBeenCalledTimes(1);
+    expect(result.messageId).toBe("om_new");
+  });
+
+  it("falls back to create for withdrawn card replies", async () => {
+    replyMock.mockResolvedValue({
+      code: 231003,
+      msg: "The message is not found",
+    });
+    createMock.mockResolvedValue({
+      code: 0,
+      data: { message_id: "om_card_new" },
+    });
+
+    const result = await sendCardFeishu({
+      cfg: {} as never,
+      to: "user:ou_target",
+      card: { schema: "2.0" },
+      replyToMessageId: "om_parent",
+    });
+
+    expect(replyMock).toHaveBeenCalledTimes(1);
+    expect(createMock).toHaveBeenCalledTimes(1);
+    expect(result.messageId).toBe("om_card_new");
+  });
+
+  it("still throws for non-withdrawn reply failures", async () => {
+    replyMock.mockResolvedValue({
+      code: 999999,
+      msg: "unknown failure",
+    });
+
+    await expect(
+      sendMessageFeishu({
+        cfg: {} as never,
+        to: "user:ou_target",
+        text: "hello",
+        replyToMessageId: "om_parent",
+      }),
+    ).rejects.toThrow("Feishu reply failed");
+
+    expect(createMock).not.toHaveBeenCalled();
+  });
+});

package/src/send.test.ts

@@ -0,0 +1,168 @@
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { getMessageFeishu } from "./send.js";
+
+const { mockClientGet, mockCreateFeishuClient, mockResolveFeishuAccount } = vi.hoisted(() => ({
+  mockClientGet: vi.fn(),
+  mockCreateFeishuClient: vi.fn(),
+  mockResolveFeishuAccount: vi.fn(),
+}));
+
+vi.mock("./client.js", () => ({
+  createFeishuClient: mockCreateFeishuClient,
+}));
+
+vi.mock("./accounts.js", () => ({
+  resolveFeishuAccount: mockResolveFeishuAccount,
+}));
+
+describe("getMessageFeishu", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockResolveFeishuAccount.mockReturnValue({
+      accountId: "default",
+      configured: true,
+    });
+    mockCreateFeishuClient.mockReturnValue({
+      im: {
+        message: {
+          get: mockClientGet,
+        },
+      },
+    });
+  });
+
+  it("extracts text content from interactive card elements", async () => {
+    mockClientGet.mockResolvedValueOnce({
+      code: 0,
+      data: {
+        items: [
+          {
+            message_id: "om_1",
+            chat_id: "oc_1",
+            msg_type: "interactive",
+            body: {
+              content: JSON.stringify({
+                elements: [
+                  { tag: "markdown", content: "hello markdown" },
+                  { tag: "div", text: { content: "hello div" } },
+                ],
+              }),
+            },
+          },
+        ],
+      },
+    });
+
+    const result = await getMessageFeishu({
+      cfg: {} as ClawdbotConfig,
+      messageId: "om_1",
+    });
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        messageId: "om_1",
+        chatId: "oc_1",
+        contentType: "interactive",
+        content: "hello markdown\nhello div",
+      }),
+    );
+  });
+
+  it("extracts text content from post messages", async () => {
+    mockClientGet.mockResolvedValueOnce({
+      code: 0,
+      data: {
+        items: [
+          {
+            message_id: "om_post",
+            chat_id: "oc_post",
+            msg_type: "post",
+            body: {
+              content: JSON.stringify({
+                zh_cn: {
+                  title: "Summary",
+                  content: [[{ tag: "text", text: "post body" }]],
+                },
+              }),
+            },
+          },
+        ],
+      },
+    });
+
+    const result = await getMessageFeishu({
+      cfg: {} as ClawdbotConfig,
+      messageId: "om_post",
+    });
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        messageId: "om_post",
+        chatId: "oc_post",
+        contentType: "post",
+        content: "Summary\n\npost body",
+      }),
+    );
+  });
+
+  it("returns text placeholder instead of raw JSON for unsupported message types", async () => {
+    mockClientGet.mockResolvedValueOnce({
+      code: 0,
+      data: {
+        items: [
+          {
+            message_id: "om_file",
+            chat_id: "oc_file",
+            msg_type: "file",
+            body: {
+              content: JSON.stringify({ file_key: "file_v3_123" }),
+            },
+          },
+        ],
+      },
+    });
+
+    const result = await getMessageFeishu({
+      cfg: {} as ClawdbotConfig,
+      messageId: "om_file",
+    });
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        messageId: "om_file",
+        chatId: "oc_file",
+        contentType: "file",
+        content: "[file message]",
+      }),
+    );
+  });
+
+  it("supports single-object response shape from Feishu API", async () => {
+    mockClientGet.mockResolvedValueOnce({
+      code: 0,
+      data: {
+        message_id: "om_single",
+        chat_id: "oc_single",
+        msg_type: "text",
+        body: {
+          content: JSON.stringify({ text: "single payload" }),
+        },
+      },
+    });
+
+    const result = await getMessageFeishu({
+      cfg: {} as ClawdbotConfig,
+      messageId: "om_single",
+    });
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        messageId: "om_single",
+        chatId: "oc_single",
+        contentType: "text",
+        content: "single payload",
+      }),
+    );
+  });
+});

package/src/send.ts

@@ -3,21 +3,105 @@ import { resolveFeishuAccount } from "./accounts.js";
 import { createFeishuClient } from "./client.js";
 import type { MentionTarget } from "./mention.js";
 import { buildMentionedMessage, buildMentionedCardContent } from "./mention.js";
+import { parsePostContent } from "./post.js";
 import { getFeishuRuntime } from "./runtime.js";
 import { assertFeishuMessageApiSuccess, toFeishuSendResult } from "./send-result.js";
 import { resolveFeishuSendTarget } from "./send-target.js";
 import type { FeishuSendResult } from "./types.js";
 
+const WITHDRAWN_REPLY_ERROR_CODES = new Set([230011, 231003]);
+
+function shouldFallbackFromReplyTarget(response: { code?: number; msg?: string }): boolean {
+  if (response.code !== undefined && WITHDRAWN_REPLY_ERROR_CODES.has(response.code)) {
+    return true;
+  }
+  const msg = response.msg?.toLowerCase() ?? "";
+  return msg.includes("withdrawn") || msg.includes("not found");
+}
+
 export type FeishuMessageInfo = {
   messageId: string;
   chatId: string;
   senderId?: string;
   senderOpenId?: string;
+  senderType?: string;
   content: string;
   contentType: string;
   createTime?: number;
 };
 
+function parseInteractiveCardContent(parsed: unknown): string {
+  if (!parsed || typeof parsed !== "object") {
+    return "[Interactive Card]";
+  }
+
+  const candidate = parsed as { elements?: unknown };
+  if (!Array.isArray(candidate.elements)) {
+    return "[Interactive Card]";
+  }
+
+  const texts: string[] = [];
+  for (const element of candidate.elements) {
+    if (!element || typeof element !== "object") {
+      continue;
+    }
+    const item = element as {
+      tag?: string;
+      content?: string;
+      text?: { content?: string };
+    };
+    if (item.tag === "div" && typeof item.text?.content === "string") {
+      texts.push(item.text.content);
+      continue;
+    }
+    if (item.tag === "markdown" && typeof item.content === "string") {
+      texts.push(item.content);
+    }
+  }
+  return texts.join("\n").trim() || "[Interactive Card]";
+}
+
+function parseQuotedMessageContent(rawContent: string, msgType: string): string {
+  if (!rawContent) {
+    return "";
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(rawContent);
+  } catch {
+    return rawContent;
+  }
+
+  if (msgType === "text") {
+    const text = (parsed as { text?: unknown })?.text;
+    return typeof text === "string" ? text : "[Text message]";
+  }
+
+  if (msgType === "post") {
+    return parsePostContent(rawContent).textContent;
+  }
+
+  if (msgType === "interactive") {
+    return parseInteractiveCardContent(parsed);
+  }
+
+  if (typeof parsed === "string") {
+    return parsed;
+  }
+
+  const genericText = (parsed as { text?: unknown; title?: unknown } | null)?.text;
+  if (typeof genericText === "string" && genericText.trim()) {
+    return genericText;
+  }
+  const genericTitle = (parsed as { title?: unknown } | null)?.title;
+  if (typeof genericTitle === "string" && genericTitle.trim()) {
+    return genericTitle;
+  }
+
+  return `[${msgType || "unknown"} message]`;
+}
+
 /**
  * Get a message by its ID.
  * Useful for fetching quoted/replied message content.
@@ -54,6 +138,16 @@ export async function getMessageFeishu(params: {
           };
           create_time?: string;
         }>;
+        message_id?: string;
+        chat_id?: string;
+        msg_type?: string;
+        body?: { content?: string };
+        sender?: {
+          id?: string;
+          id_type?: string;
+          sender_type?: string;
+        };
+        create_time?: string;
       };
     };
 
@@ -61,30 +155,30 @@ export async function getMessageFeishu(params: {
       return null;
     }
 
-    const item = response.data?.items?.[0];
+    // Support both list shape (data.items[0]) and single-object shape (data as message)
+    const rawItem = response.data?.items?.[0] ?? response.data;
+    const item =
+      rawItem &&
+      (rawItem.body !== undefined || (rawItem as { message_id?: string }).message_id !== undefined)
+        ? rawItem
+        : null;
     if (!item) {
       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
-    }
+    const msgType = item.msg_type ?? "text";
+    const rawContent = item.body?.content ?? "";
+    const content = parseQuotedMessageContent(rawContent, msgType);
 
     return {
       messageId: item.message_id ?? messageId,
       chatId: item.chat_id ?? "",
       senderId: item.sender?.id,
       senderOpenId: item.sender?.id_type === "open_id" ? item.sender?.id : undefined,
+      senderType: item.sender?.sender_type,
       content,
-      contentType: item.msg_type ?? "text",
-      createTime: item.create_time ? parseInt(item.create_time, 10) : undefined,
+      contentType: msgType,
+      createTime: item.create_time ? parseInt(String(item.create_time), 10) : undefined,
     };
   } catch {
     return null;
@@ -96,6 +190,8 @@ export type SendFeishuMessageParams = {
   to: string;
   text: string;
   replyToMessageId?: string;
+  /** When true, reply creates a Feishu topic thread instead of an inline reply */
+  replyInThread?: boolean;
   /** Mention target users */
   mentions?: MentionTarget[];
   /** Account ID (optional, uses default if not specified) */
@@ -127,7 +223,7 @@ function buildFeishuPostMessagePayload(params: { messageText: string }): {
 export async function sendMessageFeishu(
   params: SendFeishuMessageParams,
 ): Promise<FeishuSendResult> {
-  const { cfg, to, text, replyToMessageId, mentions, accountId } = params;
+  const { cfg, to, text, replyToMessageId, replyInThread, mentions, accountId } = params;
   const { client, receiveId, receiveIdType } = resolveFeishuSendTarget({ cfg, to, accountId });
   const tableMode = getFeishuRuntime().channel.text.resolveMarkdownTableMode({
     cfg,
@@ -149,8 +245,21 @@ export async function sendMessageFeishu(
       data: {
         content,
         msg_type: msgType,
+        ...(replyInThread ? { reply_in_thread: true } : {}),
       },
     });
+    if (shouldFallbackFromReplyTarget(response)) {
+      const fallback = await client.im.message.create({
+        params: { receive_id_type: receiveIdType },
+        data: {
+          receive_id: receiveId,
+          content,
+          msg_type: msgType,
+        },
+      });
+      assertFeishuMessageApiSuccess(fallback, "Feishu send failed");
+      return toFeishuSendResult(fallback, receiveId);
+    }
     assertFeishuMessageApiSuccess(response, "Feishu reply failed");
     return toFeishuSendResult(response, receiveId);
   }
@@ -172,11 +281,13 @@ export type SendFeishuCardParams = {
   to: string;
   card: Record<string, unknown>;
   replyToMessageId?: string;
+  /** When true, reply creates a Feishu topic thread instead of an inline reply */
+  replyInThread?: boolean;
   accountId?: string;
 };
 
 export async function sendCardFeishu(params: SendFeishuCardParams): Promise<FeishuSendResult> {
-  const { cfg, to, card, replyToMessageId, accountId } = params;
+  const { cfg, to, card, replyToMessageId, replyInThread, accountId } = params;
   const { client, receiveId, receiveIdType } = resolveFeishuSendTarget({ cfg, to, accountId });
   const content = JSON.stringify(card);
 
@@ -186,8 +297,21 @@ export async function sendCardFeishu(params: SendFeishuCardParams): Promise<Feis
       data: {
         content,
         msg_type: "interactive",
+        ...(replyInThread ? { reply_in_thread: true } : {}),
       },
     });
+    if (shouldFallbackFromReplyTarget(response)) {
+      const fallback = await client.im.message.create({
+        params: { receive_id_type: receiveIdType },
+        data: {
+          receive_id: receiveId,
+          content,
+          msg_type: "interactive",
+        },
+      });
+      assertFeishuMessageApiSuccess(fallback, "Feishu card send failed");
+      return toFeishuSendResult(fallback, receiveId);
+    }
     assertFeishuMessageApiSuccess(response, "Feishu card reply failed");
     return toFeishuSendResult(response, receiveId);
   }
@@ -260,18 +384,19 @@ export async function sendMarkdownCardFeishu(params: {
   to: string;
   text: string;
   replyToMessageId?: string;
+  /** When true, reply creates a Feishu topic thread instead of an inline reply */
+  replyInThread?: boolean;
   /** Mention target users */
   mentions?: MentionTarget[];
   accountId?: string;
 }): Promise<FeishuSendResult> {
-  const { cfg, to, text, replyToMessageId, mentions, accountId } = params;
-  // Build message content (with @mention support)
+  const { cfg, to, text, replyToMessageId, replyInThread, mentions, accountId } = params;
   let cardText = text;
   if (mentions && mentions.length > 0) {
     cardText = buildMentionedCardContent(mentions, text);
   }
   const card = buildMarkdownCard(cardText);
-  return sendCardFeishu({ cfg, to, card, replyToMessageId, accountId });
+  return sendCardFeishu({ cfg, to, card, replyToMessageId, replyInThread, accountId });
 }
 
 /**