@elizaos/plugin-feishu 2.0.0-alpha.6 → 2.0.0-beta.1

package/dist/index.js

@@ -1,3 +1,257 @@
+// src/index.ts
+import { getConnectorAccountManager, logger as logger3 } from "@elizaos/core";
+
+// 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/connector-account-provider.ts
+var FEISHU_PROVIDER_ID = "feishu";
+function purposeForAccount(_account) {
+  return ["messaging"];
+}
+function accessGateForAccount(account) {
+  const dmPolicy = account.config?.dmPolicy;
+  if (dmPolicy === "pairing")
+    return "pairing";
+  if (dmPolicy === "disabled")
+    return "disabled";
+  return "open";
+}
+function toConnectorAccount(account) {
+  const now = Date.now();
+  return {
+    id: normalizeAccountId(account.accountId),
+    provider: FEISHU_PROVIDER_ID,
+    label: account.name ?? account.accountId,
+    role: "AGENT",
+    purpose: purposeForAccount(account),
+    accessGate: accessGateForAccount(account),
+    status: account.enabled && account.configured ? "connected" : "disabled",
+    externalId: account.appId || undefined,
+    createdAt: now,
+    updatedAt: now,
+    metadata: {
+      tokenSource: account.tokenSource,
+      dmPolicy: account.config?.dmPolicy ?? "open",
+      groupPolicy: account.config?.groupPolicy ?? "allowlist",
+      appId: account.appId || ""
+    }
+  };
+}
+function createFeishuConnectorAccountProvider(runtime) {
+  return {
+    provider: FEISHU_PROVIDER_ID,
+    label: "Feishu",
+    listAccounts: async (_manager) => {
+      const enabled = listEnabledFeishuAccounts(runtime);
+      if (enabled.length > 0) {
+        return enabled.map(toConnectorAccount);
+      }
+      const fallback = resolveFeishuAccount(runtime, DEFAULT_ACCOUNT_ID);
+      return [toConnectorAccount(fallback)];
+    },
+    createAccount: async (input, _manager) => {
+      return {
+        ...input,
+        provider: FEISHU_PROVIDER_ID,
+        role: input.role ?? "AGENT",
+        purpose: input.purpose ?? ["messaging"],
+        accessGate: input.accessGate ?? "open",
+        status: input.status ?? "pending"
+      };
+    },
+    patchAccount: async (_accountId, patch, _manager) => {
+      return { ...patch, provider: FEISHU_PROVIDER_ID };
+    },
+    deleteAccount: async (_accountId, _manager) => {}
+  };
+}
+
 // src/constants.ts
 var FEISHU_SERVICE_NAME = "feishu";
 var FEISHU_DOMAINS = {
@@ -7,79 +261,6 @@ var FEISHU_DOMAINS = {
 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) => {
-    return message.content?.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,
@@ -438,35 +619,6 @@ ${line}` : line;
   }
 }
 
-// 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",
-  dynamic: true,
-  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,
@@ -476,6 +628,70 @@ import {
   Service
 } from "@elizaos/core";
 import * as lark from "@larksuiteoapi/node-sdk";
+function normalizeFeishuQuery(query) {
+  return query.trim().toLowerCase();
+}
+function scoreFeishuCandidate(values, query) {
+  const normalized = normalizeFeishuQuery(query);
+  if (!normalized) {
+    return 0.45;
+  }
+  const candidates = values.filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => value.trim().toLowerCase());
+  if (candidates.some((candidate) => candidate === normalized)) {
+    return 1;
+  }
+  return candidates.some((candidate) => candidate.includes(normalized)) ? 0.8 : 0;
+}
+function feishuChatToConnectorTarget(chat, score = 0.55, roomId) {
+  return {
+    target: {
+      source: FEISHU_SERVICE_NAME,
+      channelId: chat.chatId,
+      roomId
+    },
+    label: chat.name || chat.chatId,
+    kind: chat.chatType === "p2p" /* P2P */ ? "user" : "group",
+    description: chat.description || "Feishu/Lark chat",
+    score,
+    contexts: ["social", "connectors"],
+    metadata: {
+      chatType: chat.chatType,
+      ownerOpenId: chat.ownerOpenId,
+      tenantKey: chat.tenantKey
+    }
+  };
+}
+function normalizeConnectorLimit(limit, fallback = 50) {
+  if (!Number.isFinite(limit) || !limit || limit <= 0) {
+    return fallback;
+  }
+  return Math.min(Math.floor(limit), 200);
+}
+async function readStoredMessageMemories(runtime, roomId, limit) {
+  return runtime.getMemories({
+    tableName: "messages",
+    roomId,
+    limit,
+    orderBy: "createdAt",
+    orderDirection: "desc"
+  });
+}
+async function readStoredMessagesForTargets(runtime, targets, limit) {
+  const roomIds = Array.from(new Set(targets.map((target) => target.target.roomId).filter((id) => Boolean(id))));
+  const chunks = await Promise.all(roomIds.map((roomId) => readStoredMessageMemories(runtime, roomId, limit)));
+  return chunks.flat().sort((left, right) => (right.createdAt ?? 0) - (left.createdAt ?? 0)).slice(0, limit);
+}
+function filterMemoriesByQuery(memories, query, limit) {
+  const normalized = query.trim().toLowerCase();
+  if (!normalized) {
+    return memories.slice(0, limit);
+  }
+  return memories.filter((memory) => {
+    const text = typeof memory.content?.text === "string" ? memory.content.text : "";
+    return text.toLowerCase().includes(normalized);
+  }).slice(0, limit);
+}
+
 class FeishuService extends Service {
   static serviceType = FEISHU_SERVICE_NAME;
   capabilityDescription = "The agent is able to send and receive messages on Feishu/Lark";
@@ -768,8 +984,103 @@ class FeishuService extends Service {
   }
   static registerSendHandlers(runtime, serviceInstance) {
     if (serviceInstance?.client && serviceInstance?.messageManager) {
-      runtime.registerSendHandler("feishu", serviceInstance.handleSendMessage.bind(serviceInstance));
-      logger2.info("[Feishu] Registered send handler");
+      const sendHandler = async (handlerRuntime, target, content) => {
+        await serviceInstance.handleSendMessage(handlerRuntime, target, content);
+        return;
+      };
+      if (typeof runtime.registerMessageConnector === "function") {
+        const registration = {
+          source: FEISHU_SERVICE_NAME,
+          label: "Feishu/Lark",
+          capabilities: [
+            "send_message",
+            "send_card",
+            "send_image",
+            "send_file"
+          ],
+          supportedTargetKinds: ["group", "room", "user", "channel"],
+          contexts: ["social", "connectors"],
+          description: "Send Feishu/Lark text, card, image, and file messages to known chats.",
+          sendHandler,
+          resolveTargets: async (query, context) => {
+            const chats = await serviceInstance.listConnectorChats(context.runtime);
+            return chats.map(({ chat, roomId }) => ({
+              chat,
+              roomId,
+              score: scoreFeishuCandidate([chat.chatId, chat.name, chat.description, chat.ownerOpenId], query)
+            })).filter(({ score }) => score > 0).sort((left, right) => right.score - left.score).slice(0, 10).map(({ chat, score, roomId }) => feishuChatToConnectorTarget(chat, score, roomId));
+          },
+          listRecentTargets: async (context) => (await serviceInstance.listConnectorChats(context.runtime)).slice(0, 10).map(({ chat, roomId }) => feishuChatToConnectorTarget(chat, 0.55, roomId)),
+          listRooms: async (context) => (await serviceInstance.listConnectorChats(context.runtime)).map(({ chat, roomId }) => feishuChatToConnectorTarget(chat, 0.55, roomId)),
+          fetchMessages: async (context, params) => {
+            const limit = normalizeConnectorLimit(params?.limit);
+            const target = params?.target ?? context.target;
+            if (target?.roomId) {
+              return readStoredMessageMemories(context.runtime, target.roomId, limit);
+            }
+            const targets = (await serviceInstance.listConnectorChats(context.runtime)).slice(0, 10).map(({ chat, roomId }) => feishuChatToConnectorTarget(chat, 0.55, roomId));
+            return readStoredMessagesForTargets(context.runtime, targets, limit);
+          },
+          searchMessages: async (context, params) => {
+            const limit = normalizeConnectorLimit(params?.limit);
+            const target = params?.target ?? context.target;
+            const messages = target?.roomId ? await readStoredMessageMemories(context.runtime, target.roomId, Math.max(limit, 100)) : await readStoredMessagesForTargets(context.runtime, (await serviceInstance.listConnectorChats(context.runtime)).slice(0, 10).map(({ chat, roomId }) => feishuChatToConnectorTarget(chat, 0.55, roomId)), Math.max(limit, 100));
+            return filterMemoriesByQuery(messages, params.query, limit);
+          },
+          getChatContext: async (target, context) => {
+            const room = target.roomId ? await context.runtime.getRoom(target.roomId) : null;
+            const chatId = String(target.channelId ?? room?.channelId ?? "").trim();
+            if (!chatId) {
+              return null;
+            }
+            const chat = serviceInstance.knownChats.get(chatId) || {
+              chatId,
+              chatType: room?.type === ChannelType2.DM ? "p2p" /* P2P */ : "group" /* GROUP */,
+              name: room?.name
+            };
+            return {
+              target: {
+                source: FEISHU_SERVICE_NAME,
+                roomId: target.roomId,
+                channelId: chatId
+              },
+              label: chat.name || chat.chatId,
+              summary: chat.chatType === "p2p" /* P2P */ ? "Feishu/Lark direct chat" : "Feishu/Lark group chat",
+              metadata: {
+                chatType: chat.chatType,
+                ownerOpenId: chat.ownerOpenId,
+                tenantKey: chat.tenantKey
+              }
+            };
+          },
+          getUserContext: async (entityId, context) => {
+            const entity = typeof context.runtime.getEntityById === "function" ? await context.runtime.getEntityById(String(entityId)) : null;
+            if (!entity) {
+              return null;
+            }
+            return {
+              entityId,
+              label: entity.names?.[0],
+              aliases: entity.names,
+              handles: {},
+              metadata: entity.metadata
+            };
+          },
+          getUser: async (handlerRuntime, params) => {
+            const lookupParams = params;
+            const entityId = String(lookupParams.entityId ?? params.userId ?? params.username ?? params.handle ?? params.target?.entityId ?? "").trim();
+            if (!entityId || typeof handlerRuntime.getEntityById !== "function") {
+              return null;
+            }
+            const entity = await handlerRuntime.getEntityById(entityId).catch(() => null);
+            return entity;
+          }
+        };
+        runtime.registerMessageConnector(registration);
+      } else {
+        runtime.registerSendHandler(FEISHU_SERVICE_NAME, sendHandler);
+      }
+      logger2.info("[Feishu] Registered message connector");
     } else {
       logger2.warn("[Feishu] Cannot register send handler - client not initialized");
     }
@@ -798,206 +1109,87 @@ class FeishuService extends Service {
       text: content.text || ""
     };
     const contentData = content.data;
-    if (contentData?.card) {
-      feishuContent.card = contentData.card;
+    const feishuData = contentData?.feishu && typeof contentData.feishu === "object" ? contentData.feishu : contentData;
+    if (feishuData?.card) {
+      feishuContent.card = feishuData.card;
     }
-    if (contentData?.imageKey) {
-      feishuContent.imageKey = contentData.imageKey;
+    if (feishuData?.imageKey) {
+      feishuContent.imageKey = feishuData.imageKey;
     }
-    if (contentData?.fileKey) {
-      feishuContent.fileKey = contentData.fileKey;
+    if (feishuData?.fileKey) {
+      feishuContent.fileKey = feishuData.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";
+  async sendRoomMessage(target, content) {
+    await this.handleSendMessage(this.runtime, { source: FEISHU_SERVICE_NAME, channelId: target }, content);
   }
-  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;
+  async sendDirectMessage(target, content) {
+    await this.sendRoomMessage(target, content);
   }
-  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;
+  async listConnectorChats(runtime) {
+    const chats = new Map;
+    for (const chat of this.knownChats.values()) {
+      chats.set(chat.chatId, { chat });
     }
-    if (policy2 === "open") {
-      return true;
+    if (typeof runtime.getRoomsForParticipant !== "function") {
+      return Array.from(chats.values());
     }
-    if (groupConfig?.allowFrom?.length) {
-      return groupConfig.allowFrom.some((allowed) => String(allowed) === userId);
-    }
-    if (accountConfig.groupAllowFrom?.length) {
-      return accountConfig.groupAllowFrom.some((allowed) => String(allowed) === userId);
+    const roomIds = await runtime.getRoomsForParticipant(runtime.agentId).catch(() => []);
+    for (const roomId of roomIds) {
+      const room = await runtime.getRoom(roomId).catch(() => null);
+      if (room?.source !== FEISHU_SERVICE_NAME || !room.channelId) {
+        continue;
+      }
+      const known = chats.get(room.channelId)?.chat;
+      chats.set(room.channelId, {
+        chat: known || {
+          chatId: room.channelId,
+          chatType: room.type === ChannelType2.DM ? "p2p" /* P2P */ : "group" /* GROUP */,
+          name: room.name
+        },
+        roomId
+      });
     }
-    return policy2 !== "allowlist";
+    return Array.from(chats.values());
   }
-  const policy = accountConfig.dmPolicy ?? "pairing";
-  if (policy === "disabled") {
-    return false;
-  }
-  if (policy === "open") {
-    return true;
-  }
-  if (policy === "pairing") {
-    return true;
+}
+
+// src/workflow-credential-provider.ts
+import { Service as Service2 } from "@elizaos/core";
+var WORKFLOW_CREDENTIAL_PROVIDER_TYPE = "workflow_credential_provider";
+var SUPPORTED = ["httpHeaderAuth"];
+
+class FeishuWorkflowCredentialProvider extends Service2 {
+  static serviceType = WORKFLOW_CREDENTIAL_PROVIDER_TYPE;
+  capabilityDescription = "Supplies Feishu/Lark credentials to the workflow plugin.";
+  static async start(runtime) {
+    return new FeishuWorkflowCredentialProvider(runtime);
+  }
+  async stop() {}
+  async resolve(_userId, credType) {
+    if (credType !== "httpHeaderAuth")
+      return null;
+    const appId = this.runtime.getSetting("FEISHU_APP_ID");
+    const appSecret = this.runtime.getSetting("FEISHU_APP_SECRET");
+    if (!appId?.trim() || !appSecret?.trim())
+      return null;
+    return {
+      status: "credential_data",
+      data: {
+        name: "X-Feishu-App-Id",
+        value: appId.trim(),
+        appSecret: appSecret.trim()
+      }
+    };
   }
-  if (accountConfig.allowFrom?.length) {
-    return accountConfig.allowFrom.some((allowed) => String(allowed) === userId);
+  checkCredentialTypes(credTypes) {
+    return {
+      supported: credTypes.filter((t) => SUPPORTED.includes(t)),
+      unsupported: credTypes.filter((t) => !SUPPORTED.includes(t))
+    };
   }
-  return false;
-}
-function isFeishuMentionRequired(params) {
-  const { groupConfig } = params;
-  return groupConfig?.requireMention ?? false;
 }
 // src/formatting.ts
 var FEISHU_TEXT_CHUNK_LIMIT = 4000;
@@ -1341,17 +1533,30 @@ function isGroupChat(chatType) {
 var feishuPlugin = {
   name: FEISHU_SERVICE_NAME,
   description: "Feishu/Lark client plugin for elizaOS",
-  services: [FeishuService],
-  actions: [sendMessageAction],
-  providers: [chatStateProvider],
-  tests: []
+  services: [FeishuService, FeishuWorkflowCredentialProvider],
+  actions: [],
+  providers: [],
+  tests: [],
+  autoEnable: {
+    connectorKeys: ["feishu"]
+  },
+  init: async (_config, runtime) => {
+    try {
+      const manager = getConnectorAccountManager(runtime);
+      manager.registerProvider(createFeishuConnectorAccountProvider(runtime));
+    } catch (err) {
+      logger3.warn({
+        src: "plugin:feishu",
+        err: err instanceof Error ? err.message : String(err)
+      }, "Failed to register Feishu provider with ConnectorAccountManager");
+    }
+  }
 };
 var src_default = feishuPlugin;
 export {
   validateConfig,
   truncateText,
   stripMarkdown,
-  sendMessageAction,
   resolveFeishuSystemLocation,
   resolveFeishuGroupConfig,
   resolveFeishuAccount,
@@ -1372,8 +1577,6 @@ export {
   src_default as default,
   containsMarkdown,
   chunkFeishuText,
-  chatStateProvider,
-  SEND_MESSAGE_ACTION,
   MessageManager,
   MAX_MESSAGE_LENGTH,
   FeishuService,
@@ -1383,9 +1586,8 @@ export {
   FEISHU_SERVICE_NAME,
   FEISHU_DOMAINS,
   DEFAULT_TIMEOUT_MS,
-  DEFAULT_ACCOUNT_ID,
-  CHAT_STATE_PROVIDER
+  DEFAULT_ACCOUNT_ID
 };
 
-//# debugId=C18D17014C86A75D64756E2164756E21
+//# debugId=A7228C401E12666064756E2164756E21
 //# sourceMappingURL=index.js.map