@nextclaw/channel-plugin-feishu 0.2.29-beta.0 → 0.2.29-beta.2

package/dist/src/reply-dispatcher.js

@@ -0,0 +1,250 @@
+import { createReplyPrefixContext, createTypingCallbacks, logTypingFailure } from "./nextclaw-sdk/core-pairing.js";
+import "./nextclaw-sdk/feishu.js";
+import { resolveFeishuAccount } from "./accounts.js";
+import { createFeishuClient } from "./client.js";
+import { resolveReceiveIdType } from "./targets.js";
+import { getFeishuRuntime } from "./runtime.js";
+import { sendMediaFeishu } from "./media.js";
+import { buildMentionedCardContent } from "./mention.js";
+import { sendMarkdownCardFeishu, sendMessageFeishu } from "./send.js";
+import { FeishuStreamingSession, mergeStreamingText } from "./streaming-card.js";
+import { addTypingIndicator, removeTypingIndicator } from "./typing.js";
+//#region src/reply-dispatcher.ts
+/** Detect if text contains markdown elements that benefit from card rendering */
+function shouldUseCard(text) {
+	return /```[\s\S]*?```/.test(text) || /\|.+\|[\r\n]+\|[-:| ]+\|/.test(text);
+}
+/** Maximum age (ms) for a message to receive a typing indicator reaction.
+* Messages older than this are likely replays after context compaction (#30418). */
+const TYPING_INDICATOR_MAX_AGE_MS = 2 * 6e4;
+const MS_EPOCH_MIN = 0xe8d4a51000;
+function normalizeEpochMs(timestamp) {
+	if (!Number.isFinite(timestamp) || timestamp === void 0 || timestamp <= 0) return;
+	return timestamp < MS_EPOCH_MIN ? timestamp * 1e3 : timestamp;
+}
+function createFeishuReplyDispatcher(params) {
+	const core = getFeishuRuntime();
+	const { cfg, agentId, chatId, replyToMessageId, skipReplyToInMessages, replyInThread, threadReply, rootId, mentionTargets, accountId } = params;
+	const sendReplyToMessageId = skipReplyToInMessages ? void 0 : replyToMessageId;
+	const threadReplyMode = threadReply === true;
+	const effectiveReplyInThread = threadReplyMode ? true : replyInThread;
+	const account = resolveFeishuAccount({
+		cfg,
+		accountId
+	});
+	const prefixContext = createReplyPrefixContext({
+		cfg,
+		agentId
+	});
+	let typingState = null;
+	const typingCallbacks = createTypingCallbacks({
+		start: async () => {
+			if (!(account.config.typingIndicator ?? true)) return;
+			if (!replyToMessageId) return;
+			const messageCreateTimeMs = normalizeEpochMs(params.messageCreateTimeMs);
+			if (messageCreateTimeMs !== void 0 && Date.now() - messageCreateTimeMs > TYPING_INDICATOR_MAX_AGE_MS) return;
+			if (typingState?.reactionId) return;
+			typingState = await addTypingIndicator({
+				cfg,
+				messageId: replyToMessageId,
+				accountId,
+				runtime: params.runtime
+			});
+		},
+		stop: async () => {
+			if (!typingState) return;
+			await removeTypingIndicator({
+				cfg,
+				state: typingState,
+				accountId,
+				runtime: params.runtime
+			});
+			typingState = null;
+		},
+		onStartError: (err) => logTypingFailure({
+			log: (message) => params.runtime.log?.(message),
+			channel: "feishu",
+			action: "start",
+			error: err
+		}),
+		onStopError: (err) => logTypingFailure({
+			log: (message) => params.runtime.log?.(message),
+			channel: "feishu",
+			action: "stop",
+			error: err
+		})
+	});
+	const textChunkLimit = core.channel.text.resolveTextChunkLimit(cfg, "feishu", accountId, { fallbackLimit: 4e3 });
+	const chunkMode = core.channel.text.resolveChunkMode(cfg, "feishu");
+	const tableMode = core.channel.text.resolveMarkdownTableMode({
+		cfg,
+		channel: "feishu"
+	});
+	const renderMode = account.config?.renderMode ?? "auto";
+	const streamingEnabled = !threadReplyMode && account.config?.streaming !== false && renderMode !== "raw";
+	let streaming = null;
+	let streamText = "";
+	let lastPartial = "";
+	const deliveredFinalTexts = /* @__PURE__ */ new Set();
+	let partialUpdateQueue = Promise.resolve();
+	let streamingStartPromise = null;
+	const queueStreamingUpdate = (nextText, options) => {
+		if (!nextText) return;
+		if (options?.dedupeWithLastPartial && nextText === lastPartial) return;
+		if (options?.dedupeWithLastPartial) lastPartial = nextText;
+		streamText = (options?.mode ?? "snapshot") === "delta" ? `${streamText}${nextText}` : mergeStreamingText(streamText, nextText);
+		partialUpdateQueue = partialUpdateQueue.then(async () => {
+			if (streamingStartPromise) await streamingStartPromise;
+			if (streaming?.isActive()) await streaming.update(streamText);
+		});
+	};
+	const startStreaming = () => {
+		if (!streamingEnabled || streamingStartPromise || streaming) return;
+		streamingStartPromise = (async () => {
+			const creds = account.appId && account.appSecret ? {
+				appId: account.appId,
+				appSecret: account.appSecret,
+				domain: account.domain
+			} : null;
+			if (!creds) return;
+			streaming = new FeishuStreamingSession(createFeishuClient(account), creds, (message) => params.runtime.log?.(`feishu[${account.accountId}] ${message}`));
+			try {
+				await streaming.start(chatId, resolveReceiveIdType(chatId), {
+					replyToMessageId,
+					replyInThread: effectiveReplyInThread,
+					rootId
+				});
+			} catch (error) {
+				params.runtime.error?.(`feishu: streaming start failed: ${String(error)}`);
+				streaming = null;
+			}
+		})();
+	};
+	const closeStreaming = async () => {
+		if (streamingStartPromise) await streamingStartPromise;
+		await partialUpdateQueue;
+		if (streaming?.isActive()) {
+			let text = streamText;
+			if (mentionTargets?.length) text = buildMentionedCardContent(mentionTargets, text);
+			await streaming.close(text);
+		}
+		streaming = null;
+		streamingStartPromise = null;
+		streamText = "";
+		lastPartial = "";
+	};
+	const sendChunkedTextReply = async (params) => {
+		let first = true;
+		const chunkSource = params.useCard ? params.text : core.channel.text.convertMarkdownTables(params.text, tableMode);
+		for (const chunk of core.channel.text.chunkTextWithMode(chunkSource, textChunkLimit, chunkMode)) {
+			const message = {
+				cfg,
+				to: chatId,
+				text: chunk,
+				replyToMessageId: sendReplyToMessageId,
+				replyInThread: effectiveReplyInThread,
+				mentions: first ? mentionTargets : void 0,
+				accountId
+			};
+			if (params.useCard) await sendMarkdownCardFeishu(message);
+			else await sendMessageFeishu(message);
+			first = false;
+		}
+		if (params.infoKind === "final") deliveredFinalTexts.add(params.text);
+	};
+	const { dispatcher, replyOptions, markDispatchIdle } = core.channel.reply.createReplyDispatcherWithTyping({
+		responsePrefix: prefixContext.responsePrefix,
+		responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
+		humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, agentId),
+		onReplyStart: () => {
+			deliveredFinalTexts.clear();
+			typingCallbacks.onReplyStart?.();
+		},
+		deliver: async (payload, info) => {
+			const text = payload.text ?? "";
+			const mediaList = payload.mediaUrls && payload.mediaUrls.length > 0 ? payload.mediaUrls : payload.mediaUrl ? [payload.mediaUrl] : [];
+			const hasText = Boolean(text.trim());
+			const hasMedia = mediaList.length > 0;
+			const skipTextForDuplicateFinal = info?.kind === "final" && hasText && deliveredFinalTexts.has(text);
+			const shouldDeliverText = hasText && !skipTextForDuplicateFinal;
+			if (!shouldDeliverText && !hasMedia) return;
+			if (shouldDeliverText) {
+				const useCard = renderMode === "card" || renderMode === "auto" && shouldUseCard(text);
+				if (info?.kind === "block") {
+					if (!(streamingEnabled && useCard)) return;
+					startStreaming();
+					if (streamingStartPromise) await streamingStartPromise;
+				}
+				if (info?.kind === "final" && streamingEnabled && useCard) {
+					startStreaming();
+					if (streamingStartPromise) await streamingStartPromise;
+				}
+				if (streaming?.isActive()) {
+					if (info?.kind === "block") queueStreamingUpdate(text, { mode: "delta" });
+					if (info?.kind === "final") {
+						streamText = mergeStreamingText(streamText, text);
+						await closeStreaming();
+						deliveredFinalTexts.add(text);
+					}
+					if (hasMedia) for (const mediaUrl of mediaList) await sendMediaFeishu({
+						cfg,
+						to: chatId,
+						mediaUrl,
+						replyToMessageId: sendReplyToMessageId,
+						replyInThread: effectiveReplyInThread,
+						accountId
+					});
+					return;
+				}
+				if (useCard) await sendChunkedTextReply({
+					text,
+					useCard: true,
+					infoKind: info?.kind
+				});
+				else await sendChunkedTextReply({
+					text,
+					useCard: false,
+					infoKind: info?.kind
+				});
+			}
+			if (hasMedia) for (const mediaUrl of mediaList) await sendMediaFeishu({
+				cfg,
+				to: chatId,
+				mediaUrl,
+				replyToMessageId: sendReplyToMessageId,
+				replyInThread: effectiveReplyInThread,
+				accountId
+			});
+		},
+		onError: async (error, info) => {
+			params.runtime.error?.(`feishu[${account.accountId}] ${info.kind} reply failed: ${String(error)}`);
+			await closeStreaming();
+			typingCallbacks.onIdle?.();
+		},
+		onIdle: async () => {
+			await closeStreaming();
+			typingCallbacks.onIdle?.();
+		},
+		onCleanup: () => {
+			typingCallbacks.onCleanup?.();
+		}
+	});
+	return {
+		dispatcher,
+		replyOptions: {
+			...replyOptions,
+			onModelSelected: prefixContext.onModelSelected,
+			disableBlockStreaming: true,
+			onPartialReply: streamingEnabled ? (payload) => {
+				if (!payload.text) return;
+				queueStreamingUpdate(payload.text, {
+					dedupeWithLastPartial: true,
+					mode: "snapshot"
+				});
+			} : void 0
+		},
+		markDispatchIdle
+	};
+}
+//#endregion
+export { createFeishuReplyDispatcher };

package/dist/src/runtime.js

@@ -0,0 +1,5 @@
+import { createPluginRuntimeStore } from "./nextclaw-sdk/runtime-store.js";
+//#region src/runtime.ts
+const { setRuntime: setFeishuRuntime, getRuntime: getFeishuRuntime } = createPluginRuntimeStore("Feishu runtime not initialized");
+//#endregion
+export { getFeishuRuntime, setFeishuRuntime };

package/dist/src/secret-input.js

@@ -0,0 +1,3 @@
+import "./nextclaw-sdk/secrets-core.js";
+import "./nextclaw-sdk/feishu.js";
+export {};

package/dist/src/send-result.js

@@ -0,0 +1,12 @@
+//#region src/send-result.ts
+function assertFeishuMessageApiSuccess(response, errorPrefix) {
+	if (response.code !== 0) throw new Error(`${errorPrefix}: ${response.msg || `code ${response.code}`}`);
+}
+function toFeishuSendResult(response, chatId) {
+	return {
+		messageId: response.data?.message_id ?? "unknown",
+		chatId
+	};
+}
+//#endregion
+export { assertFeishuMessageApiSuccess, toFeishuSendResult };

package/dist/src/send-target.js

@@ -0,0 +1,22 @@
+import { resolveFeishuAccount } from "./accounts.js";
+import { createFeishuClient } from "./client.js";
+import { normalizeFeishuTarget, resolveReceiveIdType } from "./targets.js";
+//#region src/send-target.ts
+function resolveFeishuSendTarget(params) {
+	const target = params.to.trim();
+	const account = resolveFeishuAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	if (!account.configured) throw new Error(`Feishu account "${account.accountId}" not configured`);
+	const client = createFeishuClient(account);
+	const receiveId = normalizeFeishuTarget(target);
+	if (!receiveId) throw new Error(`Invalid Feishu target: ${params.to}`);
+	return {
+		client,
+		receiveId,
+		receiveIdType: resolveReceiveIdType(target.replace(/^(feishu|lark):/i, ""))
+	};
+}
+//#endregion
+export { resolveFeishuSendTarget };

package/dist/src/send.d.ts

@@ -0,0 +1,51 @@
+import { ClawdbotConfig } from "./nextclaw-sdk/types.js";
+import { MentionTarget } from "./mention.js";
+import { FeishuMessageInfo, FeishuSendResult } from "./types.js";
+
+//#region src/send.d.ts
+/**
+ * Get a message by its ID.
+ * Useful for fetching quoted/replied message content.
+ */
+declare function getMessageFeishu(params: {
+  cfg: ClawdbotConfig;
+  messageId: string;
+  accountId?: string;
+}): Promise<FeishuMessageInfo | null>;
+type SendFeishuMessageParams = {
+  cfg: ClawdbotConfig;
+  to: string;
+  text: string;
+  replyToMessageId?: string; /** When true, reply creates a Feishu topic thread instead of an inline reply */
+  replyInThread?: boolean; /** Mention target users */
+  mentions?: MentionTarget[]; /** Account ID (optional, uses default if not specified) */
+  accountId?: string;
+};
+declare function sendMessageFeishu(params: SendFeishuMessageParams): Promise<FeishuSendResult>;
+type SendFeishuCardParams = {
+  cfg: ClawdbotConfig;
+  to: string;
+  card: Record<string, unknown>;
+  replyToMessageId?: string; /** When true, reply creates a Feishu topic thread instead of an inline reply */
+  replyInThread?: boolean;
+  accountId?: string;
+};
+declare function sendCardFeishu(params: SendFeishuCardParams): Promise<FeishuSendResult>;
+declare function updateCardFeishu(params: {
+  cfg: ClawdbotConfig;
+  messageId: string;
+  card: Record<string, unknown>;
+  accountId?: string;
+}): Promise<void>;
+/**
+ * Edit an existing text message.
+ * Note: Feishu only allows editing messages within 24 hours.
+ */
+declare function editMessageFeishu(params: {
+  cfg: ClawdbotConfig;
+  messageId: string;
+  text: string;
+  accountId?: string;
+}): Promise<void>;
+//#endregion
+export { editMessageFeishu, getMessageFeishu, sendCardFeishu, sendMessageFeishu, updateCardFeishu };

package/dist/src/send.js

@@ -0,0 +1,265 @@
+import { resolveFeishuAccount } from "./accounts.js";
+import { createFeishuClient } from "./client.js";
+import { getFeishuRuntime } from "./runtime.js";
+import { assertFeishuMessageApiSuccess, toFeishuSendResult } from "./send-result.js";
+import { resolveFeishuSendTarget } from "./send-target.js";
+import { buildMentionedCardContent, buildMentionedMessage } from "./mention.js";
+import { parsePostContent } from "./post.js";
+//#region src/send.ts
+const WITHDRAWN_REPLY_ERROR_CODES = new Set([230011, 231003]);
+function shouldFallbackFromReplyTarget(response) {
+	if (response.code !== void 0 && WITHDRAWN_REPLY_ERROR_CODES.has(response.code)) return true;
+	const msg = response.msg?.toLowerCase() ?? "";
+	return msg.includes("withdrawn") || msg.includes("not found");
+}
+/** Check whether a thrown error indicates a withdrawn/not-found reply target. */
+function isWithdrawnReplyError(err) {
+	if (typeof err !== "object" || err === null) return false;
+	const code = err.code;
+	if (typeof code === "number" && WITHDRAWN_REPLY_ERROR_CODES.has(code)) return true;
+	const response = err.response;
+	if (typeof response?.data?.code === "number" && WITHDRAWN_REPLY_ERROR_CODES.has(response.data.code)) return true;
+	return false;
+}
+/** Send a direct message as a fallback when a reply target is unavailable. */
+async function sendFallbackDirect(client, params, errorPrefix) {
+	const response = await client.im.message.create({
+		params: { receive_id_type: params.receiveIdType },
+		data: {
+			receive_id: params.receiveId,
+			content: params.content,
+			msg_type: params.msgType
+		}
+	});
+	assertFeishuMessageApiSuccess(response, errorPrefix);
+	return toFeishuSendResult(response, params.receiveId);
+}
+async function sendReplyOrFallbackDirect(client, params) {
+	if (!params.replyToMessageId) return sendFallbackDirect(client, params.directParams, params.directErrorPrefix);
+	let response;
+	try {
+		response = await client.im.message.reply({
+			path: { message_id: params.replyToMessageId },
+			data: {
+				content: params.content,
+				msg_type: params.msgType,
+				...params.replyInThread ? { reply_in_thread: true } : {}
+			}
+		});
+	} catch (err) {
+		if (!isWithdrawnReplyError(err)) throw err;
+		return sendFallbackDirect(client, params.directParams, params.directErrorPrefix);
+	}
+	if (shouldFallbackFromReplyTarget(response)) return sendFallbackDirect(client, params.directParams, params.directErrorPrefix);
+	assertFeishuMessageApiSuccess(response, params.replyErrorPrefix);
+	return toFeishuSendResult(response, params.directParams.receiveId);
+}
+function parseInteractiveCardContent(parsed) {
+	if (!parsed || typeof parsed !== "object") return "[Interactive Card]";
+	const candidate = parsed;
+	if (!Array.isArray(candidate.elements)) return "[Interactive Card]";
+	const texts = [];
+	for (const element of candidate.elements) {
+		if (!element || typeof element !== "object") continue;
+		const item = element;
+		if (item.tag === "div" && typeof item.text?.content === "string") {
+			texts.push(item.text.content);
+			continue;
+		}
+		if (item.tag === "markdown" && typeof item.content === "string") texts.push(item.content);
+	}
+	return texts.join("\n").trim() || "[Interactive Card]";
+}
+function parseQuotedMessageContent(rawContent, msgType) {
+	if (!rawContent) return "";
+	let parsed;
+	try {
+		parsed = JSON.parse(rawContent);
+	} catch {
+		return rawContent;
+	}
+	if (msgType === "text") {
+		const text = parsed?.text;
+		return typeof text === "string" ? text : "[Text message]";
+	}
+	if (msgType === "post") return parsePostContent(rawContent).textContent;
+	if (msgType === "interactive") return parseInteractiveCardContent(parsed);
+	if (typeof parsed === "string") return parsed;
+	const genericText = parsed?.text;
+	if (typeof genericText === "string" && genericText.trim()) return genericText;
+	const genericTitle = parsed?.title;
+	if (typeof genericTitle === "string" && genericTitle.trim()) return genericTitle;
+	return `[${msgType || "unknown"} message]`;
+}
+/**
+* Get a message by its ID.
+* Useful for fetching quoted/replied message content.
+*/
+async function getMessageFeishu(params) {
+	const { cfg, messageId, accountId } = params;
+	const account = resolveFeishuAccount({
+		cfg,
+		accountId
+	});
+	if (!account.configured) throw new Error(`Feishu account "${account.accountId}" not configured`);
+	const client = createFeishuClient(account);
+	try {
+		const response = await client.im.message.get({ path: { message_id: messageId } });
+		if (response.code !== 0) return null;
+		const rawItem = response.data?.items?.[0] ?? response.data;
+		const item = rawItem && (rawItem.body !== void 0 || rawItem.message_id !== void 0) ? rawItem : null;
+		if (!item) return null;
+		const msgType = item.msg_type ?? "text";
+		const content = parseQuotedMessageContent(item.body?.content ?? "", msgType);
+		return {
+			messageId: item.message_id ?? messageId,
+			chatId: item.chat_id ?? "",
+			chatType: item.chat_type === "group" || item.chat_type === "private" || item.chat_type === "p2p" ? item.chat_type : void 0,
+			senderId: item.sender?.id,
+			senderOpenId: item.sender?.id_type === "open_id" ? item.sender?.id : void 0,
+			senderType: item.sender?.sender_type,
+			content,
+			contentType: msgType,
+			createTime: item.create_time ? parseInt(String(item.create_time), 10) : void 0
+		};
+	} catch {
+		return null;
+	}
+}
+function buildFeishuPostMessagePayload(params) {
+	const { messageText } = params;
+	return {
+		content: JSON.stringify({ zh_cn: { content: [[{
+			tag: "md",
+			text: messageText
+		}]] } }),
+		msgType: "post"
+	};
+}
+async function sendMessageFeishu(params) {
+	const { cfg, to, text, replyToMessageId, replyInThread, mentions, accountId } = params;
+	const { client, receiveId, receiveIdType } = resolveFeishuSendTarget({
+		cfg,
+		to,
+		accountId
+	});
+	const tableMode = getFeishuRuntime().channel.text.resolveMarkdownTableMode({
+		cfg,
+		channel: "feishu"
+	});
+	let rawText = text ?? "";
+	if (mentions && mentions.length > 0) rawText = buildMentionedMessage(mentions, rawText);
+	const { content, msgType } = buildFeishuPostMessagePayload({ messageText: getFeishuRuntime().channel.text.convertMarkdownTables(rawText, tableMode) });
+	return sendReplyOrFallbackDirect(client, {
+		replyToMessageId,
+		replyInThread,
+		content,
+		msgType,
+		directParams: {
+			receiveId,
+			receiveIdType,
+			content,
+			msgType
+		},
+		directErrorPrefix: "Feishu send failed",
+		replyErrorPrefix: "Feishu reply failed"
+	});
+}
+async function sendCardFeishu(params) {
+	const { cfg, to, card, replyToMessageId, replyInThread, accountId } = params;
+	const { client, receiveId, receiveIdType } = resolveFeishuSendTarget({
+		cfg,
+		to,
+		accountId
+	});
+	const content = JSON.stringify(card);
+	return sendReplyOrFallbackDirect(client, {
+		replyToMessageId,
+		replyInThread,
+		content,
+		msgType: "interactive",
+		directParams: {
+			receiveId,
+			receiveIdType,
+			content,
+			msgType: "interactive"
+		},
+		directErrorPrefix: "Feishu card send failed",
+		replyErrorPrefix: "Feishu card reply failed"
+	});
+}
+async function updateCardFeishu(params) {
+	const { cfg, messageId, card, accountId } = params;
+	const account = resolveFeishuAccount({
+		cfg,
+		accountId
+	});
+	if (!account.configured) throw new Error(`Feishu account "${account.accountId}" not configured`);
+	const client = createFeishuClient(account);
+	const content = JSON.stringify(card);
+	const response = await client.im.message.patch({
+		path: { message_id: messageId },
+		data: { content }
+	});
+	if (response.code !== 0) throw new Error(`Feishu card update failed: ${response.msg || `code ${response.code}`}`);
+}
+/**
+* Build a Feishu interactive card with markdown content.
+* Cards render markdown properly (code blocks, tables, links, etc.)
+* Uses schema 2.0 format for proper markdown rendering.
+*/
+function buildMarkdownCard(text) {
+	return {
+		schema: "2.0",
+		config: { wide_screen_mode: true },
+		body: { elements: [{
+			tag: "markdown",
+			content: text
+		}] }
+	};
+}
+/**
+* Send a message as a markdown card (interactive message).
+* This renders markdown properly in Feishu (code blocks, tables, bold/italic, etc.)
+*/
+async function sendMarkdownCardFeishu(params) {
+	const { cfg, to, text, replyToMessageId, replyInThread, mentions, accountId } = params;
+	let cardText = text;
+	if (mentions && mentions.length > 0) cardText = buildMentionedCardContent(mentions, text);
+	return sendCardFeishu({
+		cfg,
+		to,
+		card: buildMarkdownCard(cardText),
+		replyToMessageId,
+		replyInThread,
+		accountId
+	});
+}
+/**
+* Edit an existing text message.
+* Note: Feishu only allows editing messages within 24 hours.
+*/
+async function editMessageFeishu(params) {
+	const { cfg, messageId, text, accountId } = params;
+	const account = resolveFeishuAccount({
+		cfg,
+		accountId
+	});
+	if (!account.configured) throw new Error(`Feishu account "${account.accountId}" not configured`);
+	const client = createFeishuClient(account);
+	const tableMode = getFeishuRuntime().channel.text.resolveMarkdownTableMode({
+		cfg,
+		channel: "feishu"
+	});
+	const { content, msgType } = buildFeishuPostMessagePayload({ messageText: getFeishuRuntime().channel.text.convertMarkdownTables(text ?? "", tableMode) });
+	const response = await client.im.message.update({
+		path: { message_id: messageId },
+		data: {
+			msg_type: msgType,
+			content
+		}
+	});
+	if (response.code !== 0) throw new Error(`Feishu message edit failed: ${response.msg || `code ${response.code}`}`);
+}
+//#endregion
+export { editMessageFeishu, getMessageFeishu, sendCardFeishu, sendMarkdownCardFeishu, sendMessageFeishu, updateCardFeishu };