@elizaos/plugin-feishu 2.0.0-alpha

package/dist/index.js

@@ -0,0 +1,1391 @@
+// src/constants.ts
+var FEISHU_SERVICE_NAME = "feishu";
+var FEISHU_DOMAINS = {
+  feishu: "https://open.feishu.cn",
+  lark: "https://open.larksuite.com"
+};
+var MAX_MESSAGE_LENGTH = 4000;
+var DEFAULT_TIMEOUT_MS = 30000;
+
+// src/actions/sendMessage.ts
+var SEND_MESSAGE_ACTION = "SEND_FEISHU_MESSAGE";
+var sendMessageAction = {
+  name: SEND_MESSAGE_ACTION,
+  similes: [
+    "FEISHU_SEND_MESSAGE",
+    "FEISHU_REPLY",
+    "FEISHU_MESSAGE",
+    "SEND_FEISHU",
+    "REPLY_FEISHU",
+    "LARK_SEND_MESSAGE",
+    "LARK_REPLY",
+    "SEND_LARK"
+  ],
+  description: "Send a message to a Feishu/Lark chat",
+  validate: async (_runtime, message) => {
+    const source = message.content?.source;
+    return source === "feishu";
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    const feishuService = runtime.getService(FEISHU_SERVICE_NAME);
+    if (!feishuService) {
+      if (callback) {
+        await callback({
+          text: "Feishu service not available"
+        });
+      }
+      return { success: false, error: "Feishu service not initialized" };
+    }
+    const currentState = state ?? await runtime.composeState(message);
+    const responseText = currentState.values?.response?.toString() || "";
+    const chatId = message.content?.chatId;
+    if (!chatId) {
+      if (callback) {
+        await callback({
+          text: "No chat ID available"
+        });
+      }
+      return { success: false, error: "Missing chat ID" };
+    }
+    if (callback) {
+      await callback({
+        text: responseText,
+        action: SEND_MESSAGE_ACTION
+      });
+    }
+    return {
+      success: true,
+      data: {
+        action: SEND_MESSAGE_ACTION,
+        chatId,
+        text: responseText,
+        replyToMessageId: message.content?.messageId
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "Send a message to this Feishu chat"
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "I'll send a message to this chat now.",
+          actions: [SEND_MESSAGE_ACTION]
+        }
+      }
+    ]
+  ]
+};
+// src/messageManager.ts
+import {
+  ChannelType,
+  createUniqueUuid,
+  EventType,
+  logger
+} from "@elizaos/core";
+
+// src/environment.ts
+function getFeishuConfig(runtime) {
+  const appId = runtime.getSetting("FEISHU_APP_ID");
+  const appSecret = runtime.getSetting("FEISHU_APP_SECRET");
+  if (!appId || !appSecret) {
+    return null;
+  }
+  const domainSetting = runtime.getSetting("FEISHU_DOMAIN")?.toLowerCase();
+  const domain = domainSetting === "lark" ? "lark" : "feishu";
+  const apiRoot = FEISHU_DOMAINS[domain];
+  let allowedChatIds = [];
+  const allowedChatsRaw = runtime.getSetting("FEISHU_ALLOWED_CHATS");
+  if (allowedChatsRaw) {
+    try {
+      const parsed = JSON.parse(allowedChatsRaw);
+      if (Array.isArray(parsed)) {
+        allowedChatIds = parsed.map(String);
+      }
+    } catch {}
+  }
+  const testChatId = runtime.getSetting("FEISHU_TEST_CHAT_ID");
+  const shouldIgnoreBotMessages = runtime.getSetting("FEISHU_IGNORE_BOT_MESSAGES")?.toLowerCase() !== "false";
+  const shouldRespondOnlyToMentions = runtime.getSetting("FEISHU_RESPOND_ONLY_TO_MENTIONS")?.toLowerCase() === "true";
+  return {
+    appId,
+    appSecret,
+    domain,
+    apiRoot,
+    allowedChatIds,
+    testChatId,
+    shouldIgnoreBotMessages,
+    shouldRespondOnlyToMentions
+  };
+}
+function validateConfig(config) {
+  if (!config.appId) {
+    return { valid: false, error: "FEISHU_APP_ID is required" };
+  }
+  if (!config.appId.startsWith("cli_")) {
+    return { valid: false, error: "FEISHU_APP_ID should start with 'cli_'" };
+  }
+  if (!config.appSecret) {
+    return { valid: false, error: "FEISHU_APP_SECRET is required" };
+  }
+  return { valid: true };
+}
+function isChatAllowed(config, chatId) {
+  if (config.allowedChatIds.length === 0) {
+    return true;
+  }
+  return config.allowedChatIds.includes(chatId);
+}
+
+// src/types.ts
+var FeishuEventTypes;
+((FeishuEventTypes2) => {
+  FeishuEventTypes2["WORLD_JOINED"] = "FEISHU_WORLD_JOINED";
+  FeishuEventTypes2["WORLD_CONNECTED"] = "FEISHU_WORLD_CONNECTED";
+  FeishuEventTypes2["WORLD_LEFT"] = "FEISHU_WORLD_LEFT";
+  FeishuEventTypes2["ENTITY_JOINED"] = "FEISHU_ENTITY_JOINED";
+  FeishuEventTypes2["ENTITY_LEFT"] = "FEISHU_ENTITY_LEFT";
+  FeishuEventTypes2["ENTITY_UPDATED"] = "FEISHU_ENTITY_UPDATED";
+  FeishuEventTypes2["MESSAGE_RECEIVED"] = "FEISHU_MESSAGE_RECEIVED";
+  FeishuEventTypes2["MESSAGE_SENT"] = "FEISHU_MESSAGE_SENT";
+  FeishuEventTypes2["REACTION_RECEIVED"] = "FEISHU_REACTION_RECEIVED";
+  FeishuEventTypes2["INTERACTION_RECEIVED"] = "FEISHU_INTERACTION_RECEIVED";
+  FeishuEventTypes2["SLASH_START"] = "FEISHU_SLASH_START";
+})(FeishuEventTypes ||= {});
+var FeishuChatType;
+((FeishuChatType2) => {
+  FeishuChatType2["P2P"] = "p2p";
+  FeishuChatType2["GROUP"] = "group";
+})(FeishuChatType ||= {});
+
+// src/messageManager.ts
+class MessageManager {
+  client;
+  runtime;
+  config;
+  processedMessages = new Set;
+  botOpenId = null;
+  constructor(client, runtime, config) {
+    this.client = client;
+    this.runtime = runtime;
+    this.config = config;
+  }
+  setBotOpenId(openId) {
+    this.botOpenId = openId;
+  }
+  async handleMessage(event) {
+    try {
+      const message = event.event?.message;
+      if (!message) {
+        return;
+      }
+      if (this.processedMessages.has(message.messageId)) {
+        return;
+      }
+      this.processedMessages.add(message.messageId);
+      if (this.processedMessages.size > 1000) {
+        const firstKey = this.processedMessages.values().next().value;
+        this.processedMessages.delete(firstKey);
+      }
+      const chatId = message.chatId;
+      const chatType = event.event?.chat_type || "p2p";
+      if (!isChatAllowed(this.config, chatId)) {
+        logger.debug(`[Feishu] Chat ${chatId} not authorized, skipping`);
+        return;
+      }
+      const sender = this.parseSender(event);
+      if (this.config.shouldIgnoreBotMessages && sender.isBot) {
+        logger.debug("[Feishu] Ignoring bot message");
+        return;
+      }
+      if (this.config.shouldRespondOnlyToMentions && chatType !== "p2p") {
+        if (!this.isBotMentioned(message)) {
+          logger.debug("[Feishu] Bot not mentioned, skipping");
+          return;
+        }
+      }
+      const text = this.parseMessageContent(message);
+      const chat = {
+        chatId,
+        chatType,
+        name: event.event?.chat_name || undefined
+      };
+      const roomId = createUniqueUuid(this.runtime, chatId);
+      const entityId = createUniqueUuid(this.runtime, sender.openId);
+      const worldId = createUniqueUuid(this.runtime, chatId);
+      await this.runtime.ensureConnection({
+        entityId,
+        roomId,
+        userName: sender.name,
+        userId: sender.openId,
+        name: sender.name || "Unknown User",
+        source: "feishu",
+        channelId: chatId,
+        messageServerId: worldId,
+        type: chatType === "p2p" ? ChannelType.DM : ChannelType.GROUP,
+        worldId
+      });
+      const memory = {
+        id: createUniqueUuid(this.runtime, message.messageId),
+        entityId,
+        roomId,
+        agentId: this.runtime.agentId,
+        content: {
+          text,
+          source: "feishu",
+          chatId,
+          messageId: message.messageId
+        },
+        createdAt: Number.parseInt(message.createTime, 10)
+      };
+      const payload = {
+        runtime: this.runtime,
+        message: memory,
+        source: "feishu",
+        originalMessage: message,
+        chat,
+        sender
+      };
+      this.runtime.emitEvent("FEISHU_MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */, payload);
+      this.runtime.emitEvent(EventType.MESSAGE_RECEIVED, payload);
+    } catch (error) {
+      logger.error(`[Feishu] Error handling message: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async sendMessage(chatId, content) {
+    const messageIds = [];
+    try {
+      const text = content.text || "";
+      if (content.card) {
+        const response = await this.client.im.message.create({
+          params: { receive_id_type: "chat_id" },
+          data: {
+            receive_id: chatId,
+            msg_type: "interactive",
+            content: JSON.stringify(content.card)
+          }
+        });
+        if (response.data?.message_id) {
+          messageIds.push(response.data.message_id);
+        }
+        return messageIds;
+      }
+      if (content.imageKey) {
+        const response = await this.client.im.message.create({
+          params: { receive_id_type: "chat_id" },
+          data: {
+            receive_id: chatId,
+            msg_type: "image",
+            content: JSON.stringify({ image_key: content.imageKey })
+          }
+        });
+        if (response.data?.message_id) {
+          messageIds.push(response.data.message_id);
+        }
+        return messageIds;
+      }
+      const parts = this.splitMessage(text);
+      for (const part of parts) {
+        const response = await this.client.im.message.create({
+          params: { receive_id_type: "chat_id" },
+          data: {
+            receive_id: chatId,
+            msg_type: "text",
+            content: JSON.stringify({ text: part })
+          }
+        });
+        if (response.data?.message_id) {
+          messageIds.push(response.data.message_id);
+        }
+      }
+      return messageIds;
+    } catch (error) {
+      logger.error(`[Feishu] Error sending message: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+  }
+  async replyToMessage(messageId, content) {
+    const messageIds = [];
+    try {
+      const text = content.text || "";
+      const parts = this.splitMessage(text);
+      for (const part of parts) {
+        const response = await this.client.im.message.reply({
+          path: { message_id: messageId },
+          data: {
+            msg_type: "text",
+            content: JSON.stringify({ text: part })
+          }
+        });
+        if (response.data?.message_id) {
+          messageIds.push(response.data.message_id);
+        }
+      }
+      return messageIds;
+    } catch (error) {
+      logger.error(`[Feishu] Error replying to message: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+  }
+  parseSender(event) {
+    const sender = event.event?.sender;
+    const isBot = sender?.sender_type === "app";
+    const openId = sender?.sender_id?.open_id || "";
+    return {
+      openId,
+      unionId: sender?.sender_id?.union_id,
+      userId: sender?.sender_id?.user_id,
+      isBot
+    };
+  }
+  parseMessageContent(message) {
+    try {
+      const content = JSON.parse(message.content);
+      switch (message.msgType) {
+        case "text":
+          return content.text || "";
+        case "post":
+          return this.extractTextFromPost(content);
+        case "image":
+        case "file":
+        case "audio":
+        case "video":
+        case "sticker":
+          return `[${message.msgType}]`;
+        case "interactive":
+          return "[interactive card]";
+        default:
+          return content.text || "";
+      }
+    } catch {
+      return "";
+    }
+  }
+  extractTextFromPost(content) {
+    const parts = [];
+    if (content.title) {
+      parts.push(content.title);
+    }
+    if (content.content && Array.isArray(content.content)) {
+      for (const line of content.content) {
+        if (Array.isArray(line)) {
+          const lineText = line.filter((elem) => elem.tag === "text" && elem.text).map((elem) => elem.text).join("");
+          if (lineText) {
+            parts.push(lineText);
+          }
+        }
+      }
+    }
+    return parts.join(`
+`);
+  }
+  isBotMentioned(message) {
+    if (!this.botOpenId || !message.mentions) {
+      return false;
+    }
+    return message.mentions.some((mention) => mention.id === this.botOpenId);
+  }
+  splitMessage(content) {
+    if (content.length <= MAX_MESSAGE_LENGTH) {
+      return [content];
+    }
+    const parts = [];
+    let current = "";
+    for (const line of content.split(`
+`)) {
+      const lineWithNewline = current ? `
+${line}` : line;
+      if (current.length + lineWithNewline.length > MAX_MESSAGE_LENGTH) {
+        if (current) {
+          parts.push(current);
+          current = "";
+        }
+        if (line.length > MAX_MESSAGE_LENGTH) {
+          const words = line.split(/\s+/);
+          for (const word of words) {
+            const wordWithSpace = current ? ` ${word}` : word;
+            if (current.length + wordWithSpace.length > MAX_MESSAGE_LENGTH) {
+              if (current) {
+                parts.push(current);
+                current = "";
+              }
+              if (word.length > MAX_MESSAGE_LENGTH) {
+                for (let i = 0;i < word.length; i += MAX_MESSAGE_LENGTH) {
+                  parts.push(word.slice(i, i + MAX_MESSAGE_LENGTH));
+                }
+              } else {
+                current = word;
+              }
+            } else {
+              current += wordWithSpace;
+            }
+          }
+        } else {
+          current = line;
+        }
+      } else {
+        current += lineWithNewline;
+      }
+    }
+    if (current) {
+      parts.push(current);
+    }
+    return parts;
+  }
+}
+
+// src/providers/chatState.ts
+var CHAT_STATE_PROVIDER = "FEISHU_CHAT_STATE";
+var chatStateProvider = {
+  name: CHAT_STATE_PROVIDER,
+  description: "Provides Feishu chat context and state information",
+  get: async (_runtime, message, state) => {
+    if (message.content?.source !== "feishu") {
+      return { text: "" };
+    }
+    const chatId = message.content?.chatId;
+    const messageId = message.content?.messageId;
+    if (!chatId) {
+      return { text: "" };
+    }
+    const stateInfo = [`Platform: Feishu/Lark`, `Chat ID: ${chatId}`];
+    if (messageId) {
+      stateInfo.push(`Message ID: ${messageId}`);
+    }
+    if (state?.values?.feishuChatType) {
+      stateInfo.push(`Chat Type: ${state.values.feishuChatType}`);
+    }
+    if (state?.values?.feishuChatName) {
+      stateInfo.push(`Chat Name: ${state.values.feishuChatName}`);
+    }
+    return { text: stateInfo.join(`
+`) };
+  }
+};
+// src/service.ts
+import {
+  ChannelType as ChannelType2,
+  createUniqueUuid as createUniqueUuid2,
+  EventType as EventType2,
+  logger as logger2,
+  Service
+} from "@elizaos/core";
+import * as lark from "@larksuiteoapi/node-sdk";
+class FeishuService extends Service {
+  static serviceType = FEISHU_SERVICE_NAME;
+  capabilityDescription = "The agent is able to send and receive messages on Feishu/Lark";
+  client = null;
+  wsClient = null;
+  messageManager = null;
+  feishuConfig = null;
+  botOpenId = null;
+  knownChats = new Map;
+  constructor(runtime) {
+    super(runtime);
+    if (!runtime) {
+      return;
+    }
+    const config = getFeishuConfig(runtime);
+    if (!config) {
+      logger2.warn("[Feishu] App ID or App Secret not provided - Feishu functionality will be unavailable");
+      return;
+    }
+    const validation = validateConfig(config);
+    if (!validation.valid) {
+      logger2.warn(`[Feishu] Invalid configuration: ${validation.error}`);
+      return;
+    }
+    this.feishuConfig = config;
+    this.client = new lark.Client({
+      appId: config.appId,
+      appSecret: config.appSecret,
+      domain: config.domain === "lark" ? lark.Domain.Lark : lark.Domain.Feishu,
+      loggerLevel: lark.LoggerLevel.warn
+    });
+    this.messageManager = new MessageManager(this.client, runtime, config);
+  }
+  static async start(runtime) {
+    const service = new FeishuService(runtime);
+    if (!service.client || !service.feishuConfig) {
+      logger2.warn("[Feishu] Service started without client - no credentials provided");
+      return service;
+    }
+    const maxRetries = 5;
+    let retryCount = 0;
+    let lastError = null;
+    while (retryCount < maxRetries) {
+      try {
+        logger2.info(`[Feishu] Starting service for character ${runtime.character.name}`);
+        await service.initializeBot();
+        await service.setupWebSocket();
+        logger2.success(`[Feishu] Service started successfully`);
+        return service;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        logger2.error(`[Feishu] Initialization attempt ${retryCount + 1} failed: ${lastError.message}`);
+        retryCount++;
+        if (retryCount < maxRetries) {
+          const delay = 2 ** retryCount * 1000;
+          logger2.info(`[Feishu] Retrying in ${delay / 1000} seconds...`);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    }
+    logger2.error(`[Feishu] Initialization failed after ${maxRetries} attempts. Last error: ${lastError?.message}`);
+    return service;
+  }
+  static async stop(runtime) {
+    const service = runtime.getService(FEISHU_SERVICE_NAME);
+    if (service) {
+      await service.stop();
+    }
+  }
+  async stop() {
+    logger2.info("[Feishu] Stopping service...");
+    if (this.wsClient) {
+      try {
+        const wsClientWithStop = this.wsClient;
+        if (typeof wsClientWithStop.stop === "function") {
+          await wsClientWithStop.stop();
+        }
+      } catch (error) {
+        logger2.error(`[Feishu] Error stopping WebSocket client: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      this.wsClient = null;
+    }
+    this.client = null;
+    logger2.info("[Feishu] Service stopped");
+  }
+  async initializeBot() {
+    if (!this.client) {
+      throw new Error("Client not initialized");
+    }
+    try {
+      const client = this.client;
+      if (client.bot?.botInfo?.get) {
+        const botInfo = await client.bot.botInfo.get({});
+        this.botOpenId = botInfo.data?.bot?.open_id || null;
+        if (this.botOpenId && this.messageManager) {
+          this.messageManager.setBotOpenId(this.botOpenId);
+        }
+        logger2.info(`[Feishu] Bot initialized: ${botInfo.data?.bot?.app_name || "Unknown"}`);
+      } else {
+        logger2.warn("[Feishu] Bot info API not available, some features may not work");
+      }
+    } catch (error) {
+      logger2.error(`[Feishu] Failed to get bot info: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+  }
+  async setupWebSocket() {
+    if (!this.client || !this.feishuConfig || !this.runtime) {
+      throw new Error("Client not initialized");
+    }
+    const eventDispatcher = new lark.EventDispatcher({}).register({
+      "im.message.receive_v1": async (data) => {
+        await this.handleMessageEvent(data);
+        return {};
+      },
+      "im.chat.member.bot.added_v1": async (data) => {
+        await this.handleBotAddedEvent(data);
+        return {};
+      },
+      "im.chat.member.bot.deleted_v1": async (data) => {
+        await this.handleBotRemovedEvent(data);
+        return {};
+      },
+      "im.chat.member.user.added_v1": async (data) => {
+        await this.handleUserAddedEvent(data);
+        return {};
+      },
+      "im.chat.member.user.deleted_v1": async (data) => {
+        await this.handleUserRemovedEvent(data);
+        return {};
+      }
+    });
+    this.wsClient = new lark.WSClient({
+      appId: this.feishuConfig.appId,
+      appSecret: this.feishuConfig.appSecret,
+      domain: this.feishuConfig.domain === "lark" ? lark.Domain.Lark : lark.Domain.Feishu,
+      loggerLevel: lark.LoggerLevel.warn
+    });
+    await this.wsClient.start({ eventDispatcher });
+    this.runtime.emitEvent("FEISHU_WORLD_CONNECTED" /* WORLD_CONNECTED */, {
+      runtime: this.runtime,
+      source: "feishu",
+      botOpenId: this.botOpenId
+    });
+  }
+  async handleMessageEvent(event) {
+    if (!this.messageManager)
+      return;
+    await this.messageManager.handleMessage(event);
+  }
+  async handleBotAddedEvent(event) {
+    if (!this.runtime)
+      return;
+    try {
+      const chatId = event.event?.chat_id;
+      if (!chatId)
+        return;
+      const chat = {
+        chatId,
+        chatType: "group" /* GROUP */,
+        name: event.event?.chat_name
+      };
+      this.knownChats.set(chatId, chat);
+      const worldId = createUniqueUuid2(this.runtime, chatId);
+      const roomId = createUniqueUuid2(this.runtime, chatId);
+      const world = {
+        id: worldId,
+        name: chat.name || `Feishu Chat ${chatId}`,
+        agentId: this.runtime.agentId,
+        messageServerId: worldId,
+        metadata: {
+          extra: {
+            chatType: chat.chatType
+          }
+        }
+      };
+      await this.runtime.ensureWorldExists(world);
+      const room = {
+        id: roomId,
+        name: chat.name || `Feishu Chat ${chatId}`,
+        source: "feishu",
+        type: ChannelType2.GROUP,
+        channelId: chatId,
+        messageServerId: worldId,
+        worldId
+      };
+      await this.runtime.ensureRoomExists(room);
+      const payload = {
+        runtime: this.runtime,
+        world,
+        rooms: [room],
+        entities: [],
+        source: "feishu",
+        chat,
+        botOpenId: this.botOpenId || undefined
+      };
+      this.runtime.emitEvent("FEISHU_WORLD_JOINED" /* WORLD_JOINED */, payload);
+      this.runtime.emitEvent(EventType2.WORLD_JOINED, {
+        runtime: this.runtime,
+        world,
+        rooms: [room],
+        entities: [],
+        source: "feishu"
+      });
+      logger2.info(`[Feishu] Bot added to chat: ${chat.name || chatId}`);
+    } catch (error) {
+      logger2.error(`[Feishu] Error handling bot added event: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async handleBotRemovedEvent(event) {
+    if (!this.runtime)
+      return;
+    try {
+      const chatId = event.event?.chat_id;
+      if (!chatId)
+        return;
+      const chat = this.knownChats.get(chatId) || {
+        chatId,
+        chatType: "group" /* GROUP */
+      };
+      this.knownChats.delete(chatId);
+      this.runtime.emitEvent("FEISHU_WORLD_LEFT" /* WORLD_LEFT */, {
+        runtime: this.runtime,
+        source: "feishu",
+        chat,
+        botOpenId: this.botOpenId
+      });
+      logger2.info(`[Feishu] Bot removed from chat: ${chatId}`);
+    } catch (error) {
+      logger2.error(`[Feishu] Error handling bot removed event: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async handleUserAddedEvent(event) {
+    if (!this.runtime)
+      return;
+    try {
+      const chatId = event.event?.chat_id;
+      const users = event.event?.users;
+      if (!chatId || !users)
+        return;
+      for (const user of users) {
+        const openId = user.user_id?.open_id;
+        if (!openId)
+          continue;
+        this.runtime.emitEvent("FEISHU_ENTITY_JOINED" /* ENTITY_JOINED */, {
+          runtime: this.runtime,
+          source: "feishu",
+          feishuUser: {
+            openId,
+            name: user.name
+          },
+          chat: this.knownChats.get(chatId) || {
+            chatId,
+            chatType: "group" /* GROUP */
+          }
+        });
+      }
+    } catch (error) {
+      logger2.error(`[Feishu] Error handling user added event: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async handleUserRemovedEvent(event) {
+    if (!this.runtime)
+      return;
+    try {
+      const chatId = event.event?.chat_id;
+      const users = event.event?.users;
+      if (!chatId || !users)
+        return;
+      for (const user of users) {
+        const openId = user.user_id?.open_id;
+        if (!openId)
+          continue;
+        this.runtime.emitEvent("FEISHU_ENTITY_LEFT" /* ENTITY_LEFT */, {
+          runtime: this.runtime,
+          source: "feishu",
+          feishuUser: {
+            openId,
+            name: user.name
+          },
+          chat: this.knownChats.get(chatId) || {
+            chatId,
+            chatType: "group" /* GROUP */
+          }
+        });
+      }
+    } catch (error) {
+      logger2.error(`[Feishu] Error handling user removed event: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  static registerSendHandlers(runtime, serviceInstance) {
+    if (serviceInstance?.client && serviceInstance?.messageManager) {
+      runtime.registerSendHandler("feishu", serviceInstance.handleSendMessage.bind(serviceInstance));
+      logger2.info("[Feishu] Registered send handler");
+    } else {
+      logger2.warn("[Feishu] Cannot register send handler - client not initialized");
+    }
+  }
+  async handleSendMessage(runtime, target, content) {
+    if (!this.messageManager) {
+      logger2.error("[Feishu] Message manager not initialized");
+      throw new Error("Feishu message manager is not initialized");
+    }
+    let chatId;
+    if (target.channelId) {
+      chatId = target.channelId;
+    } else if (target.roomId) {
+      const room = await runtime.getRoom(target.roomId);
+      chatId = room?.channelId;
+      if (!chatId) {
+        throw new Error(`Could not resolve Feishu chat ID from roomId ${target.roomId}`);
+      }
+    } else {
+      throw new Error("Feishu SendHandler requires channelId or roomId");
+    }
+    if (!chatId) {
+      throw new Error(`Could not determine target Feishu chat ID for target: ${JSON.stringify(target)}`);
+    }
+    const feishuContent = {
+      text: content.text || ""
+    };
+    const contentData = content.data;
+    if (contentData?.card) {
+      feishuContent.card = contentData.card;
+    }
+    if (contentData?.imageKey) {
+      feishuContent.imageKey = contentData.imageKey;
+    }
+    if (contentData?.fileKey) {
+      feishuContent.fileKey = contentData.fileKey;
+    }
+    await this.messageManager.sendMessage(chatId, feishuContent);
+    logger2.info(`[Feishu] Message sent to chat ID: ${chatId}`);
+  }
+}
+
+// src/accounts.ts
+var DEFAULT_ACCOUNT_ID = "default";
+function normalizeAccountId(accountId) {
+  if (!accountId || typeof accountId !== "string") {
+    return DEFAULT_ACCOUNT_ID;
+  }
+  const trimmed = accountId.trim().toLowerCase();
+  if (!trimmed || trimmed === "default") {
+    return DEFAULT_ACCOUNT_ID;
+  }
+  return trimmed;
+}
+function getMultiAccountConfig(runtime) {
+  const characterFeishu = runtime.character?.settings?.feishu;
+  return {
+    enabled: characterFeishu?.enabled,
+    appId: characterFeishu?.appId,
+    appSecret: characterFeishu?.appSecret,
+    appSecretFile: characterFeishu?.appSecretFile,
+    encryptKey: characterFeishu?.encryptKey,
+    verificationToken: characterFeishu?.verificationToken,
+    apiUrl: characterFeishu?.apiUrl,
+    dmPolicy: characterFeishu?.dmPolicy,
+    groupPolicy: characterFeishu?.groupPolicy,
+    mediaMaxMb: characterFeishu?.mediaMaxMb,
+    textChunkLimit: characterFeishu?.textChunkLimit,
+    webhookPath: characterFeishu?.webhookPath,
+    accounts: characterFeishu?.accounts,
+    groups: characterFeishu?.groups
+  };
+}
+function listFeishuAccountIds(runtime) {
+  const config = getMultiAccountConfig(runtime);
+  const accounts = config.accounts;
+  const ids = new Set;
+  const envAppId = runtime.getSetting("FEISHU_APP_ID");
+  const envAppSecret = runtime.getSetting("FEISHU_APP_SECRET");
+  const baseConfigured = Boolean(config.appId?.trim() && (config.appSecret?.trim() || config.appSecretFile));
+  const envConfigured = Boolean(envAppId?.trim() && envAppSecret?.trim());
+  if (baseConfigured || envConfigured) {
+    ids.add(DEFAULT_ACCOUNT_ID);
+  }
+  if (accounts && typeof accounts === "object") {
+    for (const id of Object.keys(accounts)) {
+      if (id) {
+        ids.add(normalizeAccountId(id));
+      }
+    }
+  }
+  const result = Array.from(ids);
+  if (result.length === 0) {
+    return [DEFAULT_ACCOUNT_ID];
+  }
+  return result.toSorted((a, b) => a.localeCompare(b));
+}
+function resolveDefaultFeishuAccountId(runtime) {
+  const ids = listFeishuAccountIds(runtime);
+  if (ids.includes(DEFAULT_ACCOUNT_ID)) {
+    return DEFAULT_ACCOUNT_ID;
+  }
+  return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+function getAccountConfig(runtime, accountId) {
+  const config = getMultiAccountConfig(runtime);
+  const accounts = config.accounts;
+  if (!accounts || typeof accounts !== "object") {
+    return;
+  }
+  const direct = accounts[accountId];
+  if (direct) {
+    return direct;
+  }
+  const normalized = normalizeAccountId(accountId);
+  const matchKey = Object.keys(accounts).find((key) => normalizeAccountId(key) === normalized);
+  return matchKey ? accounts[matchKey] : undefined;
+}
+function mergeFeishuAccountConfig(runtime, accountId) {
+  const multiConfig = getMultiAccountConfig(runtime);
+  const { accounts: _ignored, ...baseConfig } = multiConfig;
+  const accountConfig = getAccountConfig(runtime, accountId) ?? {};
+  const envAppId = runtime.getSetting("FEISHU_APP_ID");
+  const envAppSecret = runtime.getSetting("FEISHU_APP_SECRET");
+  const envEncryptKey = runtime.getSetting("FEISHU_ENCRYPT_KEY");
+  const envVerificationToken = runtime.getSetting("FEISHU_VERIFICATION_TOKEN");
+  const envDmPolicy = runtime.getSetting("FEISHU_DM_POLICY");
+  const envGroupPolicy = runtime.getSetting("FEISHU_GROUP_POLICY");
+  const envConfig = {
+    appId: envAppId || undefined,
+    appSecret: envAppSecret || undefined,
+    encryptKey: envEncryptKey || undefined,
+    verificationToken: envVerificationToken || undefined,
+    dmPolicy: envDmPolicy,
+    groupPolicy: envGroupPolicy
+  };
+  return {
+    ...envConfig,
+    ...baseConfig,
+    ...accountConfig
+  };
+}
+function resolveFeishuAccount(runtime, accountId) {
+  const normalizedAccountId = normalizeAccountId(accountId);
+  const multiConfig = getMultiAccountConfig(runtime);
+  const baseEnabled = multiConfig.enabled !== false;
+  const merged = mergeFeishuAccountConfig(runtime, normalizedAccountId);
+  const accountEnabled = merged.enabled !== false;
+  const enabled = baseEnabled && accountEnabled;
+  const appId = merged.appId?.trim() || "";
+  const appSecret = merged.appSecret?.trim() || "";
+  let tokenSource = "none";
+  if (merged.appSecret?.trim()) {
+    tokenSource = "config";
+  } else {
+    const envAppSecret = runtime.getSetting("FEISHU_APP_SECRET");
+    if (envAppSecret?.trim()) {
+      tokenSource = "env";
+    }
+  }
+  if (!appId || !appSecret) {
+    tokenSource = "none";
+  }
+  const configured = Boolean(appId && appSecret);
+  const name = merged.name?.trim() || merged.botName?.trim() || undefined;
+  return {
+    accountId: normalizedAccountId,
+    enabled,
+    name,
+    appId,
+    appSecret,
+    tokenSource,
+    configured,
+    config: merged
+  };
+}
+function listEnabledFeishuAccounts(runtime) {
+  return listFeishuAccountIds(runtime).map((accountId) => resolveFeishuAccount(runtime, accountId)).filter((account) => account.enabled && account.configured);
+}
+function isMultiAccountEnabled(runtime) {
+  const accounts = listEnabledFeishuAccounts(runtime);
+  return accounts.length > 1;
+}
+function resolveFeishuGroupConfig(runtime, accountId, groupId) {
+  const multiConfig = getMultiAccountConfig(runtime);
+  const accountConfig = getAccountConfig(runtime, accountId);
+  const accountGroup = accountConfig?.groups?.[groupId];
+  if (accountGroup) {
+    return accountGroup;
+  }
+  return multiConfig.groups?.[groupId];
+}
+function isFeishuUserAllowed(params) {
+  const { userId, accountConfig, isGroup, groupConfig } = params;
+  if (isGroup) {
+    const policy2 = accountConfig.groupPolicy ?? "allowlist";
+    if (policy2 === "disabled") {
+      return false;
+    }
+    if (policy2 === "open") {
+      return true;
+    }
+    if (groupConfig?.allowFrom?.length) {
+      return groupConfig.allowFrom.some((allowed) => String(allowed) === userId);
+    }
+    if (accountConfig.groupAllowFrom?.length) {
+      return accountConfig.groupAllowFrom.some((allowed) => String(allowed) === userId);
+    }
+    return policy2 !== "allowlist";
+  }
+  const policy = accountConfig.dmPolicy ?? "pairing";
+  if (policy === "disabled") {
+    return false;
+  }
+  if (policy === "open") {
+    return true;
+  }
+  if (policy === "pairing") {
+    return true;
+  }
+  if (accountConfig.allowFrom?.length) {
+    return accountConfig.allowFrom.some((allowed) => String(allowed) === userId);
+  }
+  return false;
+}
+function isFeishuMentionRequired(params) {
+  const { groupConfig } = params;
+  return groupConfig?.requireMention ?? false;
+}
+// src/formatting.ts
+var FEISHU_TEXT_CHUNK_LIMIT = 4000;
+function parseMarkdownToIR(markdown) {
+  const styles = [];
+  const links = [];
+  let text = markdown;
+  const linkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
+  const linkReplacements = [];
+  let linkMatch = linkRegex.exec(markdown);
+  while (linkMatch !== null) {
+    linkReplacements.push({
+      start: linkMatch.index,
+      end: linkMatch.index + linkMatch[0].length,
+      text: linkMatch[1],
+      href: linkMatch[2]
+    });
+    linkMatch = linkRegex.exec(markdown);
+  }
+  let offset = 0;
+  for (const repl of linkReplacements) {
+    const before = text.slice(0, repl.start + offset);
+    const after = text.slice(repl.end + offset);
+    text = before + repl.text + after;
+    links.push({
+      start: repl.start + offset,
+      end: repl.start + offset + repl.text.length,
+      href: repl.href,
+      text: repl.text
+    });
+    offset += repl.text.length - (repl.end - repl.start);
+  }
+  text = processStyle(text, /\*\*([^*]+)\*\*/g, "bold", styles);
+  text = processStyle(text, /__([^_]+)__/g, "bold", styles);
+  text = processStyle(text, /(?<!\*)\*(?!\*)([^*]+)(?<!\*)\*(?!\*)/g, "italic", styles);
+  text = processStyle(text, /(?<!_)_(?!_)([^_]+)(?<!_)_(?!_)/g, "italic", styles);
+  text = processStyle(text, /~~([^~]+)~~/g, "strikethrough", styles);
+  text = processStyle(text, /`([^`]+)`/g, "code", styles);
+  text = text.replace(/```(\w*)\n?([\s\S]*?)```/g, (_, _lang, code) => {
+    const start = text.indexOf(_);
+    const trimmedCode = code.trim();
+    styles.push({
+      start,
+      end: start + trimmedCode.length,
+      style: "code"
+    });
+    return trimmedCode;
+  });
+  text = text.replace(/^#{1,6}\s+/gm, "");
+  text = text.replace(/^>\s?/gm, "｜ ");
+  text = text.replace(/\n{3,}/g, `
+
+`).trim();
+  return { text, styles, links };
+}
+function processStyle(text, pattern, style, styles) {
+  let result = text;
+  const matches = [];
+  let match = pattern.exec(text);
+  while (match !== null) {
+    matches.push({
+      index: match.index,
+      fullLength: match[0].length,
+      content: match[1]
+    });
+    match = pattern.exec(text);
+  }
+  let offset = 0;
+  for (const m of matches) {
+    const before = result.slice(0, m.index + offset);
+    const after = result.slice(m.index + offset + m.fullLength);
+    result = before + m.content + after;
+    styles.push({
+      start: m.index + offset,
+      end: m.index + offset + m.content.length,
+      style
+    });
+    offset += m.content.length - m.fullLength;
+  }
+  return result;
+}
+function buildStyleRanges(styles, textLength) {
+  const ranges = Array(textLength).fill(null).map(() => ({
+    bold: false,
+    italic: false,
+    strikethrough: false,
+    code: false
+  }));
+  for (const span of styles) {
+    for (let i = span.start;i < span.end && i < textLength; i++) {
+      switch (span.style) {
+        case "bold":
+          ranges[i].bold = true;
+          break;
+        case "italic":
+          ranges[i].italic = true;
+          break;
+        case "strikethrough":
+          ranges[i].strikethrough = true;
+          break;
+        case "code":
+          ranges[i].code = true;
+          break;
+      }
+    }
+  }
+  return ranges;
+}
+function buildLinkMap(links) {
+  const map = new Map;
+  for (const link of links) {
+    for (let i = link.start;i < link.end; i++) {
+      map.set(i, link.href);
+    }
+  }
+  return map;
+}
+function getStylesAt(ranges, pos) {
+  return ranges[pos] ?? {
+    bold: false,
+    italic: false,
+    strikethrough: false,
+    code: false
+  };
+}
+function getLinkAt(linkMap, pos) {
+  return linkMap.get(pos);
+}
+function stylesEqual(a, b) {
+  return a.bold === b.bold && a.italic === b.italic && a.strikethrough === b.strikethrough && a.code === b.code;
+}
+function createPostElement(text, styles, link) {
+  const styleArray = [];
+  if (styles.bold) {
+    styleArray.push("bold");
+  }
+  if (styles.italic) {
+    styleArray.push("italic");
+  }
+  if (styles.strikethrough) {
+    styleArray.push("lineThrough");
+  }
+  if (styles.code) {
+    styleArray.push("code");
+  }
+  if (link) {
+    return {
+      tag: "a",
+      text,
+      href: link,
+      ...styleArray.length > 0 ? { style: styleArray } : {}
+    };
+  }
+  return {
+    tag: "text",
+    text,
+    ...styleArray.length > 0 ? { style: styleArray } : {}
+  };
+}
+function renderFeishuPost(ir) {
+  const lines = [];
+  const text = ir.text;
+  if (!text) {
+    return { zh_cn: { content: [[{ tag: "text", text: "" }]] } };
+  }
+  const styleRanges = buildStyleRanges(ir.styles, text.length);
+  const linkMap = buildLinkMap(ir.links);
+  const textLines = text.split(`
+`);
+  let charIndex = 0;
+  for (const line of textLines) {
+    const lineElements = [];
+    if (line.length === 0) {
+      lineElements.push({ tag: "text", text: "" });
+    } else {
+      let segmentStart = charIndex;
+      let currentStyles = getStylesAt(styleRanges, segmentStart);
+      let currentLink = getLinkAt(linkMap, segmentStart);
+      for (let i = 0;i < line.length; i++) {
+        const pos = charIndex + i;
+        const newStyles = getStylesAt(styleRanges, pos);
+        const newLink = getLinkAt(linkMap, pos);
+        const stylesChanged = !stylesEqual(currentStyles, newStyles);
+        const linkChanged = currentLink !== newLink;
+        if (stylesChanged || linkChanged) {
+          const segmentText = text.slice(segmentStart, pos);
+          if (segmentText) {
+            lineElements.push(createPostElement(segmentText, currentStyles, currentLink));
+          }
+          segmentStart = pos;
+          currentStyles = newStyles;
+          currentLink = newLink;
+        }
+      }
+      const finalText = text.slice(segmentStart, charIndex + line.length);
+      if (finalText) {
+        lineElements.push(createPostElement(finalText, currentStyles, currentLink));
+      }
+    }
+    lines.push(lineElements.length > 0 ? lineElements : [{ tag: "text", text: "" }]);
+    charIndex += line.length + 1;
+  }
+  return {
+    zh_cn: {
+      content: lines
+    }
+  };
+}
+function markdownToFeishuPost(markdown) {
+  const ir = parseMarkdownToIR(markdown ?? "");
+  return renderFeishuPost(ir);
+}
+function splitAtBreakPoint(text, limit) {
+  if (text.length <= limit) {
+    return { chunk: text, remainder: "" };
+  }
+  const searchArea = text.slice(0, limit);
+  const doubleNewline = searchArea.lastIndexOf(`
+
+`);
+  if (doubleNewline > limit * 0.5) {
+    return {
+      chunk: text.slice(0, doubleNewline).trimEnd(),
+      remainder: text.slice(doubleNewline + 2).trimStart()
+    };
+  }
+  const singleNewline = searchArea.lastIndexOf(`
+`);
+  if (singleNewline > limit * 0.5) {
+    return {
+      chunk: text.slice(0, singleNewline).trimEnd(),
+      remainder: text.slice(singleNewline + 1).trimStart()
+    };
+  }
+  const sentenceEnd = Math.max(searchArea.lastIndexOf(". "), searchArea.lastIndexOf("! "), searchArea.lastIndexOf("? "));
+  if (sentenceEnd > limit * 0.5) {
+    return {
+      chunk: text.slice(0, sentenceEnd + 1).trimEnd(),
+      remainder: text.slice(sentenceEnd + 2).trimStart()
+    };
+  }
+  const space = searchArea.lastIndexOf(" ");
+  if (space > limit * 0.5) {
+    return {
+      chunk: text.slice(0, space).trimEnd(),
+      remainder: text.slice(space + 1).trimStart()
+    };
+  }
+  return {
+    chunk: text.slice(0, limit),
+    remainder: text.slice(limit)
+  };
+}
+function chunkFeishuText(text, opts = {}) {
+  const limit = opts.limit ?? FEISHU_TEXT_CHUNK_LIMIT;
+  if (!text?.trim()) {
+    return [];
+  }
+  const normalizedText = text.trim();
+  if (normalizedText.length <= limit) {
+    return [normalizedText];
+  }
+  const chunks = [];
+  let remaining = normalizedText;
+  while (remaining.length > 0) {
+    const { chunk, remainder } = splitAtBreakPoint(remaining, limit);
+    if (chunk) {
+      chunks.push(chunk);
+    }
+    remaining = remainder;
+  }
+  return chunks.filter((c) => c.length > 0);
+}
+function markdownToFeishuChunks(markdown, limit = FEISHU_TEXT_CHUNK_LIMIT) {
+  const textChunks = chunkFeishuText(markdown, { limit });
+  return textChunks.map((chunk) => ({
+    post: markdownToFeishuPost(chunk),
+    text: chunk
+  }));
+}
+function containsMarkdown(text) {
+  if (!text) {
+    return false;
+  }
+  const markdownPatterns = [
+    /\*\*[^*]+\*\*/,
+    /\*[^*]+\*/,
+    /~~[^~]+~~/,
+    /`[^`]+`/,
+    /```[\s\S]*```/,
+    /\[.+\]\(.+\)/,
+    /^#{1,6}\s/m,
+    /^[-*]\s/m,
+    /^\d+\.\s/m
+  ];
+  return markdownPatterns.some((pattern) => pattern.test(text));
+}
+function stripMarkdown(text) {
+  let result = text;
+  result = result.replace(/\*\*(.+?)\*\*/g, "$1");
+  result = result.replace(/__(.+?)__/g, "$1");
+  result = result.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, "$1");
+  result = result.replace(/(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/g, "$1");
+  result = result.replace(/~~(.+?)~~/g, "$1");
+  result = result.replace(/^#{1,6}\s+(.+)$/gm, "$1");
+  result = result.replace(/^>\s?(.*)$/gm, "$1");
+  result = result.replace(/```(\w*)\n?([\s\S]*?)```/g, "$2");
+  result = result.replace(/`([^`]+)`/g, "$1");
+  result = result.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+  result = result.replace(/\n{3,}/g, `
+
+`);
+  result = result.trim();
+  return result;
+}
+function formatFeishuUserMention(userId) {
+  return `<at user_id="${userId}"></at>`;
+}
+function formatFeishuAtAll() {
+  return '<at user_id="all"></at>';
+}
+function truncateText(text, maxLength) {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  if (maxLength <= 3) {
+    return "...".slice(0, maxLength);
+  }
+  return `${text.slice(0, maxLength - 3)}...`;
+}
+function resolveFeishuSystemLocation(params) {
+  const { chatType, chatId, chatName } = params;
+  const name = chatName || chatId.slice(0, 8);
+  return `Feishu ${chatType}:${name}`;
+}
+function isGroupChat(chatType) {
+  return chatType === "group";
+}
+
+// src/index.ts
+var feishuPlugin = {
+  name: FEISHU_SERVICE_NAME,
+  description: "Feishu/Lark client plugin for elizaOS",
+  services: [FeishuService],
+  actions: [sendMessageAction],
+  providers: [chatStateProvider],
+  tests: []
+};
+var src_default = feishuPlugin;
+export {
+  validateConfig,
+  truncateText,
+  stripMarkdown,
+  sendMessageAction,
+  resolveFeishuSystemLocation,
+  resolveFeishuGroupConfig,
+  resolveFeishuAccount,
+  resolveDefaultFeishuAccountId,
+  normalizeAccountId,
+  markdownToFeishuPost,
+  markdownToFeishuChunks,
+  listFeishuAccountIds,
+  listEnabledFeishuAccounts,
+  isMultiAccountEnabled,
+  isGroupChat,
+  isFeishuUserAllowed,
+  isFeishuMentionRequired,
+  isChatAllowed,
+  getFeishuConfig,
+  formatFeishuUserMention,
+  formatFeishuAtAll,
+  src_default as default,
+  containsMarkdown,
+  chunkFeishuText,
+  chatStateProvider,
+  SEND_MESSAGE_ACTION,
+  MessageManager,
+  MAX_MESSAGE_LENGTH,
+  FeishuService,
+  FeishuEventTypes,
+  FeishuChatType,
+  FEISHU_TEXT_CHUNK_LIMIT,
+  FEISHU_SERVICE_NAME,
+  FEISHU_DOMAINS,
+  DEFAULT_TIMEOUT_MS,
+  DEFAULT_ACCOUNT_ID,
+  CHAT_STATE_PROVIDER
+};
+
+//# debugId=B56498A90F39E45564756E2164756E21
+//# sourceMappingURL=index.js.map