@gakr-gakr/feishu 0.1.0

package/src/monitor.message-handler.ts

@@ -0,0 +1,350 @@
+import type { ClawdbotConfig, HistoryEntry, PluginRuntime, RuntimeEnv } from "../runtime-api.js";
+import { resolveFeishuMessageDedupeKey } from "./dedupe-key.js";
+import type { FeishuMessageEvent } from "./event-types.js";
+import { isMentionForwardRequest } from "./mention.js";
+import {
+  releaseFeishuMessageProcessing,
+  tryBeginFeishuMessageProcessing,
+} from "./processing-claims.js";
+import { createSequentialQueue } from "./sequential-queue.js";
+import type { FeishuChatType } from "./types.js";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === "string" ? value : undefined;
+}
+
+type FeishuMessageReceiveHandlerContext = {
+  cfg: ClawdbotConfig;
+  core: PluginRuntime;
+  accountId: string;
+  runtime?: RuntimeEnv;
+  chatHistories: Map<string, HistoryEntry[]>;
+  fireAndForget?: boolean;
+  handleMessage: (params: {
+    cfg: ClawdbotConfig;
+    event: FeishuMessageEvent;
+    botOpenId?: string;
+    botName?: string;
+    runtime?: RuntimeEnv;
+    chatHistories?: Map<string, HistoryEntry[]>;
+    accountId?: string;
+    processingClaimHeld?: boolean;
+  }) => Promise<void>;
+  resolveDebounceText: (params: {
+    event: FeishuMessageEvent;
+    botOpenId?: string;
+    botName?: string;
+  }) => string;
+  hasProcessedMessage: (
+    messageId: string | undefined | null,
+    namespace: string,
+    log?: (...args: unknown[]) => void,
+  ) => Promise<boolean>;
+  recordProcessedMessage: (
+    messageId: string | undefined | null,
+    namespace: string,
+    log?: (...args: unknown[]) => void,
+  ) => Promise<boolean>;
+  getBotOpenId?: (accountId: string) => string | undefined;
+  getBotName?: (accountId: string) => string | undefined;
+  resolveSequentialKey?: (params: {
+    accountId: string;
+    event: FeishuMessageEvent;
+    botOpenId?: string;
+    botName?: string;
+  }) => string;
+};
+
+function normalizeFeishuChatType(value: unknown): FeishuChatType | undefined {
+  return value === "group" || value === "topic_group" || value === "private" || value === "p2p"
+    ? value
+    : undefined;
+}
+
+function parseFeishuMessageEventPayload(value: unknown): FeishuMessageEvent | null {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const sender = value.sender;
+  const message = value.message;
+  if (!isRecord(sender) || !isRecord(message)) {
+    return null;
+  }
+  const senderId = sender.sender_id;
+  if (!isRecord(senderId)) {
+    return null;
+  }
+  const messageId = readString(message.message_id);
+  const chatId = readString(message.chat_id);
+  const chatType = normalizeFeishuChatType(message.chat_type);
+  const messageType = readString(message.message_type);
+  const content = readString(message.content);
+  if (!messageId || !chatId || !chatType || !messageType || !content) {
+    return null;
+  }
+  return value as FeishuMessageEvent;
+}
+
+function mergeFeishuDebounceMentions(
+  entries: FeishuMessageEvent[],
+): FeishuMessageEvent["message"]["mentions"] | undefined {
+  const merged = new Map<string, NonNullable<FeishuMessageEvent["message"]["mentions"]>[number]>();
+  for (const entry of entries) {
+    for (const mention of entry.message.mentions ?? []) {
+      const stableId =
+        mention.id.open_id?.trim() || mention.id.user_id?.trim() || mention.id.union_id?.trim();
+      const mentionName = mention.name?.trim();
+      const mentionKey = mention.key?.trim();
+      const fallback =
+        mentionName && mentionKey ? `${mentionName}|${mentionKey}` : mentionName || mentionKey;
+      const key = stableId || fallback;
+      if (!key || merged.has(key)) {
+        continue;
+      }
+      merged.set(key, mention);
+    }
+  }
+  return merged.size > 0 ? Array.from(merged.values()) : undefined;
+}
+
+function dedupeFeishuDebounceEntriesByDedupeKey(
+  entries: FeishuMessageEvent[],
+): FeishuMessageEvent[] {
+  const seen = new Set<string>();
+  const deduped: FeishuMessageEvent[] = [];
+  for (const entry of entries) {
+    const dedupeKey = resolveFeishuMessageDedupeKey(entry);
+    if (!dedupeKey) {
+      deduped.push(entry);
+      continue;
+    }
+    if (seen.has(dedupeKey)) {
+      continue;
+    }
+    seen.add(dedupeKey);
+    deduped.push(entry);
+  }
+  return deduped;
+}
+
+function resolveFeishuDebounceMentions(params: {
+  entries: FeishuMessageEvent[];
+  botOpenId?: string;
+}): FeishuMessageEvent["message"]["mentions"] | undefined {
+  const { entries, botOpenId } = params;
+  if (entries.length === 0) {
+    return undefined;
+  }
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (isMentionForwardRequest(entry, botOpenId)) {
+      return mergeFeishuDebounceMentions([entry]);
+    }
+  }
+  const merged = mergeFeishuDebounceMentions(entries);
+  if (!merged) {
+    return undefined;
+  }
+  const normalizedBotOpenId = botOpenId?.trim();
+  if (!normalizedBotOpenId) {
+    return undefined;
+  }
+  const botMentions = merged.filter(
+    (mention) => mention.id.open_id?.trim() === normalizedBotOpenId,
+  );
+  return botMentions.length > 0 ? botMentions : undefined;
+}
+
+export function createFeishuMessageReceiveHandler({
+  cfg,
+  core,
+  accountId,
+  runtime,
+  chatHistories,
+  fireAndForget,
+  handleMessage,
+  resolveDebounceText: resolveText,
+  hasProcessedMessage,
+  recordProcessedMessage,
+  getBotOpenId = () => undefined,
+  getBotName = () => undefined,
+  resolveSequentialKey = ({ accountId, event }) =>
+    `feishu:${accountId}:${event.message.chat_id?.trim() || "unknown"}`,
+}: FeishuMessageReceiveHandlerContext): (data: unknown) => Promise<void> {
+  const inboundDebounceMs = core.channel.debounce.resolveInboundDebounceMs({
+    cfg,
+    channel: "feishu",
+  });
+  const log = runtime?.log ?? console.log;
+  const error = runtime?.error ?? console.error;
+  const enqueue = createSequentialQueue({
+    onTaskTimeout: (key, timeoutMs) => {
+      log(
+        `feishu[${accountId}]: per-chat task exceeded ${timeoutMs}ms cap (key=${key}); evicting from queue so later same-key messages can proceed (#70133)`,
+      );
+    },
+  });
+
+  const dispatchFeishuMessage = async (event: FeishuMessageEvent) => {
+    const sequentialKey = resolveSequentialKey({
+      accountId,
+      event,
+      botOpenId: getBotOpenId(accountId),
+      botName: getBotName(accountId),
+    });
+    const task = () =>
+      handleMessage({
+        cfg,
+        event,
+        botOpenId: getBotOpenId(accountId),
+        botName: getBotName(accountId),
+        runtime,
+        chatHistories,
+        accountId,
+        processingClaimHeld: true,
+      });
+    await enqueue(sequentialKey, task);
+  };
+
+  const resolveSenderDebounceId = (event: FeishuMessageEvent): string | undefined => {
+    const senderId =
+      event.sender.sender_id.open_id?.trim() || event.sender.sender_id.user_id?.trim();
+    return senderId || undefined;
+  };
+
+  const resolveDebounceText = (event: FeishuMessageEvent): string => {
+    return resolveText({
+      event,
+      botOpenId: getBotOpenId(accountId),
+      botName: getBotName(accountId),
+    }).trim();
+  };
+
+  const recordSuppressedMessageIds = async (
+    entries: FeishuMessageEvent[],
+    dispatchDedupeKey?: string,
+  ) => {
+    const keepDedupeKey = dispatchDedupeKey?.trim();
+    const suppressedIds = new Set(
+      entries
+        .map((entry) => resolveFeishuMessageDedupeKey(entry))
+        .filter((id): id is string => Boolean(id) && (!keepDedupeKey || id !== keepDedupeKey)),
+    );
+    for (const messageId of suppressedIds) {
+      try {
+        await recordProcessedMessage(messageId, accountId, log);
+      } catch (err) {
+        error(
+          `feishu[${accountId}]: failed to record merged dedupe id ${messageId}: ${String(err)}`,
+        );
+      }
+    }
+  };
+
+  const inboundDebouncer = core.channel.debounce.createInboundDebouncer<FeishuMessageEvent>({
+    debounceMs: inboundDebounceMs,
+    buildKey: (event) => {
+      const chatId = event.message.chat_id?.trim();
+      const senderId = resolveSenderDebounceId(event);
+      if (!chatId || !senderId) {
+        return null;
+      }
+      const rootId = event.message.root_id?.trim();
+      const threadKey = rootId ? `thread:${rootId}` : "chat";
+      return `feishu:${accountId}:${chatId}:${threadKey}:${senderId}`;
+    },
+    shouldDebounce: (event) => {
+      if (event.message.message_type !== "text") {
+        return false;
+      }
+      const text = resolveDebounceText(event);
+      return Boolean(text) && !core.channel.text.hasControlCommand(text, cfg);
+    },
+    onFlush: async (entries) => {
+      const last = entries.at(-1);
+      if (!last) {
+        return;
+      }
+      if (entries.length === 1) {
+        await dispatchFeishuMessage(last);
+        return;
+      }
+      const dedupedEntries = dedupeFeishuDebounceEntriesByDedupeKey(entries);
+      const freshEntries: FeishuMessageEvent[] = [];
+      for (const entry of dedupedEntries) {
+        if (!(await hasProcessedMessage(resolveFeishuMessageDedupeKey(entry), accountId, log))) {
+          freshEntries.push(entry);
+        }
+      }
+      const dispatchEntry = freshEntries.at(-1);
+      if (!dispatchEntry) {
+        return;
+      }
+      await recordSuppressedMessageIds(
+        dedupedEntries,
+        resolveFeishuMessageDedupeKey(dispatchEntry),
+      );
+      const combinedText = freshEntries
+        .map((entry) => resolveDebounceText(entry))
+        .filter(Boolean)
+        .join("\n");
+      const mergedMentions = resolveFeishuDebounceMentions({
+        entries: freshEntries,
+        botOpenId: getBotOpenId(accountId),
+      });
+      await dispatchFeishuMessage({
+        ...dispatchEntry,
+        message: {
+          ...dispatchEntry.message,
+          ...(combinedText.trim()
+            ? {
+                message_type: "text",
+                content: JSON.stringify({ text: combinedText }),
+              }
+            : {}),
+          mentions: mergedMentions ?? dispatchEntry.message.mentions,
+        },
+      });
+    },
+    onError: (err, entries) => {
+      for (const entry of entries) {
+        releaseFeishuMessageProcessing(resolveFeishuMessageDedupeKey(entry), accountId);
+      }
+      error(`feishu[${accountId}]: inbound debounce flush failed: ${String(err)}`);
+    },
+  });
+
+  return async (data) => {
+    const event = parseFeishuMessageEventPayload(data);
+    if (!event) {
+      error(`feishu[${accountId}]: ignoring malformed message event payload`);
+      return;
+    }
+    const messageId = event.message?.message_id?.trim();
+    const messageDedupeKey = resolveFeishuMessageDedupeKey(event);
+    if (!tryBeginFeishuMessageProcessing(messageDedupeKey, accountId)) {
+      log(`feishu[${accountId}]: dropping duplicate event for message ${messageId}`);
+      return;
+    }
+    const processMessage = async () => {
+      await inboundDebouncer.enqueue(event);
+    };
+    if (fireAndForget) {
+      void processMessage().catch((err) => {
+        releaseFeishuMessageProcessing(messageDedupeKey, accountId);
+        error(`feishu[${accountId}]: error handling message: ${String(err)}`);
+      });
+      return;
+    }
+    try {
+      await processMessage();
+    } catch (err) {
+      releaseFeishuMessageProcessing(messageDedupeKey, accountId);
+      error(`feishu[${accountId}]: error handling message: ${String(err)}`);
+    }
+  };
+}

package/src/monitor.reaction.lifecycle.test-support.ts

@@ -0,0 +1,68 @@
+import { describe, expect, it } from "vitest";
+import type { ClawdbotConfig } from "../runtime-api.js";
+import {
+  resolveReactionSyntheticEvent,
+  type FeishuReactionCreatedEvent,
+} from "./monitor.account.js";
+
+const cfg = {} as ClawdbotConfig;
+
+function makeReactionEvent(
+  overrides: Partial<FeishuReactionCreatedEvent> = {},
+): FeishuReactionCreatedEvent {
+  return {
+    message_id: "om_msg1",
+    reaction_type: { emoji_type: "THUMBSUP" },
+    operator_type: "user",
+    user_id: { open_id: "ou_user1" },
+    ...overrides,
+  };
+}
+
+describe("Feishu reaction lifecycle", () => {
+  it("builds a created synthetic interaction payload", async () => {
+    const result = await resolveReactionSyntheticEvent({
+      cfg,
+      accountId: "default",
+      event: makeReactionEvent({ user_id: { open_id: "ou_user1", user_id: "on_user1" } }),
+      botOpenId: "ou_bot",
+      fetchMessage: async () => ({
+        messageId: "om_msg1",
+        chatId: "oc_group_1",
+        chatType: "group",
+        senderOpenId: "ou_bot",
+        senderType: "app",
+        content: "hello",
+        contentType: "text",
+      }),
+      uuid: () => "fixed-uuid",
+    });
+
+    expect(result?.sender.sender_id).toEqual({ open_id: "ou_user1", user_id: "on_user1" });
+    expect(result?.message.content).toBe('{"text":"[reacted with THUMBSUP to message om_msg1]"}');
+  });
+
+  it("builds a deleted synthetic interaction payload", async () => {
+    const result = await resolveReactionSyntheticEvent({
+      cfg,
+      accountId: "default",
+      event: makeReactionEvent(),
+      botOpenId: "ou_bot",
+      fetchMessage: async () => ({
+        messageId: "om_msg1",
+        chatId: "oc_group_1",
+        chatType: "group",
+        senderOpenId: "ou_bot",
+        senderType: "app",
+        content: "hello",
+        contentType: "text",
+      }),
+      uuid: () => "fixed-uuid",
+      action: "deleted",
+    });
+
+    expect(result?.message.content).toBe(
+      '{"text":"[removed reaction THUMBSUP from message om_msg1]"}',
+    );
+  });
+});

package/src/monitor.startup.ts

@@ -0,0 +1,74 @@
+import { normalizeLowercaseStringOrEmpty } from "autobot/plugin-sdk/string-coerce-runtime";
+import type { RuntimeEnv } from "../runtime-api.js";
+import { probeFeishu } from "./probe.js";
+import type { ResolvedFeishuAccount } from "./types.js";
+
+const FEISHU_STARTUP_BOT_INFO_TIMEOUT_DEFAULT_MS = 30_000;
+const FEISHU_STARTUP_BOT_INFO_TIMEOUT_ENV = "AUTOBOT_FEISHU_STARTUP_PROBE_TIMEOUT_MS";
+
+function resolveStartupProbeTimeoutMs(): number {
+  const raw = process.env[FEISHU_STARTUP_BOT_INFO_TIMEOUT_ENV];
+  if (raw) {
+    const parsed = Number(raw);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      return Math.floor(parsed);
+    }
+    console.warn(
+      `[feishu] ${FEISHU_STARTUP_BOT_INFO_TIMEOUT_ENV}="${raw}" is invalid; using default ${FEISHU_STARTUP_BOT_INFO_TIMEOUT_DEFAULT_MS}ms`,
+    );
+  }
+  return FEISHU_STARTUP_BOT_INFO_TIMEOUT_DEFAULT_MS;
+}
+
+const FEISHU_STARTUP_BOT_INFO_TIMEOUT_MS = resolveStartupProbeTimeoutMs();
+
+type FetchBotOpenIdOptions = {
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  timeoutMs?: number;
+};
+
+export type FeishuMonitorBotIdentity = {
+  botOpenId?: string;
+  botName?: string;
+};
+
+function isTimeoutErrorMessage(message: string | undefined): boolean {
+  const lower = normalizeLowercaseStringOrEmpty(message);
+  return lower.includes("timeout") || lower.includes("timed out");
+}
+
+function isAbortErrorMessage(message: string | undefined): boolean {
+  return normalizeLowercaseStringOrEmpty(message).includes("aborted");
+}
+
+export async function fetchBotIdentityForMonitor(
+  account: ResolvedFeishuAccount,
+  options: FetchBotOpenIdOptions = {},
+): Promise<FeishuMonitorBotIdentity> {
+  if (options.abortSignal?.aborted) {
+    return {};
+  }
+
+  const timeoutMs = options.timeoutMs ?? FEISHU_STARTUP_BOT_INFO_TIMEOUT_MS;
+  const result = await probeFeishu(account, {
+    timeoutMs,
+    abortSignal: options.abortSignal,
+  });
+  if (result.ok) {
+    return { botOpenId: result.botOpenId, botName: result.botName };
+  }
+
+  const probeError = result.error ?? undefined;
+  if (options.abortSignal?.aborted || isAbortErrorMessage(probeError)) {
+    return {};
+  }
+
+  if (isTimeoutErrorMessage(probeError)) {
+    const error = options.runtime?.error ?? console.error;
+    error(
+      `feishu[${account.accountId}]: bot info probe timed out after ${timeoutMs}ms; continuing startup`,
+    );
+  }
+  return {};
+}

package/src/monitor.state.ts

@@ -0,0 +1,170 @@
+import * as http from "node:http";
+import type * as Lark from "@larksuiteoapi/node-sdk";
+import {
+  createFixedWindowRateLimiter,
+  createWebhookAnomalyTracker,
+  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 "./monitor-state-runtime-api.js";
+
+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 = 64 * 1024;
+export const FEISHU_WEBHOOK_BODY_TIMEOUT_MS = 5_000;
+
+type WebhookRateLimitDefaults = {
+  windowMs: number;
+  maxRequests: number;
+  maxTrackedKeys: number;
+};
+
+type WebhookAnomalyDefaults = {
+  maxTrackedKeys: number;
+  ttlMs: number;
+  logEvery: number;
+};
+
+const FEISHU_WEBHOOK_RATE_LIMIT_FALLBACK_DEFAULTS: WebhookRateLimitDefaults = {
+  windowMs: 60_000,
+  maxRequests: 120,
+  maxTrackedKeys: 4_096,
+};
+
+const FEISHU_WEBHOOK_ANOMALY_FALLBACK_DEFAULTS: WebhookAnomalyDefaults = {
+  maxTrackedKeys: 4_096,
+  ttlMs: 6 * 60 * 60_000,
+  logEvery: 25,
+};
+
+function coercePositiveInt(value: unknown, fallback: number): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  const normalized = Math.floor(value);
+  return normalized > 0 ? normalized : fallback;
+}
+
+export function resolveFeishuWebhookRateLimitDefaultsForTest(
+  defaults: unknown,
+): WebhookRateLimitDefaults {
+  const resolved = defaults as Partial<WebhookRateLimitDefaults> | null | undefined;
+  return {
+    windowMs: coercePositiveInt(
+      resolved?.windowMs,
+      FEISHU_WEBHOOK_RATE_LIMIT_FALLBACK_DEFAULTS.windowMs,
+    ),
+    maxRequests: coercePositiveInt(
+      resolved?.maxRequests,
+      FEISHU_WEBHOOK_RATE_LIMIT_FALLBACK_DEFAULTS.maxRequests,
+    ),
+    maxTrackedKeys: coercePositiveInt(
+      resolved?.maxTrackedKeys,
+      FEISHU_WEBHOOK_RATE_LIMIT_FALLBACK_DEFAULTS.maxTrackedKeys,
+    ),
+  };
+}
+
+export function resolveFeishuWebhookAnomalyDefaultsForTest(
+  defaults: unknown,
+): WebhookAnomalyDefaults {
+  const resolved = defaults as Partial<WebhookAnomalyDefaults> | null | undefined;
+  return {
+    maxTrackedKeys: coercePositiveInt(
+      resolved?.maxTrackedKeys,
+      FEISHU_WEBHOOK_ANOMALY_FALLBACK_DEFAULTS.maxTrackedKeys,
+    ),
+    ttlMs: coercePositiveInt(resolved?.ttlMs, FEISHU_WEBHOOK_ANOMALY_FALLBACK_DEFAULTS.ttlMs),
+    logEvery: coercePositiveInt(
+      resolved?.logEvery,
+      FEISHU_WEBHOOK_ANOMALY_FALLBACK_DEFAULTS.logEvery,
+    ),
+  };
+}
+
+const feishuWebhookRateLimitDefaults = resolveFeishuWebhookRateLimitDefaultsForTest(
+  WEBHOOK_RATE_LIMIT_DEFAULTS_FROM_SDK,
+);
+const feishuWebhookAnomalyDefaults = resolveFeishuWebhookAnomalyDefaultsForTest(
+  WEBHOOK_ANOMALY_COUNTER_DEFAULTS_FROM_SDK,
+);
+
+export const feishuWebhookRateLimiter = createFixedWindowRateLimiter({
+  windowMs: feishuWebhookRateLimitDefaults.windowMs,
+  maxRequests: feishuWebhookRateLimitDefaults.maxRequests,
+  maxTrackedKeys: feishuWebhookRateLimitDefaults.maxTrackedKeys,
+});
+
+const feishuWebhookAnomalyTracker = createWebhookAnomalyTracker({
+  maxTrackedKeys: feishuWebhookAnomalyDefaults.maxTrackedKeys,
+  ttlMs: feishuWebhookAnomalyDefaults.ttlMs,
+  logEvery: feishuWebhookAnomalyDefaults.logEvery,
+});
+
+function closeWsClient(client: Lark.WSClient | undefined): void {
+  if (!client) {
+    return;
+  }
+  try {
+    client.close();
+  } catch {
+    /* Best-effort cleanup */
+  }
+}
+
+export function clearFeishuWebhookRateLimitStateForTest(): void {
+  feishuWebhookRateLimiter.clear();
+  feishuWebhookAnomalyTracker.clear();
+}
+
+export function getFeishuWebhookRateLimitStateSizeForTest(): number {
+  return feishuWebhookRateLimiter.size();
+}
+
+export function isWebhookRateLimitedForTest(key: string, nowMs: number): boolean {
+  return feishuWebhookRateLimiter.isRateLimited(key, nowMs);
+}
+
+export function recordWebhookStatus(
+  runtime: RuntimeEnv | undefined,
+  accountId: string,
+  path: string,
+  statusCode: number,
+): void {
+  feishuWebhookAnomalyTracker.record({
+    key: `${accountId}:${path}:${statusCode}`,
+    statusCode,
+    log: runtime?.log ?? console.log,
+    message: (count) =>
+      `feishu[${accountId}]: webhook anomaly path=${path} status=${statusCode} count=${count}`,
+  });
+}
+
+export function stopFeishuMonitorState(accountId?: string): void {
+  if (accountId) {
+    closeWsClient(wsClients.get(accountId));
+    wsClients.delete(accountId);
+    const server = httpServers.get(accountId);
+    if (server) {
+      server.close();
+      httpServers.delete(accountId);
+    }
+    botOpenIds.delete(accountId);
+    botNames.delete(accountId);
+    return;
+  }
+
+  for (const client of wsClients.values()) {
+    closeWsClient(client);
+  }
+  wsClients.clear();
+  for (const server of httpServers.values()) {
+    server.close();
+  }
+  httpServers.clear();
+  botOpenIds.clear();
+  botNames.clear();
+}

package/src/monitor.synthetic-error.ts

@@ -0,0 +1,18 @@
+export class FeishuRetryableSyntheticEventError extends Error {
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "FeishuRetryableSyntheticEventError";
+  }
+}
+
+export function isFeishuRetryableSyntheticEventError(
+  error: unknown,
+): error is FeishuRetryableSyntheticEventError {
+  return (
+    error instanceof FeishuRetryableSyntheticEventError ||
+    (typeof error === "object" &&
+      error !== null &&
+      "name" in error &&
+      error.name === "FeishuRetryableSyntheticEventError")
+  );
+}