@openclaw/feishu 2026.3.2 → 2026.3.7

package/src/media.ts

@@ -1,7 +1,7 @@
 import fs from "fs";
 import path from "path";
 import { Readable } from "stream";
-import { withTempDownloadPath, type ClawdbotConfig } from "openclaw/plugin-sdk";
+import { withTempDownloadPath, type ClawdbotConfig } from "openclaw/plugin-sdk/feishu";
 import { resolveFeishuAccount } from "./accounts.js";
 import { createFeishuClient } from "./client.js";
 import { normalizeFeishuExternalKey } from "./external-keys.js";
@@ -9,6 +9,8 @@ import { getFeishuRuntime } from "./runtime.js";
 import { assertFeishuMessageApiSuccess, toFeishuSendResult } from "./send-result.js";
 import { resolveFeishuSendTarget } from "./send-target.js";
 
+const FEISHU_MEDIA_HTTP_TIMEOUT_MS = 120_000;
+
 export type DownloadImageResult = {
   buffer: Buffer;
   contentType?: string;
@@ -97,7 +99,10 @@ export async function downloadImageFeishu(params: {
     throw new Error(`Feishu account "${account.accountId}" not configured`);
   }
 
-  const client = createFeishuClient(account);
+  const client = createFeishuClient({
+    ...account,
+    httpTimeoutMs: FEISHU_MEDIA_HTTP_TIMEOUT_MS,
+  });
 
   const response = await client.im.image.get({
     path: { image_key: normalizedImageKey },
@@ -132,7 +137,10 @@ export async function downloadMessageResourceFeishu(params: {
     throw new Error(`Feishu account "${account.accountId}" not configured`);
   }
 
-  const client = createFeishuClient(account);
+  const client = createFeishuClient({
+    ...account,
+    httpTimeoutMs: FEISHU_MEDIA_HTTP_TIMEOUT_MS,
+  });
 
   const response = await client.im.messageResource.get({
     path: { message_id: messageId, file_key: normalizedFileKey },
@@ -176,7 +184,10 @@ export async function uploadImageFeishu(params: {
     throw new Error(`Feishu account "${account.accountId}" not configured`);
   }
 
-  const client = createFeishuClient(account);
+  const client = createFeishuClient({
+    ...account,
+    httpTimeoutMs: FEISHU_MEDIA_HTTP_TIMEOUT_MS,
+  });
 
   // SDK accepts Buffer directly or fs.ReadStream for file paths
   // Using Readable.from(buffer) causes issues with form-data library
@@ -243,7 +254,10 @@ export async function uploadFileFeishu(params: {
     throw new Error(`Feishu account "${account.accountId}" not configured`);
   }
 
-  const client = createFeishuClient(account);
+  const client = createFeishuClient({
+    ...account,
+    httpTimeoutMs: FEISHU_MEDIA_HTTP_TIMEOUT_MS,
+  });
 
   // SDK accepts Buffer directly or fs.ReadStream for file paths
   // Using Readable.from(buffer) causes issues with form-data library
@@ -328,8 +342,8 @@ export async function sendFileFeishu(params: {
   cfg: ClawdbotConfig;
   to: string;
   fileKey: string;
-  /** Use "audio" for audio files, "file" for documents and video */
-  msgType?: "file" | "audio";
+  /** Use "audio" for audio, "media" for video (mp4), "file" for documents */
+  msgType?: "file" | "audio" | "media";
   replyToMessageId?: string;
   replyInThread?: boolean;
   accountId?: string;
@@ -467,8 +481,8 @@ export async function sendMediaFeishu(params: {
       fileType,
       accountId,
     });
-    // Feishu API: opus -> "audio", everything else (including video) -> "file"
-    const msgType = fileType === "opus" ? "audio" : "file";
+    // Feishu API: opus -> "audio", mp4/video -> "media" (playable), others -> "file"
+    const msgType = fileType === "opus" ? "audio" : fileType === "mp4" ? "media" : "file";
     return sendFileFeishu({
       cfg,
       to,

package/src/monitor.account.ts

@@ -1,6 +1,6 @@
 import * as crypto from "crypto";
 import * as Lark from "@larksuiteoapi/node-sdk";
-import type { ClawdbotConfig, RuntimeEnv, HistoryEntry } from "openclaw/plugin-sdk";
+import type { ClawdbotConfig, RuntimeEnv, HistoryEntry } from "openclaw/plugin-sdk/feishu";
 import { resolveFeishuAccount } from "./accounts.js";
 import { raceWithTimeoutAndAbort } from "./async.js";
 import {
@@ -19,8 +19,8 @@ import {
   warmupDedupFromDisk,
 } from "./dedup.js";
 import { isMentionForwardRequest } from "./mention.js";
-import { fetchBotOpenIdForMonitor } from "./monitor.startup.js";
-import { botOpenIds } from "./monitor.state.js";
+import { fetchBotIdentityForMonitor } from "./monitor.startup.js";
+import { botNames, botOpenIds } from "./monitor.state.js";
 import { monitorWebhook, monitorWebSocket } from "./monitor.transport.js";
 import { getFeishuRuntime } from "./runtime.js";
 import { getMessageFeishu } from "./send.js";
@@ -247,6 +247,7 @@ function registerEventHandlers(
         cfg,
         event,
         botOpenId: botOpenIds.get(accountId),
+        botName: botNames.get(accountId),
         runtime,
         chatHistories,
         accountId,
@@ -260,7 +261,7 @@ function registerEventHandlers(
   };
   const resolveDebounceText = (event: FeishuMessageEvent): string => {
     const botOpenId = botOpenIds.get(accountId);
-    const parsed = parseFeishuMessageEvent(event, botOpenId);
+    const parsed = parseFeishuMessageEvent(event, botOpenId, botNames.get(accountId));
     return parsed.content.trim();
   };
   const recordSuppressedMessageIds = async (
@@ -430,6 +431,7 @@ function registerEventHandlers(
           cfg,
           event: syntheticEvent,
           botOpenId: myBotId,
+          botName: botNames.get(accountId),
           runtime,
           chatHistories,
           accountId,
@@ -483,7 +485,9 @@ function registerEventHandlers(
   });
 }
 
-export type BotOpenIdSource = { kind: "prefetched"; botOpenId?: string } | { kind: "fetch" };
+export type BotOpenIdSource =
+  | { kind: "prefetched"; botOpenId?: string; botName?: string }
+  | { kind: "fetch" };
 
 export type MonitorSingleAccountParams = {
   cfg: ClawdbotConfig;
@@ -499,11 +503,18 @@ export async function monitorSingleAccount(params: MonitorSingleAccountParams):
   const log = runtime?.log ?? console.log;
 
   const botOpenIdSource = params.botOpenIdSource ?? { kind: "fetch" };
-  const botOpenId =
+  const botIdentity =
     botOpenIdSource.kind === "prefetched"
-      ? botOpenIdSource.botOpenId
-      : await fetchBotOpenIdForMonitor(account, { runtime, abortSignal });
+      ? { botOpenId: botOpenIdSource.botOpenId, botName: botOpenIdSource.botName }
+      : await fetchBotIdentityForMonitor(account, { runtime, abortSignal });
+  const botOpenId = botIdentity.botOpenId;
+  const botName = botIdentity.botName?.trim();
   botOpenIds.set(accountId, botOpenId ?? "");
+  if (botName) {
+    botNames.set(accountId, botName);
+  } else {
+    botNames.delete(accountId);
+  }
   log(`feishu[${accountId}]: bot open_id resolved: ${botOpenId ?? "unknown"}`);
 
   const connectionMode = account.config.connectionMode ?? "websocket";

package/src/monitor.reaction.test.ts

@@ -1,4 +1,4 @@
-import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk/feishu";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { hasControlCommand } from "../../../src/auto-reply/command-detection.js";
 import {
@@ -51,6 +51,30 @@ function makeReactionEvent(
   };
 }
 
+function createFetchedReactionMessage(chatId: string) {
+  return {
+    messageId: "om_msg1",
+    chatId,
+    senderOpenId: "ou_bot",
+    content: "hello",
+    contentType: "text",
+  };
+}
+
+async function resolveReactionWithLookup(params: {
+  event?: FeishuReactionCreatedEvent;
+  lookupChatId: string;
+}) {
+  return await resolveReactionSyntheticEvent({
+    cfg,
+    accountId: "default",
+    event: params.event ?? makeReactionEvent(),
+    botOpenId: "ou_bot",
+    fetchMessage: async () => createFetchedReactionMessage(params.lookupChatId),
+    uuid: () => "fixed-uuid",
+  });
+}
+
 type FeishuMention = NonNullable<FeishuMessageEvent["message"]["mentions"]>[number];
 
 function buildDebounceConfig(): ClawdbotConfig {
@@ -77,7 +101,7 @@ function buildDebounceAccount(): ResolvedFeishuAccount {
     enabled: true,
     configured: true,
     appId: "cli_test",
-    appSecret: "secret_test",
+    appSecret: "secret_test", // pragma: allowlist secret
     domain: "feishu",
     config: {
       enabled: true,
@@ -109,7 +133,10 @@ function createTextEvent(params: {
   };
 }
 
-async function setupDebounceMonitor(): Promise<(data: unknown) => Promise<void>> {
+async function setupDebounceMonitor(params?: {
+  botOpenId?: string;
+  botName?: string;
+}): Promise<(data: unknown) => Promise<void>> {
   const register = vi.fn((registered: Record<string, (data: unknown) => Promise<void>>) => {
     handlers = registered;
   });
@@ -123,7 +150,11 @@ async function setupDebounceMonitor(): Promise<(data: unknown) => Promise<void>>
       error: vi.fn(),
       exit: vi.fn(),
     } as RuntimeEnv,
-    botOpenIdSource: { kind: "prefetched", botOpenId: "ou_bot" },
+    botOpenIdSource: {
+      kind: "prefetched",
+      botOpenId: params?.botOpenId ?? "ou_bot",
+      botName: params?.botName,
+    },
   });
 
   const onMessage = handlers["im.message.receive_v1"];
@@ -145,6 +176,30 @@ function getFirstDispatchedEvent(): FeishuMessageEvent {
   return firstParams.event;
 }
 
+function setDedupPassThroughMocks(): void {
+  vi.spyOn(dedup, "tryRecordMessage").mockReturnValue(true);
+  vi.spyOn(dedup, "tryRecordMessagePersistent").mockResolvedValue(true);
+  vi.spyOn(dedup, "hasRecordedMessage").mockReturnValue(false);
+  vi.spyOn(dedup, "hasRecordedMessagePersistent").mockResolvedValue(false);
+}
+
+function createMention(params: { openId: string; name: string; key?: string }): FeishuMention {
+  return {
+    key: params.key ?? "@_user_1",
+    id: { open_id: params.openId },
+    name: params.name,
+  };
+}
+
+async function enqueueDebouncedMessage(
+  onMessage: (data: unknown) => Promise<void>,
+  event: FeishuMessageEvent,
+): Promise<void> {
+  await onMessage(event);
+  await Promise.resolve();
+  await Promise.resolve();
+}
+
 describe("resolveReactionSyntheticEvent", () => {
   it("filters app self-reactions", async () => {
     const event = makeReactionEvent({ operator_type: "app" });
@@ -265,23 +320,12 @@ describe("resolveReactionSyntheticEvent", () => {
   });
 
   it("uses event chat context when provided", async () => {
-    const event = makeReactionEvent({
-      chat_id: "oc_group_from_event",
-      chat_type: "group",
-    });
-    const result = await resolveReactionSyntheticEvent({
-      cfg,
-      accountId: "default",
-      event,
-      botOpenId: "ou_bot",
-      fetchMessage: async () => ({
-        messageId: "om_msg1",
-        chatId: "oc_group_from_lookup",
-        senderOpenId: "ou_bot",
-        content: "hello",
-        contentType: "text",
+    const result = await resolveReactionWithLookup({
+      event: makeReactionEvent({
+        chat_id: "oc_group_from_event",
+        chat_type: "group",
       }),
-      uuid: () => "fixed-uuid",
+      lookupChatId: "oc_group_from_lookup",
     });
 
     expect(result).toEqual({
@@ -302,20 +346,8 @@ describe("resolveReactionSyntheticEvent", () => {
   });
 
   it("falls back to reacted message chat_id when event chat_id is absent", async () => {
-    const event = makeReactionEvent();
-    const result = await resolveReactionSyntheticEvent({
-      cfg,
-      accountId: "default",
-      event,
-      botOpenId: "ou_bot",
-      fetchMessage: async () => ({
-        messageId: "om_msg1",
-        chatId: "oc_group_from_lookup",
-        senderOpenId: "ou_bot",
-        content: "hello",
-        contentType: "text",
-      }),
-      uuid: () => "fixed-uuid",
+    const result = await resolveReactionWithLookup({
+      lookupChatId: "oc_group_from_lookup",
     });
 
     expect(result?.message.chat_id).toBe("oc_group_from_lookup");
@@ -323,20 +355,8 @@ describe("resolveReactionSyntheticEvent", () => {
   });
 
   it("falls back to sender p2p chat when lookup returns empty chat_id", async () => {
-    const event = makeReactionEvent();
-    const result = await resolveReactionSyntheticEvent({
-      cfg,
-      accountId: "default",
-      event,
-      botOpenId: "ou_bot",
-      fetchMessage: async () => ({
-        messageId: "om_msg1",
-        chatId: "",
-        senderOpenId: "ou_bot",
-        content: "hello",
-        contentType: "text",
-      }),
-      uuid: () => "fixed-uuid",
+    const result = await resolveReactionWithLookup({
+      lookupChatId: "",
     });
 
     expect(result?.message.chat_id).toBe("p2p:ou_user1");
@@ -389,42 +409,25 @@ describe("Feishu inbound debounce regressions", () => {
   });
 
   it("keeps bot mention when per-message mention keys collide across non-forward messages", async () => {
-    vi.spyOn(dedup, "tryRecordMessage").mockReturnValue(true);
-    vi.spyOn(dedup, "tryRecordMessagePersistent").mockResolvedValue(true);
-    vi.spyOn(dedup, "hasRecordedMessage").mockReturnValue(false);
-    vi.spyOn(dedup, "hasRecordedMessagePersistent").mockResolvedValue(false);
+    setDedupPassThroughMocks();
     const onMessage = await setupDebounceMonitor();
 
-    await onMessage(
+    await enqueueDebouncedMessage(
+      onMessage,
       createTextEvent({
         messageId: "om_1",
         text: "first",
-        mentions: [
-          {
-            key: "@_user_1",
-            id: { open_id: "ou_user_a" },
-            name: "user-a",
-          },
-        ],
+        mentions: [createMention({ openId: "ou_user_a", name: "user-a" })],
       }),
     );
-    await Promise.resolve();
-    await Promise.resolve();
-    await onMessage(
+    await enqueueDebouncedMessage(
+      onMessage,
       createTextEvent({
         messageId: "om_2",
         text: "@bot second",
-        mentions: [
-          {
-            key: "@_user_1",
-            id: { open_id: "ou_bot" },
-            name: "bot",
-          },
-        ],
+        mentions: [createMention({ openId: "ou_bot", name: "bot" })],
       }),
     );
-    await Promise.resolve();
-    await Promise.resolve();
     await vi.advanceTimersByTimeAsync(25);
 
     expect(handleFeishuMessageMock).toHaveBeenCalledTimes(1);
@@ -434,43 +437,57 @@ describe("Feishu inbound debounce regressions", () => {
     expect(mergedMentions.some((mention) => mention.id.open_id === "ou_user_a")).toBe(false);
   });
 
-  it("does not synthesize mention-forward intent across separate messages", async () => {
+  it("passes prefetched botName through to handleFeishuMessage", async () => {
     vi.spyOn(dedup, "tryRecordMessage").mockReturnValue(true);
     vi.spyOn(dedup, "tryRecordMessagePersistent").mockResolvedValue(true);
     vi.spyOn(dedup, "hasRecordedMessage").mockReturnValue(false);
     vi.spyOn(dedup, "hasRecordedMessagePersistent").mockResolvedValue(false);
-    const onMessage = await setupDebounceMonitor();
+    const onMessage = await setupDebounceMonitor({ botName: "OpenClaw Bot" });
 
     await onMessage(
       createTextEvent({
-        messageId: "om_user_mention",
-        text: "@alice first",
+        messageId: "om_name_passthrough",
+        text: "@bot hello",
         mentions: [
           {
             key: "@_user_1",
-            id: { open_id: "ou_alice" },
-            name: "alice",
+            id: { open_id: "ou_bot" },
+            name: "OpenClaw Bot",
           },
         ],
       }),
     );
     await Promise.resolve();
     await Promise.resolve();
-    await onMessage(
+    await vi.advanceTimersByTimeAsync(25);
+
+    expect(handleFeishuMessageMock).toHaveBeenCalledTimes(1);
+    const firstParams = handleFeishuMessageMock.mock.calls[0]?.[0] as
+      | { botName?: string }
+      | undefined;
+    expect(firstParams?.botName).toBe("OpenClaw Bot");
+  });
+
+  it("does not synthesize mention-forward intent across separate messages", async () => {
+    setDedupPassThroughMocks();
+    const onMessage = await setupDebounceMonitor();
+
+    await enqueueDebouncedMessage(
+      onMessage,
+      createTextEvent({
+        messageId: "om_user_mention",
+        text: "@alice first",
+        mentions: [createMention({ openId: "ou_alice", name: "alice" })],
+      }),
+    );
+    await enqueueDebouncedMessage(
+      onMessage,
       createTextEvent({
         messageId: "om_bot_mention",
         text: "@bot second",
-        mentions: [
-          {
-            key: "@_user_1",
-            id: { open_id: "ou_bot" },
-            name: "bot",
-          },
-        ],
+        mentions: [createMention({ openId: "ou_bot", name: "bot" })],
       }),
     );
-    await Promise.resolve();
-    await Promise.resolve();
     await vi.advanceTimersByTimeAsync(25);
 
     expect(handleFeishuMessageMock).toHaveBeenCalledTimes(1);
@@ -483,35 +500,24 @@ describe("Feishu inbound debounce regressions", () => {
   });
 
   it("preserves bot mention signal when the latest merged message has no mentions", async () => {
-    vi.spyOn(dedup, "tryRecordMessage").mockReturnValue(true);
-    vi.spyOn(dedup, "tryRecordMessagePersistent").mockResolvedValue(true);
-    vi.spyOn(dedup, "hasRecordedMessage").mockReturnValue(false);
-    vi.spyOn(dedup, "hasRecordedMessagePersistent").mockResolvedValue(false);
+    setDedupPassThroughMocks();
     const onMessage = await setupDebounceMonitor();
 
-    await onMessage(
+    await enqueueDebouncedMessage(
+      onMessage,
       createTextEvent({
         messageId: "om_bot_first",
         text: "@bot first",
-        mentions: [
-          {
-            key: "@_user_1",
-            id: { open_id: "ou_bot" },
-            name: "bot",
-          },
-        ],
+        mentions: [createMention({ openId: "ou_bot", name: "bot" })],
       }),
     );
-    await Promise.resolve();
-    await Promise.resolve();
-    await onMessage(
+    await enqueueDebouncedMessage(
+      onMessage,
       createTextEvent({
         messageId: "om_plain_second",
         text: "plain follow-up",
       }),
     );
-    await Promise.resolve();
-    await Promise.resolve();
     await vi.advanceTimersByTimeAsync(25);
 
     expect(handleFeishuMessageMock).toHaveBeenCalledTimes(1);

package/src/monitor.startup.test.ts

@@ -1,19 +1,13 @@
-import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import type { ClawdbotConfig } from "openclaw/plugin-sdk/feishu";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { monitorFeishuProvider, stopFeishuMonitor } from "./monitor.js";
 
 const probeFeishuMock = vi.hoisted(() => vi.fn());
-
-vi.mock("./probe.js", () => ({
-  probeFeishu: probeFeishuMock,
-}));
-
-vi.mock("./client.js", () => ({
+const feishuClientMockModule = vi.hoisted(() => ({
   createFeishuWSClient: vi.fn(() => ({ start: vi.fn() })),
   createEventDispatcher: vi.fn(() => ({ register: vi.fn() })),
 }));
-
-vi.mock("./runtime.js", () => ({
+const feishuRuntimeMockModule = vi.hoisted(() => ({
   getFeishuRuntime: () => ({
     channel: {
       debounce: {
@@ -30,6 +24,13 @@ vi.mock("./runtime.js", () => ({
   }),
 }));
 
+vi.mock("./probe.js", () => ({
+  probeFeishu: probeFeishuMock,
+}));
+
+vi.mock("./client.js", () => feishuClientMockModule);
+vi.mock("./runtime.js", () => feishuRuntimeMockModule);
+
 function buildMultiAccountWebsocketConfig(accountIds: string[]): ClawdbotConfig {
   return {
     channels: {
@@ -41,7 +42,7 @@ function buildMultiAccountWebsocketConfig(accountIds: string[]): ClawdbotConfig
             {
               enabled: true,
               appId: `cli_${accountId}`,
-              appSecret: `secret_${accountId}`,
+              appSecret: `secret_${accountId}`, // pragma: allowlist secret
               connectionMode: "websocket",
             },
           ]),

package/src/monitor.startup.ts

@@ -1,4 +1,4 @@
-import type { RuntimeEnv } from "openclaw/plugin-sdk";
+import type { RuntimeEnv } from "openclaw/plugin-sdk/feishu";
 import { probeFeishu } from "./probe.js";
 import type { ResolvedFeishuAccount } from "./types.js";
 
@@ -10,6 +10,11 @@ type FetchBotOpenIdOptions = {
   timeoutMs?: number;
 };
 
+export type FeishuMonitorBotIdentity = {
+  botOpenId?: string;
+  botName?: string;
+};
+
 function isTimeoutErrorMessage(message: string | undefined): boolean {
   return message?.toLowerCase().includes("timeout") || message?.toLowerCase().includes("timed out")
     ? true
@@ -20,12 +25,12 @@ function isAbortErrorMessage(message: string | undefined): boolean {
   return message?.toLowerCase().includes("aborted") ?? false;
 }
 
-export async function fetchBotOpenIdForMonitor(
+export async function fetchBotIdentityForMonitor(
   account: ResolvedFeishuAccount,
   options: FetchBotOpenIdOptions = {},
-): Promise<string | undefined> {
+): Promise<FeishuMonitorBotIdentity> {
   if (options.abortSignal?.aborted) {
-    return undefined;
+    return {};
   }
 
   const timeoutMs = options.timeoutMs ?? FEISHU_STARTUP_BOT_INFO_TIMEOUT_MS;
@@ -34,11 +39,11 @@ export async function fetchBotOpenIdForMonitor(
     abortSignal: options.abortSignal,
   });
   if (result.ok) {
-    return result.botOpenId;
+    return { botOpenId: result.botOpenId, botName: result.botName };
   }
 
   if (options.abortSignal?.aborted || isAbortErrorMessage(result.error)) {
-    return undefined;
+    return {};
   }
 
   if (isTimeoutErrorMessage(result.error)) {
@@ -47,5 +52,13 @@ export async function fetchBotOpenIdForMonitor(
       `feishu[${account.accountId}]: bot info probe timed out after ${timeoutMs}ms; continuing startup`,
     );
   }
-  return undefined;
+  return {};
+}
+
+export async function fetchBotOpenIdForMonitor(
+  account: ResolvedFeishuAccount,
+  options: FetchBotOpenIdOptions = {},
+): Promise<string | undefined> {
+  const identity = await fetchBotIdentityForMonitor(account, options);
+  return identity.botOpenId;
 }

package/src/monitor.state.ts

@@ -6,11 +6,12 @@ import {
   type RuntimeEnv,
   WEBHOOK_ANOMALY_COUNTER_DEFAULTS as WEBHOOK_ANOMALY_COUNTER_DEFAULTS_FROM_SDK,
   WEBHOOK_RATE_LIMIT_DEFAULTS as WEBHOOK_RATE_LIMIT_DEFAULTS_FROM_SDK,
-} from "openclaw/plugin-sdk";
+} from "openclaw/plugin-sdk/feishu";
 
 export const wsClients = new Map<string, Lark.WSClient>();
 export const httpServers = new Map<string, http.Server>();
 export const botOpenIds = new Map<string, string>();
+export const botNames = new Map<string, string>();
 
 export const FEISHU_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
 export const FEISHU_WEBHOOK_BODY_TIMEOUT_MS = 30_000;
@@ -140,6 +141,7 @@ export function stopFeishuMonitorState(accountId?: string): void {
       httpServers.delete(accountId);
     }
     botOpenIds.delete(accountId);
+    botNames.delete(accountId);
     return;
   }
 
@@ -149,4 +151,5 @@ export function stopFeishuMonitorState(accountId?: string): void {
   }
   httpServers.clear();
   botOpenIds.clear();
+  botNames.clear();
 }