@openclaw/feishu 2026.9.3 → 2026.9.5

package/dist/{chat-BZSnEtgb.js → .setup/chat-dWJYS63b.mjs}

@@ -1,5 +1,5 @@
-import { G as feishuExternalToolResult, X as resolveFeishuToolAccount, Y as resolveAnyEnabledFeishuToolsConfig, kt as resolveFeishuChatType, mt as authorizeFeishuChatMemberRead, pt as assertFeishuChatReadAllowed, tt as formatFeishuApiError, yt as resolveFeishuChatReadPreliminaryAuthorization } from "./reply-delivery-result-BXEmtKpf.js";
-import { r as createFeishuClient } from "./client-DMbIL3UH.js";
+import { At as resolveFeishuChatType, K as feishuExternalToolResult, X as resolveAnyEnabledFeishuToolsConfig, Z as resolveFeishuToolAccount, bt as resolveFeishuChatReadPreliminaryAuthorization, ht as authorizeFeishuChatMemberRead, mt as assertFeishuChatReadAllowed, nt as formatFeishuApiError } from "./reply-delivery-result-DFjxGLgX.mjs";
+import { r as createFeishuClient } from "./client-DCwNVFZg.mjs";
 import { optionalPositiveIntegerSchema } from "openclaw/plugin-sdk/channel-actions";
 import { readPositiveIntegerParam } from "openclaw/plugin-sdk/param-readers";
 import { Type } from "typebox";
@@ -189,96 +189,97 @@ async function getFeishuMemberInfo(client, memberId, memberIdType = "open_id") {
 	};
 }
 function registerFeishuChatTools(api) {
-	if (!api.config) return;
-	const cfg = api.config;
-	if (!resolveAnyEnabledFeishuToolsConfig(cfg).chat) return;
-	api.registerTool((toolContext) => ({
-		name: "feishu_chat",
-		resultContentSource: "network",
-		label: "Feishu Chat",
-		description: "Feishu chat operations. Actions: members, info, member_info",
-		parameters: FeishuChatSchema,
-		async execute(_toolCallId, params) {
-			const rawParams = params;
-			const p = params;
-			try {
-				const account = resolveFeishuToolAccount({
-					api,
-					defaultAccountId: toolContext.agentAccountId,
-					requiredTool: {
-						family: "chat",
-						label: "chat"
-					}
-				});
-				const client = createFeishuClient(account);
-				switch (p.action) {
-					case "members":
-						if (!p.chat_id) return feishuExternalToolResult({ error: "chat_id is required for action members" });
-						{
-							const chat = await getAuthorizedFeishuChatInfo({
-								client,
-								cfg,
-								account,
-								chatId: p.chat_id,
-								ctx: toolContext
-							});
-							const authorization = authorizeFeishuChatMemberRead({
-								cfg,
-								account,
-								chatId: p.chat_id,
-								chatType: resolveFeishuChatType(chat),
-								ctx: toolContext,
-								memberIdType: p.member_id_type
-							});
-							if (authorization.kind === "direct") return feishuExternalToolResult(buildFeishuDirectChatMembers(authorization));
-						}
-						return feishuExternalToolResult(await getChatMembers(client, p.chat_id, readChatPageSize(rawParams), p.page_token, p.member_id_type));
-					case "info":
-						if (!p.chat_id) return feishuExternalToolResult({ error: "chat_id is required for action info" });
-						{
-							const chat = await getAuthorizedFeishuChatInfo({
-								client,
-								cfg,
-								account,
-								chatId: p.chat_id,
-								ctx: toolContext
-							});
-							return feishuExternalToolResult(chat);
+	api.registerTool((toolContext) => {
+		const cfg = toolContext.runtimeConfig ?? toolContext.config ?? api.config;
+		if (!cfg || !resolveAnyEnabledFeishuToolsConfig(cfg).chat) return null;
+		return {
+			name: "feishu_chat",
+			resultContentSource: "network",
+			label: "Feishu Chat",
+			description: "Feishu chat operations. Actions: members, info, member_info",
+			parameters: FeishuChatSchema,
+			async execute(_toolCallId, params) {
+				const rawParams = params;
+				const p = params;
+				try {
+					const account = resolveFeishuToolAccount({
+						cfg,
+						defaultAccountId: toolContext.agentAccountId,
+						requiredTool: {
+							family: "chat",
+							label: "chat"
 						}
-					case "member_info":
-						if (!p.member_id) return feishuExternalToolResult({ error: "member_id is required for action member_info" });
-						if (!p.chat_id) return feishuExternalToolResult({ error: "chat_id is required for action member_info" });
-						{
-							const chat = await getAuthorizedFeishuChatInfo({
-								client,
-								cfg,
-								account,
-								chatId: p.chat_id,
-								ctx: toolContext
-							});
-							const authorization = authorizeFeishuChatMemberRead({
-								cfg,
-								account,
-								chatId: p.chat_id,
-								chatType: resolveFeishuChatType(chat),
-								ctx: toolContext,
-								memberId: p.member_id,
-								memberIdType: p.member_id_type
-							});
-							if (authorization.kind === "group") {
-								const memberIdType = p.member_id_type ?? "open_id";
-								await assertFeishuChatMember(client, p.chat_id, p.member_id, memberIdType);
-								return feishuExternalToolResult(await getFeishuMemberInfo(client, p.member_id, memberIdType));
+					});
+					const client = createFeishuClient(account);
+					switch (p.action) {
+						case "members":
+							if (!p.chat_id) return feishuExternalToolResult({ error: "chat_id is required for action members" });
+							{
+								const chat = await getAuthorizedFeishuChatInfo({
+									client,
+									cfg,
+									account,
+									chatId: p.chat_id,
+									ctx: toolContext
+								});
+								const authorization = authorizeFeishuChatMemberRead({
+									cfg,
+									account,
+									chatId: p.chat_id,
+									chatType: resolveFeishuChatType(chat),
+									ctx: toolContext,
+									memberIdType: p.member_id_type
+								});
+								if (authorization.kind === "direct") return feishuExternalToolResult(buildFeishuDirectChatMembers(authorization));
 							}
-							return feishuExternalToolResult(await getFeishuMemberInfo(client, authorization.memberId, authorization.memberIdType));
-						}
-					default: return feishuExternalToolResult({ error: `Unknown action: ${String(p.action)}` });
+							return feishuExternalToolResult(await getChatMembers(client, p.chat_id, readChatPageSize(rawParams), p.page_token, p.member_id_type));
+						case "info":
+							if (!p.chat_id) return feishuExternalToolResult({ error: "chat_id is required for action info" });
+							{
+								const chat = await getAuthorizedFeishuChatInfo({
+									client,
+									cfg,
+									account,
+									chatId: p.chat_id,
+									ctx: toolContext
+								});
+								return feishuExternalToolResult(chat);
+							}
+						case "member_info":
+							if (!p.member_id) return feishuExternalToolResult({ error: "member_id is required for action member_info" });
+							if (!p.chat_id) return feishuExternalToolResult({ error: "chat_id is required for action member_info" });
+							{
+								const chat = await getAuthorizedFeishuChatInfo({
+									client,
+									cfg,
+									account,
+									chatId: p.chat_id,
+									ctx: toolContext
+								});
+								const authorization = authorizeFeishuChatMemberRead({
+									cfg,
+									account,
+									chatId: p.chat_id,
+									chatType: resolveFeishuChatType(chat),
+									ctx: toolContext,
+									memberId: p.member_id,
+									memberIdType: p.member_id_type
+								});
+								if (authorization.kind === "group") {
+									const memberIdType = p.member_id_type ?? "open_id";
+									await assertFeishuChatMember(client, p.chat_id, p.member_id, memberIdType);
+									return feishuExternalToolResult(await getFeishuMemberInfo(client, p.member_id, memberIdType));
+								}
+								return feishuExternalToolResult(await getFeishuMemberInfo(client, authorization.memberId, authorization.memberIdType));
+							}
+						default: return feishuExternalToolResult({ error: `Unknown action: ${String(p.action)}` });
+					}
+				} catch (err) {
+					return feishuExternalToolResult({ error: formatFeishuApiError(err, { includeNestedErrorLogId: true }) });
 				}
-			} catch (err) {
-				return feishuExternalToolResult({ error: formatFeishuApiError(err, { includeNestedErrorLogId: true }) });
 			}
-		}
-	}), { name: "feishu_chat" });
+		};
+	}, { name: "feishu_chat" });
 }
 //#endregion
 export { getFeishuMemberInfo as a, getChatMembers as i, buildFeishuDirectChatMembers as n, registerFeishuChatTools as o, getChatInfo as r, assertFeishuChatMember as t };

package/dist/{client-DMbIL3UH.js → .setup/client-DCwNVFZg.mjs}

@@ -1,10 +1,13 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
 import { createRequire } from "node:module";
+import { PlatformMessageNotDispatchedError } from "openclaw/plugin-sdk/error-runtime";
 import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
 import * as Lark from "@larksuiteoapi/node-sdk";
 import { bufferToBlobPart } from "openclaw/plugin-sdk/blob-runtime";
 import { isRecord } from "openclaw/plugin-sdk/channel-secret-basic-runtime";
 import { readPluginPackageVersion, resolveAmbientNodeProxyAgent } from "openclaw/plugin-sdk/extension-shared";
+import { captureChannelReadAuthority } from "openclaw/plugin-sdk/fetch-runtime";
+import { AsyncLocalStorage } from "node:async_hooks";
 //#region extensions/feishu/src/client-timeout.ts
 /** Default HTTP timeout for Feishu API requests (30 seconds). */
 const FEISHU_HTTP_TIMEOUT_MS = 3e4;
@@ -26,6 +29,57 @@ function resolveConfiguredHttpTimeoutMs(creds) {
 	return clampTimeout(timeout);
 }
 //#endregion
+//#region extensions/feishu/src/send-context.ts
+const sendScope = new AsyncLocalStorage();
+/** Mutation errors preserve uncertainty after earlier requests reached the provider. */
+function withFeishuRequestContext(assertCurrent, request) {
+	return assertCurrent ? sendScope.run({ assertCurrent }, request) : request();
+}
+/** Keep invocation authority out of the shared, account-cached SDK client. */
+function withFeishuSendContext(context, send) {
+	const { signal, assertDirectAdapterHandoff, onPlatformSendDispatch } = context;
+	if (!signal && !assertDirectAdapterHandoff && !onPlatformSendDispatch) return send();
+	const assertCurrent = () => {
+		try {
+			signal?.throwIfAborted();
+			assertDirectAdapterHandoff?.();
+		} catch (cause) {
+			throw new PlatformMessageNotDispatchedError("Feishu sender retired before request dispatch", {
+				cause,
+				retryable: false
+			});
+		}
+	};
+	return sendScope.run({
+		assertCurrent,
+		onPlatformSendDispatch
+	}, send);
+}
+function captureFeishuSendAuthority() {
+	return sendScope.getStore()?.assertCurrent;
+}
+/** Only recipient-visible request owners opt into durable dispatch accounting. */
+function withFeishuMessageDispatch(request) {
+	const scope = sendScope.getStore();
+	scope?.assertCurrent();
+	return scope ? sendScope.run({
+		...scope,
+		recipientVisible: true
+	}, request) : request();
+}
+function captureFeishuSendContext() {
+	return sendScope.getStore();
+}
+async function runBeforeFeishuMessageDispatch(operation) {
+	try {
+		captureFeishuSendAuthority()?.();
+		return await operation();
+	} catch (error) {
+		if (error instanceof PlatformMessageNotDispatchedError) throw error;
+		throw new PlatformMessageNotDispatchedError(`Feishu media preparation failed before message dispatch: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+	}
+}
+//#endregion
 //#region extensions/feishu/src/client.ts
 var client_exports = /* @__PURE__ */ __exportAll({
 	createEventDispatcher: () => createEventDispatcher,
@@ -165,13 +219,14 @@ function createFeishuHttpInstance(defaultTimeoutMs, configuredDomain) {
 		destination.hash = requestUrl.hash;
 		return destination.toString();
 	}
-	async function injectRequestOptions(opts) {
+	async function injectRequestOptions(opts, authority) {
 		const next = {
 			timeout: defaultTimeoutMs,
 			...opts
 		};
 		if (typeof next.url === "string") next.url = resolveRequestUrl(next.url);
 		const agent = await getFeishuProxyAgent();
+		authority?.assertCurrent();
 		if (agent) {
 			if (isManagedProxyActive()) {
 				next.httpAgent = agent;
@@ -182,17 +237,79 @@ function createFeishuHttpInstance(defaultTimeoutMs, configuredDomain) {
 			}
 			next.proxy = false;
 		}
+		if (authority?.beforeDispatch) {
+			await authority.beforeDispatch();
+			authority.assertCurrent();
+		}
+		if (authority) {
+			const defaults = feishuClientSdk.defaultHttpInstance.defaults;
+			const transforms = next.transformRequest === void 0 ? defaults.transformRequest : next.transformRequest;
+			next.transformRequest = [...Array.isArray(transforms) ? transforms : transforms ? [transforms] : [], (data) => {
+				authority.assertCurrent();
+				return data;
+			}];
+			const beforeRedirect = next.beforeRedirect === void 0 ? defaults.beforeRedirect : next.beforeRedirect;
+			next.beforeRedirect = (...args) => {
+				beforeRedirect?.(...args);
+				authority.assertRedirect();
+			};
+		}
 		return next;
 	}
+	async function runRequest(request, sdkMethod) {
+		const assertReadAuthority = captureChannelReadAuthority();
+		const sendContext = captureFeishuSendContext();
+		const recipientVisible = sdkMethod === "request" && sendContext?.recipientVisible === true;
+		const onPlatformSendDispatch = recipientVisible ? sendContext.onPlatformSendDispatch : void 0;
+		let fenceFailure;
+		const assertCurrent = () => {
+			try {
+				assertReadAuthority?.();
+				sendContext?.assertCurrent();
+			} catch (cause) {
+				fenceFailure = cause instanceof Error ? cause : new Error("Feishu request authority closed", { cause });
+				throw fenceFailure;
+			}
+		};
+		const authority = assertReadAuthority || sendContext ? {
+			assertCurrent,
+			assertRedirect: recipientVisible ? () => {
+				try {
+					assertCurrent();
+				} catch {
+					const failure = /* @__PURE__ */ new Error("Feishu sender retired before following a message redirect");
+					fenceFailure = failure;
+					throw failure;
+				}
+			} : assertCurrent,
+			...onPlatformSendDispatch ? { beforeDispatch: async () => {
+				try {
+					await onPlatformSendDispatch();
+				} catch (cause) {
+					assertCurrent();
+					fenceFailure = cause instanceof PlatformMessageNotDispatchedError ? cause : new PlatformMessageNotDispatchedError("Feishu dispatch refresh failed before request", { cause });
+					throw fenceFailure;
+				}
+			} } : {}
+		} : void 0;
+		authority?.assertCurrent();
+		try {
+			return await request(authority);
+		} catch (error) {
+			assertReadAuthority?.();
+			if (fenceFailure) throw fenceFailure;
+			throw error;
+		}
+	}
 	return {
-		request: async (opts) => base.request(await injectRequestOptions(normalizeMultipartUploadData(opts))),
-		get: async (url, opts) => base.get(resolveRequestUrl(url), await injectRequestOptions(opts)),
-		post: async (url, data, opts) => base.post(resolveRequestUrl(url), data, await injectRequestOptions(opts)),
-		put: async (url, data, opts) => base.put(resolveRequestUrl(url), data, await injectRequestOptions(opts)),
-		patch: async (url, data, opts) => base.patch(resolveRequestUrl(url), data, await injectRequestOptions(opts)),
-		delete: async (url, opts) => base.delete(resolveRequestUrl(url), await injectRequestOptions(opts)),
-		head: async (url, opts) => base.head(resolveRequestUrl(url), await injectRequestOptions(opts)),
-		options: async (url, opts) => base.options(resolveRequestUrl(url), await injectRequestOptions(opts))
+		request: (opts) => runRequest(async (authority) => base.request(await injectRequestOptions(normalizeMultipartUploadData(opts), authority)), "request"),
+		get: (url, opts) => runRequest(async (assert) => base.get(resolveRequestUrl(url), await injectRequestOptions(opts, assert))),
+		post: (url, data, opts) => runRequest(async (assert) => base.post(resolveRequestUrl(url), data, await injectRequestOptions(opts, assert))),
+		put: (url, data, opts) => runRequest(async (assert) => base.put(resolveRequestUrl(url), data, await injectRequestOptions(opts, assert))),
+		patch: (url, data, opts) => runRequest(async (assert) => base.patch(resolveRequestUrl(url), data, await injectRequestOptions(opts, assert))),
+		delete: (url, opts) => runRequest(async (assert) => base.delete(resolveRequestUrl(url), await injectRequestOptions(opts, assert))),
+		head: (url, opts) => runRequest(async (assert) => base.head(resolveRequestUrl(url), await injectRequestOptions(opts, assert))),
+		options: (url, opts) => runRequest(async (assert) => base.options(resolveRequestUrl(url), await injectRequestOptions(opts, assert)))
 	};
 }
 /**
@@ -253,4 +370,4 @@ function createEventDispatcher(account) {
 	});
 }
 //#endregion
-export { getFeishuUserAgent as a, createFeishuWSClient as i, createEventDispatcher as n, FEISHU_HTTP_TIMEOUT_MS as o, createFeishuClient as r, resolveConfiguredHttpTimeoutMs as s, client_exports as t };
+export { getFeishuUserAgent as a, withFeishuMessageDispatch as c, FEISHU_HTTP_TIMEOUT_MS as d, resolveConfiguredHttpTimeoutMs as f, createFeishuWSClient as i, withFeishuRequestContext as l, createEventDispatcher as n, captureFeishuSendAuthority as o, createFeishuClient as r, runBeforeFeishuMessageDispatch as s, client_exports as t, withFeishuSendContext as u };

package/dist/{conversation-id-VYgGQ-GX.js → .setup/conversation-id-H-lUayji.mjs}

@@ -1,4 +1,50 @@
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/feishu/src/targets.ts
+const CHAT_ID_PREFIX = "oc_";
+const OPEN_ID_PREFIX = "ou_";
+const USER_ID_REGEX = /^[a-zA-Z0-9_-]+$/;
+function stripFeishuProviderPrefix(raw) {
+	return raw.replace(/^(feishu|lark):/i, "").trim();
+}
+function detectIdType(id) {
+	const trimmed = id.trim();
+	if (trimmed.startsWith(CHAT_ID_PREFIX)) return "chat_id";
+	if (trimmed.startsWith(OPEN_ID_PREFIX)) return "open_id";
+	if (USER_ID_REGEX.test(trimmed)) return "user_id";
+	return null;
+}
+function normalizeFeishuTarget(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return null;
+	const withoutProvider = stripFeishuProviderPrefix(trimmed);
+	const lowered = normalizeLowercaseStringOrEmpty(withoutProvider);
+	if (lowered.startsWith("chat:")) return withoutProvider.slice(5).trim() || null;
+	if (lowered.startsWith("group:")) return withoutProvider.slice(6).trim() || null;
+	if (lowered.startsWith("channel:")) return withoutProvider.slice(8).trim() || null;
+	if (lowered.startsWith("user:")) return withoutProvider.slice(5).trim() || null;
+	if (lowered.startsWith("dm:")) return withoutProvider.slice(3).trim() || null;
+	if (lowered.startsWith("open_id:")) return withoutProvider.slice(8).trim() || null;
+	return withoutProvider;
+}
+function resolveReceiveIdType(id) {
+	const trimmed = id.trim();
+	const lowered = normalizeLowercaseStringOrEmpty(trimmed);
+	if (lowered.startsWith("chat:") || lowered.startsWith("group:") || lowered.startsWith("channel:")) return "chat_id";
+	if (lowered.startsWith("open_id:")) return "open_id";
+	if (lowered.startsWith("user:") || lowered.startsWith("dm:")) return trimmed.replace(/^(user|dm):/i, "").trim().startsWith(OPEN_ID_PREFIX) ? "open_id" : "user_id";
+	if (trimmed.startsWith(CHAT_ID_PREFIX)) return "chat_id";
+	if (trimmed.startsWith(OPEN_ID_PREFIX)) return "open_id";
+	return "user_id";
+}
+function looksLikeFeishuId(raw) {
+	const trimmed = stripFeishuProviderPrefix(raw.trim());
+	if (!trimmed) return false;
+	if (/^(chat|group|channel|user|dm|open_id):/i.test(trimmed)) return true;
+	if (trimmed.startsWith(CHAT_ID_PREFIX)) return true;
+	if (trimmed.startsWith(OPEN_ID_PREFIX)) return true;
+	return false;
+}
+//#endregion
 //#region extensions/feishu/src/conversation-id.ts
 function resolveConfiguredFeishuGroupSessionScope(params) {
 	const legacyTopicSessionMode = params.groupConfig?.topicSessionMode ?? params.feishuCfg?.topicSessionMode ?? "disabled";
@@ -21,23 +67,12 @@ function buildFeishuConversationId(params) {
 function parseFeishuTargetId(raw) {
 	const target = normalizeOptionalString(raw);
 	if (!target) return;
-	const withoutProvider = target.replace(/^(feishu|lark):/i, "").trim();
-	if (!withoutProvider) return;
-	const lowered = normalizeLowercaseStringOrEmpty(withoutProvider);
-	for (const prefix of [
-		"chat:",
-		"group:",
-		"channel:",
-		"user:",
-		"dm:",
-		"open_id:"
-	]) if (lowered.startsWith(prefix)) return normalizeOptionalString(withoutProvider.slice(prefix.length));
-	return withoutProvider;
+	return normalizeFeishuTarget(target) || void 0;
 }
 function parseFeishuDirectConversationId(raw) {
 	const target = normalizeOptionalString(raw);
 	if (!target) return;
-	const withoutProvider = target.replace(/^(feishu|lark):/i, "").trim();
+	const withoutProvider = stripFeishuProviderPrefix(target);
 	if (!withoutProvider) return;
 	const lowered = normalizeLowercaseStringOrEmpty(withoutProvider);
 	for (const prefix of [
@@ -139,4 +174,4 @@ function buildFeishuModelOverrideParentCandidates(parentConversationId) {
 	return [];
 }
 //#endregion
-export { parseFeishuTargetId as a, parseFeishuDirectConversationId as i, buildFeishuModelOverrideParentCandidates as n, resolveConfiguredFeishuGroupSessionScope as o, parseFeishuConversationId as r, buildFeishuConversationId as t };
+export { parseFeishuTargetId as a, looksLikeFeishuId as c, stripFeishuProviderPrefix as d, parseFeishuDirectConversationId as i, normalizeFeishuTarget as l, buildFeishuModelOverrideParentCandidates as n, resolveConfiguredFeishuGroupSessionScope as o, parseFeishuConversationId as r, detectIdType as s, buildFeishuConversationId as t, resolveReceiveIdType as u };

package/dist/{monitor-DSGtOPio.js → .setup/monitor-C69OLzgO.mjs}

@@ -1,6 +1,6 @@
-import { r as listEnabledFeishuAccounts, s as resolveFeishuRuntimeAccount } from "./accounts-cCMNFBKg.js";
-import { t as getFeishuRuntime } from "./runtime-C5JxBWZp.js";
-import { r as registerFeishuAiAgent, t as probeFeishu } from "./probe-D_SatdZl.js";
+import { r as listEnabledFeishuAccounts, s as resolveFeishuRuntimeAccount } from "./accounts-DmU0xYPx.mjs";
+import { t as getFeishuRuntime } from "./runtime-C5JxBWZp.mjs";
+import { r as registerFeishuAiAgent, t as probeFeishu } from "./probe-bdidyhAn.mjs";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
@@ -143,7 +143,7 @@ async function fetchBotIdentityForMonitor(account, options = {}) {
 }
 //#endregion
 //#region extensions/feishu/src/monitor.ts
-const loadMonitorAccountRuntime = createLazyRuntimeModule(() => import("./monitor.account-BRDUsS_q.js"));
+const loadMonitorAccountRuntime = createLazyRuntimeModule(() => import("./monitor.account-zwHb3HKM.mjs"));
 async function monitorFeishuProvider(opts = {}) {
 	const cfg = opts.config;
 	if (!cfg) throw new Error("Config is required for Feishu monitor");