@openclaw/feishu 2026.7.2-beta.1 → 2026.7.2-beta.2

package/dist/{monitor.account-F99J862T.js → monitor.account-BSRV2hIF.js}

@@ -1,16 +1,16 @@
 import { _ as normalizeCommentFileType, c as encodeQuery, d as isRecord$1, f as normalizeString, g as buildFeishuCommentTarget, h as requestFeishuApi, l as extractReplyText, m as readString, o as resolveFeishuAccount, p as parseCommentContentElements, s as resolveFeishuRuntimeAccount } from "./accounts-BDoGHJDk.js";
 import { i as resolveReceiveIdType } from "./targets-BUjQ1TcA.js";
-import { C as resolveFeishuGroupConfig, D as resolveFeishuReplyPolicy, M as createFeishuCardInteractionEnvelope, N as decodeFeishuCardAction, O as normalizeFeishuChatType$2, S as resolveFeishuDmIngressAccess, T as resolveFeishuGroupSenderActivationIngressAccess, b as hasExplicitFeishuGroupConfig, d as chunkFeishuPostMarkdown, f as materializeFeishuPostMarkdownSoftBreaks, j as buildFeishuCardActionTextFallback, k as resolveFeishuChatType, o as resolveFeishuCardTemplate, w as resolveFeishuGroupConversationIngressAccess, x as normalizeFeishuAllowEntry } from "./send-result-CPS7AozW.js";
+import { A as resolveFeishuChatType, C as resolveFeishuDmIngressAccess, E as resolveFeishuGroupSenderActivationIngressAccess, M as buildFeishuCardActionTextFallback, N as createFeishuCardInteractionEnvelope, O as resolveFeishuReplyPolicy, P as decodeFeishuCardAction, S as normalizeFeishuAllowEntry, T as resolveFeishuGroupConversationIngressAccess, d as chunkFeishuPostMarkdown, f as materializeFeishuPostMarkdownSoftBreaks, k as normalizeFeishuChatType$2, o as resolveFeishuCardTemplate, w as resolveFeishuGroupConfig, x as hasExplicitFeishuGroupConfig } from "./send-result-DsqTk27v.js";
 import { o as resolveConfiguredFeishuGroupSessionScope, t as buildFeishuConversationId } from "./conversation-id-BeJL-wq7.js";
+import { a as getFeishuUserAgent, i as createFeishuWSClient, n as createEventDispatcher, r as createFeishuClient, s as resolveConfiguredHttpTimeoutMs } from "./client-87BmeMpj.js";
 import { t as getFeishuRuntime } from "./runtime-C5JxBWZp.js";
-import { a as getFeishuUserAgent, i as createFeishuWSClient, n as createEventDispatcher, r as createFeishuClient, s as resolveConfiguredHttpTimeoutMs } from "./client-BUC-R2Wi.js";
-import { i as createCommentTypingReactionLifecycle, l as getChatInfo, t as deliverCommentThreadText } from "./drive-Bpe8ONK_.js";
+import { i as createCommentTypingReactionLifecycle, l as getChatInfo, t as deliverCommentThreadText } from "./drive-B4E8OXZ0.js";
 import { t as createFeishuThreadBindingManager } from "./thread-bindings-V0bwk0A1.js";
 import { createReplyPrefixContext, evaluateSupplementalContextVisibility, getSessionEntry, normalizeAgentId as normalizeAgentId$2, resolveChannelContextVisibilityMode } from "./runtime-api.js";
 import { t as readFeishuJsonResponse } from "./json-response-CheljwGr.js";
-import { _ as resolveFeishuIdentityEmoji, c as parsePostContent, d as isMentionForwardRequest, f as isFeishuGroupChatType, g as normalizeFeishuExternalKey, h as shouldSuppressFeishuTextForVoiceMedia, i as sendCardFeishu, l as extractMentionTargets, m as sendMediaFeishu, n as getMessageFeishu, o as sendMessageFeishu, p as saveMessageResourceFeishu, r as listFeishuThreadMessages, s as sendStructuredCardFeishu, u as isFeishuBroadcastMention } from "./send-CpnLYueT.js";
-import { i as waitForAbortableDelay, r as raceWithTimeoutAndAbort } from "./probe-CAloGqgG.js";
-import { t as fetchBotIdentityForMonitor } from "./monitor.startup-DpZzunQn.js";
+import { _ as resolveFeishuIdentityEmoji, c as parsePostContent, d as isMentionForwardRequest, f as isFeishuGroupChatType, g as normalizeFeishuExternalKey, h as shouldSuppressFeishuTextForVoiceMedia, i as sendCardFeishu, l as extractMentionTargets, m as sendMediaFeishu, n as getMessageFeishu, o as sendMessageFeishu, p as saveMessageResourceFeishu, r as listFeishuThreadMessages, s as sendStructuredCardFeishu, u as isFeishuBroadcastMention } from "./send-DrWM_Ilf.js";
+import { i as waitForAbortableDelay, r as raceWithTimeoutAndAbort } from "./probe-BgboTHIn.js";
+import { t as fetchBotIdentityForMonitor } from "./monitor.startup-Cy8NPGAX.js";
 import { createChannelMessageReplyPipeline, formatChannelProgressDraftLineForEntry, isChannelProgressDraftWorkToolName, resolveAgentOutboundIdentity, resolveChannelPreviewStreamMode, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
 import { createChannelPairingController, createChannelPairingController as createChannelPairingController$1 } from "openclaw/plugin-sdk/channel-pairing";
 import { ensureConfiguredBindingRouteReady, resolveConfiguredBindingRoute, resolveRuntimeConversationBindingRoute } from "openclaw/plugin-sdk/conversation-runtime";
@@ -33,7 +33,7 @@ import crypto, { createHash } from "node:crypto";
 import { buildChannelInboundEventContext, formatInboundMediaUnavailableText, toInboundMediaFacts } from "openclaw/plugin-sdk/channel-inbound";
 import { DEFAULT_GROUP_HISTORY_LIMIT, createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
 import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
-import { createClaimableDedupe } from "openclaw/plugin-sdk/persistent-dedupe";
+import { createChannelReplayGuard } from "openclaw/plugin-sdk/persistent-dedupe";
 import { resolveChannelConfigWrites } from "openclaw/plugin-sdk/channel-config-writes";
 import { formatReasoningMessage } from "openclaw/plugin-sdk/agent-runtime";
 import { logTypingFailure } from "openclaw/plugin-sdk/channel-feedback";
@@ -563,12 +563,15 @@ const DEDUP_TTL_MS = 1440 * 60 * 1e3;
 const MEMORY_MAX_SIZE = 1e3;
 const STORE_MAX_ENTRIES = 1e4;
 function createFeishuDedupeGuard() {
-	return createClaimableDedupe({
-		pluginId: "feishu",
-		namespacePrefix: DEDUPE_NAMESPACE_PREFIX,
-		ttlMs: DEDUP_TTL_MS,
-		memoryMaxSize: MEMORY_MAX_SIZE,
-		stateMaxEntries: STORE_MAX_ENTRIES
+	return createChannelReplayGuard({
+		dedupe: {
+			pluginId: "feishu",
+			namespacePrefix: DEDUPE_NAMESPACE_PREFIX,
+			ttlMs: DEDUP_TTL_MS,
+			memoryMaxSize: MEMORY_MAX_SIZE,
+			stateMaxEntries: STORE_MAX_ENTRIES
+		},
+		buildReplayKey: (messageId) => messageId
 	});
 }
 const feishuDedupeState = {
@@ -590,18 +593,13 @@ function dedupeOptions(namespace, log) {
 }
 /**
 * Claims a dedupe key for exclusive handling. Duplicate (already committed)
-* and in-flight keys are reported; blank keys fail open as claimed so an
+* and in-flight keys are reported; blank keys fail open as invalid so an
 * unidentifiable event is never suppressed.
 */
 async function claimUnprocessedFeishuMessage(params) {
-	const key = dedupeKey(params.messageId);
-	if (!key) return "claimed";
-	return (await feishuDedupeState.guard.claim(key, dedupeOptions(params.namespace, params.log))).kind;
-}
-/** Drops an uncommitted claim so a failed handler can retry the message. */
-function releaseFeishuMessageProcessing(messageId, namespace = "global") {
-	const key = dedupeKey(messageId);
-	if (key) feishuDedupeState.guard.release(key, { namespace });
+	const claim = await feishuDedupeState.guard.claim(params.messageId, dedupeOptions(params.namespace, params.log));
+	if (claim.kind === "inflight") return { kind: "inflight" };
+	return claim;
 }
 /**
 * Claims (unless the caller already holds the claim) and commits a message.
@@ -612,26 +610,22 @@ async function finalizeFeishuMessageProcessing(params) {
 	const key = dedupeKey(params.messageId);
 	if (!key) return false;
 	const options = dedupeOptions(params.namespace, params.log);
-	if (!params.claimHeld && (await feishuDedupeState.guard.claim(key, options)).kind !== "claimed") return false;
-	return await feishuDedupeState.guard.commit(key, options);
+	const claim = params.processingClaim ?? await feishuDedupeState.guard.claim(key, options);
+	if ("kind" in claim && claim.kind !== "claimed") return false;
+	return await ("kind" in claim ? claim.handle : claim).commit();
 }
 /** Records a handled message so restart/replay cannot dispatch it again; false when already recorded. */
 async function recordProcessedFeishuMessage(messageId, namespace = "global", log) {
-	const key = dedupeKey(messageId);
-	if (!key) return false;
-	return await feishuDedupeState.guard.commit(key, dedupeOptions(namespace, log));
+	const claim = await feishuDedupeState.guard.claim(messageId, dedupeOptions(namespace, log));
+	return claim.kind === "claimed" ? await claim.handle.commit() : false;
 }
 /** Forgets a recorded message so a retryable synthetic event can be handled on redelivery. */
 async function forgetProcessedFeishuMessage(messageId, namespace = "global", log) {
-	const key = dedupeKey(messageId);
-	if (!key) return false;
-	return await feishuDedupeState.guard.forget(key, dedupeOptions(namespace, log));
+	return await feishuDedupeState.guard.forget(messageId, dedupeOptions(namespace, log));
 }
 /** Checks recency without claiming or recording. */
 async function hasProcessedFeishuMessage(messageId, namespace = "global", log) {
-	const key = dedupeKey(messageId);
-	if (!key) return false;
-	return await feishuDedupeState.guard.hasRecent(key, dedupeOptions(namespace, log));
+	return await feishuDedupeState.guard.hasRecent(messageId, dedupeOptions(namespace, log));
 }
 /** Loads recent persisted entries into memory at account start; returns the loaded count. */
 async function warmupDedupFromPluginState(namespace, log) {
@@ -2148,7 +2142,7 @@ async function filterFetchedGroupContextMessages(messages, params) {
 	}) ? message : void 0))).filter((message) => message !== void 0);
 }
 async function handleFeishuMessage(params) {
-	const { cfg, event, botOpenId, botName, runtime, channelRuntime, chatHistories, accountId, processingClaimHeld = false, messageDedupeKey: messageDedupeKeyOverride } = params;
+	const { cfg, event, botOpenId, botName, runtime, channelRuntime, chatHistories, accountId, processingClaim, messageDedupeKey: messageDedupeKeyOverride } = params;
 	const account = resolveFeishuRuntimeAccount({
 		cfg,
 		accountId
@@ -2162,7 +2156,7 @@ async function handleFeishuMessage(params) {
 		messageId: messageDedupeKey,
 		namespace: account.accountId,
 		log,
-		claimHeld: processingClaimHeld
+		processingClaim
 	})) {
 		log(`feishu: skipping duplicate message ${messageId}`);
 		return;
@@ -2827,7 +2821,7 @@ async function handleFeishuMessage(params) {
 						wasMentioned,
 						requireMention
 					},
-					commands: { authorized: commandAuthorized }
+					commands: { authorized: commandAuthorized === true }
 				},
 				extra: {
 					RootMessageId: ctx.rootId,
@@ -3863,11 +3857,11 @@ function createFeishuBotMenuHandler(params) {
 				namespace: accountId,
 				log
 			});
-			if (claim === "duplicate") {
+			if (claim.kind === "duplicate") {
 				log(`feishu[${accountId}]: dropping duplicate bot-menu event for ${syntheticMessageId}`);
 				return;
 			}
-			if (claim === "inflight") {
+			if (claim.kind === "inflight") {
 				log(`feishu[${accountId}]: dropping in-flight bot-menu event for ${syntheticMessageId}`);
 				return;
 			}
@@ -3880,7 +3874,7 @@ function createFeishuBotMenuHandler(params) {
 				channelRuntime: params.channelRuntime,
 				chatHistories,
 				accountId,
-				processingClaimHeld: true
+				processingClaim: claim.kind === "claimed" ? claim.handle : void 0
 			});
 			const promise = maybeHandleFeishuQuickActionMenu({
 				cfg,
@@ -3890,16 +3884,16 @@ function createFeishuBotMenuHandler(params) {
 				accountId
 			}).then(async (handledMenu) => {
 				if (handledMenu) {
-					await recordProcessedFeishuMessage(syntheticMessageId, accountId, log);
+					if (claim.kind === "claimed") await claim.handle.commit();
 					return;
 				}
 				return await handleLegacyMenu();
 			}).catch(async (err) => {
-				if (isFeishuRetryableSyntheticEventError(err)) await forgetProcessedFeishuMessage(syntheticMessageId, accountId, log);
-				else await recordProcessedFeishuMessage(syntheticMessageId, accountId, log);
+				if (isFeishuRetryableSyntheticEventError(err)) {
+					await forgetProcessedFeishuMessage(syntheticMessageId, accountId, log);
+					if (claim.kind === "claimed") claim.handle.release({ error: err });
+				} else if (claim.kind === "claimed") await claim.handle.commit();
 				throw err;
-			}).finally(() => {
-				releaseFeishuMessageProcessing(syntheticMessageId, accountId);
 			});
 			if (fireAndForget) {
 				promise.catch((err) => {
@@ -4088,11 +4082,6 @@ async function resolveParsedCommentContent(params) {
 		linkedDocuments: resolvedLinkedDocuments
 	};
 }
-async function delayMs(ms) {
-	await new Promise((resolve) => {
-		setTimeout(resolve, ms);
-	});
-}
 function buildDriveCommentTargetUrl(params) {
 	return `/open-apis/drive/v1/files/${encodeURIComponent(params.fileToken)}/comments/batch_query` + encodeQuery({
 		file_type: params.fileType,
@@ -4315,8 +4304,9 @@ async function fetchDriveCommentContext(params) {
 			fetchedMatchedReply = params.replyId ? replies.find((reply) => reply.reply_id?.trim() === params.replyId?.trim()) : void 0;
 		}
 		if (params.replyId && !embeddedTargetReply && !fetchedMatchedReply) for (let attempt = 1; attempt <= FEISHU_COMMENT_REPLY_MISS_RETRY_LIMIT; attempt += 1) {
+			if (params.abortSignal?.aborted) break;
 			params.logger?.(`feishu[${params.accountId}]: retrying comment reply lookup comment=${params.commentId} requested_reply=${params.replyId} attempt=${attempt}/${FEISHU_COMMENT_REPLY_MISS_RETRY_LIMIT} delay_ms=${FEISHU_COMMENT_REPLY_MISS_RETRY_DELAY_MS}`);
-			await params.waitMs(FEISHU_COMMENT_REPLY_MISS_RETRY_DELAY_MS);
+			if (!await waitForAbortableDelay(FEISHU_COMMENT_REPLY_MISS_RETRY_DELAY_MS, params.abortSignal)) break;
 			const retried = await fetchDriveCommentReplies(params);
 			if (retried.replies.length > 0) {
 				params.logger?.(`feishu[${params.accountId}]: fetched retried comment replies comment=${params.commentId} attempt=${attempt} count=${retried.replies.length} log_ids=${safeJsonStringify(retried.logIds)} summary=${summarizeCommentRepliesForLog(retried.replies)}`);
@@ -4464,7 +4454,7 @@ function buildDriveCommentSurfacePrompt(params) {
 	return lines.join("\n");
 }
 async function resolveDriveCommentEventCore(params) {
-	const { cfg, accountId, event, account, botOpenId, createClient, verificationTimeoutMs = FEISHU_COMMENT_VERIFY_TIMEOUT_MS, logger, waitMs = delayMs } = params;
+	const { cfg, accountId, event, account, botOpenId, createClient, verificationTimeoutMs = FEISHU_COMMENT_VERIFY_TIMEOUT_MS, logger, abortSignal } = params;
 	const eventId = event.event_id?.trim();
 	const commentId = event.comment_id?.trim();
 	const replyId = event.reply_id?.trim();
@@ -4502,7 +4492,7 @@ async function resolveDriveCommentEventCore(params) {
 		timeoutMs: verificationTimeoutMs,
 		logger,
 		accountId,
-		waitMs
+		abortSignal
 	});
 	return {
 		eventId,
@@ -4628,7 +4618,8 @@ async function handleFeishuCommentEvent(params) {
 		accountId: account.accountId,
 		event: params.event,
 		botOpenId: params.botOpenId,
-		logger: log
+		logger: log,
+		abortSignal: params.abortSignal
 	});
 	if (!turn) {
 		log(`feishu[${account.accountId}]: drive comment notice skipped event=${params.event.event_id ?? "unknown"} comment=${params.event.comment_id ?? "unknown"}`);
@@ -4912,7 +4903,7 @@ function buildCommentNoticeQueueKey(event) {
 	return `comment-doc:${event.notice_meta?.file_type?.trim() || "unknown"}:${event.notice_meta?.file_token?.trim() || "unknown"}`;
 }
 function createFeishuDriveCommentNoticeHandler(params) {
-	const { cfg, accountId, runtime, fireAndForget } = params;
+	const { cfg, accountId, runtime, fireAndForget, abortSignal } = params;
 	const log = runtime?.log ?? console.log;
 	const error = runtime?.error ?? console.error;
 	const enqueue = createSequentialQueue();
@@ -4932,20 +4923,22 @@ function createFeishuDriveCommentNoticeHandler(params) {
 			}
 			const eventId = event.event_id?.trim();
 			const syntheticMessageId = eventId ? `drive-comment:${eventId}` : void 0;
+			let processingClaim;
 			if (syntheticMessageId) {
 				const claim = await claimUnprocessedFeishuMessage({
 					messageId: syntheticMessageId,
 					namespace: accountId,
 					log
 				});
-				if (claim === "duplicate") {
+				if (claim.kind === "duplicate") {
 					log(`feishu[${accountId}]: dropping duplicate comment event ${syntheticMessageId}`);
 					return;
 				}
-				if (claim === "inflight") {
+				if (claim.kind === "inflight") {
 					log(`feishu[${accountId}]: dropping in-flight comment event ${syntheticMessageId}`);
 					return;
 				}
+				processingClaim = claim.kind === "claimed" ? claim.handle : void 0;
 			}
 			log(`feishu[${accountId}]: received drive comment notice event=${event.event_id ?? "unknown"} type=${event.notice_meta?.notice_type ?? "unknown"} file=${event.notice_meta?.file_type ?? "unknown"}:${event.notice_meta?.file_token ?? "unknown"} comment=${event.comment_id ?? "unknown"} reply=${event.reply_id ?? "none"} from=${event.notice_meta?.from_user_id?.open_id ?? "unknown"} mentioned=${event.is_mentioned === true ? "yes" : "no"}`);
 			try {
@@ -4955,15 +4948,15 @@ function createFeishuDriveCommentNoticeHandler(params) {
 						accountId,
 						event,
 						botOpenId: getBotOpenId(accountId),
-						runtime
+						runtime,
+						abortSignal
 					});
 				});
-				if (syntheticMessageId) await recordProcessedFeishuMessage(syntheticMessageId, accountId, log);
+				await processingClaim?.commit();
 			} catch (err) {
-				if (syntheticMessageId && !isFeishuRetryableSyntheticEventError(err)) await recordProcessedFeishuMessage(syntheticMessageId, accountId, log);
+				if (isFeishuRetryableSyntheticEventError(err)) processingClaim?.release({ error: err });
+				else await processingClaim?.commit();
 				throw err;
-			} finally {
-				if (syntheticMessageId) releaseFeishuMessageProcessing(syntheticMessageId, accountId);
 			}
 		});
 	};
@@ -5005,7 +4998,7 @@ function dedupeFeishuDebounceEntriesByDedupeKey(entries) {
 	const seen = /* @__PURE__ */ new Set();
 	const deduped = [];
 	for (const entry of entries) {
-		const dedupeKey = resolveFeishuMessageDedupeKey(entry);
+		const dedupeKey = resolveFeishuMessageDedupeKey(entry.event);
 		if (!dedupeKey) {
 			deduped.push(entry);
 			continue;
@@ -5027,7 +5020,7 @@ function resolveFeishuDebounceMentions(params) {
 	const botMentions = merged.filter((mention) => mention.id.open_id?.trim() === normalizedBotOpenId);
 	return botMentions.length > 0 ? botMentions : void 0;
 }
-function createFeishuMessageReceiveHandler({ cfg, channelRuntime, accountId, runtime, chatHistories, fireAndForget, handleMessage, resolveDebounceText: resolveText, hasProcessedMessage, recordProcessedMessage, getBotOpenId = () => void 0, getBotName = () => void 0, resolveSequentialKey = ({ accountId: accountIdLocal, event }) => `feishu:${accountIdLocal}:${event.message.chat_id?.trim() || "unknown"}`, statusSink }) {
+function createFeishuMessageReceiveHandler({ cfg, channelRuntime, accountId, runtime, chatHistories, fireAndForget, handleMessage, resolveDebounceText: resolveText, hasProcessedMessage, getBotOpenId = () => void 0, getBotName = () => void 0, resolveSequentialKey = ({ accountId: accountIdLocal, event }) => `feishu:${accountIdLocal}:${event.message.chat_id?.trim() || "unknown"}`, statusSink }) {
 	const inboundDebounceMs = channelRuntime.debounce.resolveInboundDebounceMs({
 		cfg,
 		channel: "feishu"
@@ -5037,7 +5030,7 @@ function createFeishuMessageReceiveHandler({ cfg, channelRuntime, accountId, run
 	const enqueue = createSequentialQueue({ onTaskTimeout: (key, timeoutMs) => {
 		log(`feishu[${accountId}]: per-chat task exceeded ${timeoutMs}ms cap (key=${key}); evicting from queue so later same-key messages can proceed (#70133)`);
 	} });
-	const dispatchFeishuMessage = async (event, messageDedupeKey) => {
+	const dispatchFeishuMessage = async (event, messageDedupeKey, processingClaim) => {
 		const sequentialKey = resolveSequentialKey({
 			accountId,
 			event,
@@ -5053,7 +5046,7 @@ function createFeishuMessageReceiveHandler({ cfg, channelRuntime, accountId, run
 			channelRuntime,
 			chatHistories,
 			accountId,
-			processingClaimHeld: true,
+			processingClaim,
 			messageDedupeKey
 		});
 		await enqueue(sequentialKey, task);
@@ -5070,23 +5063,26 @@ function createFeishuMessageReceiveHandler({ cfg, channelRuntime, accountId, run
 	};
 	const recordSuppressedMessageIds = async (entries, dispatchDedupeKey) => {
 		const keepDedupeKey = dispatchDedupeKey?.trim();
-		const suppressedIds = new Set(entries.map((entry) => resolveFeishuMessageDedupeKey(entry)).filter((id) => Boolean(id) && (!keepDedupeKey || id !== keepDedupeKey)));
-		for (const messageId of suppressedIds) try {
-			await recordProcessedMessage(messageId, accountId, log);
+		const suppressedIds = new Set(entries.map((entry) => ({
+			id: resolveFeishuMessageDedupeKey(entry.event),
+			claim: entry.processingClaim
+		})).filter(({ id }) => Boolean(id) && (!keepDedupeKey || id !== keepDedupeKey)));
+		for (const suppressed of suppressedIds) try {
+			await suppressed.claim?.commit();
 		} catch (err) {
-			error(`feishu[${accountId}]: failed to record merged dedupe id ${messageId}: ${String(err)}`);
+			error(`feishu[${accountId}]: failed to record merged dedupe id ${suppressed.id}: ${String(err)}`);
 		}
 	};
 	const inboundDebouncer = channelRuntime.debounce.createInboundDebouncer({
 		debounceMs: inboundDebounceMs,
-		buildKey: (event) => {
+		buildKey: ({ event }) => {
 			const chatId = event.message.chat_id?.trim();
 			const senderId = resolveSenderDebounceId(event);
 			if (!chatId || !senderId) return null;
 			const rootId = event.message.root_id?.trim();
 			return `feishu:${accountId}:${chatId}:${rootId ? `thread:${rootId}` : "chat"}:${senderId}`;
 		},
-		shouldDebounce: (event) => {
+		shouldDebounce: ({ event }) => {
 			if (event.message.message_type !== "text") return false;
 			const text = resolveDebounceText(event);
 			return Boolean(text) && !channelRuntime.commands.isControlCommandMessage(text, cfg);
@@ -5095,35 +5091,35 @@ function createFeishuMessageReceiveHandler({ cfg, channelRuntime, accountId, run
 			const last = entries.at(-1);
 			if (!last) return;
 			if (entries.length === 1) {
-				await dispatchFeishuMessage(last, resolveFeishuMessageDedupeKey(last));
+				await dispatchFeishuMessage(last.event, resolveFeishuMessageDedupeKey(last.event), last.processingClaim);
 				return;
 			}
 			const dedupedEntries = dedupeFeishuDebounceEntriesByDedupeKey(entries);
 			const freshEntries = [];
-			for (const entry of dedupedEntries) if (!await hasProcessedMessage(resolveFeishuMessageDedupeKey(entry), accountId, log)) freshEntries.push(entry);
+			for (const entry of dedupedEntries) if (!await hasProcessedMessage(resolveFeishuMessageDedupeKey(entry.event), accountId, log)) freshEntries.push(entry);
 			const dispatchEntry = freshEntries.at(-1);
 			if (!dispatchEntry) return;
-			const dispatchDedupeKey = resolveFeishuMessageDedupeKey(dispatchEntry);
+			const dispatchDedupeKey = resolveFeishuMessageDedupeKey(dispatchEntry.event);
 			await recordSuppressedMessageIds(dedupedEntries, dispatchDedupeKey);
-			const combinedText = freshEntries.map((entry) => resolveDebounceText(entry)).filter(Boolean).join("\n");
+			const combinedText = freshEntries.map((entry) => resolveDebounceText(entry.event)).filter(Boolean).join("\n");
 			const mergedMentions = resolveFeishuDebounceMentions({
-				entries: freshEntries,
+				entries: freshEntries.map((entry) => entry.event),
 				botOpenId: getBotOpenId(accountId)
 			});
 			await dispatchFeishuMessage({
-				...dispatchEntry,
+				...dispatchEntry.event,
 				message: {
-					...dispatchEntry.message,
+					...dispatchEntry.event.message,
 					...combinedText.trim() ? {
 						message_type: "text",
 						content: JSON.stringify({ text: combinedText })
 					} : {},
-					mentions: mergedMentions ?? dispatchEntry.message.mentions
+					mentions: mergedMentions ?? dispatchEntry.event.message.mentions
 				}
-			}, dispatchDedupeKey);
+			}, dispatchDedupeKey, dispatchEntry.processingClaim);
 		},
 		onError: (err, entries) => {
-			for (const entry of entries) releaseFeishuMessageProcessing(resolveFeishuMessageDedupeKey(entry), accountId);
+			for (const entry of entries) entry.processingClaim?.release({ error: err });
 			error(`feishu[${accountId}]: inbound debounce flush failed: ${String(err)}`);
 		}
 	});
@@ -5141,22 +5137,24 @@ function createFeishuMessageReceiveHandler({ cfg, channelRuntime, accountId, run
 			log(`feishu[${accountId}]: dropping self-authored message ${messageId ?? "unknown"}`);
 			return;
 		}
-		const messageDedupeKey = resolveFeishuMessageDedupeKey(event);
 		const claim = await claimUnprocessedFeishuMessage({
-			messageId: messageDedupeKey,
+			messageId: resolveFeishuMessageDedupeKey(event),
 			namespace: accountId,
 			log
 		});
-		if (claim !== "claimed") {
-			log(`feishu[${accountId}]: dropping ${claim} event for message ${messageId}`);
+		if (claim.kind === "duplicate" || claim.kind === "inflight") {
+			log(`feishu[${accountId}]: dropping ${claim.kind} event for message ${messageId}`);
 			return;
 		}
 		const processMessage = async () => {
-			await inboundDebouncer.enqueue(event);
+			await inboundDebouncer.enqueue({
+				event,
+				...claim.kind === "claimed" ? { processingClaim: claim.handle } : {}
+			});
 		};
 		if (fireAndForget) {
 			processMessage().catch((err) => {
-				releaseFeishuMessageProcessing(messageDedupeKey, accountId);
+				if (claim.kind === "claimed") claim.handle.release({ error: err });
 				error(`feishu[${accountId}]: error handling message: ${String(err)}`);
 			});
 			return;
@@ -5164,7 +5162,7 @@ function createFeishuMessageReceiveHandler({ cfg, channelRuntime, accountId, run
 		try {
 			await processMessage();
 		} catch (err) {
-			releaseFeishuMessageProcessing(messageDedupeKey, accountId);
+			if (claim.kind === "claimed") claim.handle.release({ error: err });
 			error(`feishu[${accountId}]: error handling message: ${String(err)}`);
 		}
 	};
@@ -5619,7 +5617,7 @@ function parseFeishuCardActionEventPayload(value) {
 	};
 }
 function registerEventHandlers(eventDispatcher, context) {
-	const { cfg, accountId, channelRuntime, runtime, chatHistories, fireAndForget } = context;
+	const { cfg, accountId, channelRuntime, runtime, chatHistories, fireAndForget, abortSignal } = context;
 	const log = runtime?.log ?? console.log;
 	const error = runtime?.error ?? console.error;
 	const runFeishuHandler = async (params) => {
@@ -5646,7 +5644,6 @@ function registerEventHandlers(eventDispatcher, context) {
 			handleMessage: handleFeishuMessage,
 			resolveDebounceText: ({ event, botOpenId, botName }) => parseFeishuMessageEvent(event, botOpenId, botName).content,
 			hasProcessedMessage: hasProcessedFeishuMessage,
-			recordProcessedMessage: recordProcessedFeishuMessage,
 			getBotOpenId: (id) => botOpenIds.get(id),
 			getBotName: (id) => botNames.get(id),
 			resolveSequentialKey: getFeishuSequentialKey,
@@ -5676,7 +5673,8 @@ function registerEventHandlers(eventDispatcher, context) {
 			cfg,
 			accountId,
 			runtime,
-			fireAndForget
+			fireAndForget,
+			abortSignal
 		}),
 		"im.message.reaction.created_v1": async (data) => {
 			await runFeishuHandler({
@@ -5805,6 +5803,7 @@ async function monitorSingleAccount(params) {
 			runtime,
 			chatHistories,
 			fireAndForget: params.fireAndForget ?? true,
+			abortSignal,
 			...params.statusSink ? { statusSink: params.statusSink } : {}
 		});
 		if (connectionMode === "webhook") return await monitorWebhook({

package/dist/{monitor.startup-DpZzunQn.js → monitor.startup-Cy8NPGAX.js}

@@ -1,4 +1,4 @@
-import { t as probeFeishu } from "./probe-CAloGqgG.js";
+import { t as probeFeishu } from "./probe-BgboTHIn.js";
 import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/feishu/src/monitor-startup-timeout.ts

package/dist/{probe-CAloGqgG.js → probe-BgboTHIn.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { r as createFeishuClient } from "./client-BUC-R2Wi.js";
+import { r as createFeishuClient } from "./client-87BmeMpj.js";
 import { asDateTimestampMs, resolveExpiresAtMsFromDurationMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 //#region extensions/feishu/src/async.ts

package/dist/{send-CpnLYueT.js → send-DrWM_Ilf.js}

@@ -1,18 +1,18 @@
 import { d as isRecord$1, h as requestFeishuApi, s as resolveFeishuRuntimeAccount } from "./accounts-BDoGHJDk.js";
 import { i as resolveReceiveIdType, r as normalizeFeishuTarget } from "./targets-BUjQ1TcA.js";
-import { c as assertFeishuPostWithinEnvelope, f as materializeFeishuPostMarkdownSoftBreaks, i as toFeishuSendResult, l as buildFeishuPostMessageContent, o as resolveFeishuCardTemplate, r as resolveFeishuReceiptKind, t as assertFeishuMessageApiSuccess } from "./send-result-CPS7AozW.js";
+import { c as assertFeishuPostWithinEnvelope, f as materializeFeishuPostMarkdownSoftBreaks, i as toFeishuSendResult, l as buildFeishuPostMessageContent, o as resolveFeishuCardTemplate, r as resolveFeishuReceiptKind, t as assertFeishuMessageApiSuccess } from "./send-result-DsqTk27v.js";
+import { r as createFeishuClient } from "./client-87BmeMpj.js";
 import { t as getFeishuRuntime } from "./runtime-C5JxBWZp.js";
-import { r as createFeishuClient } from "./client-BUC-R2Wi.js";
 import { parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
 import { isRecord, normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { convertMarkdownTables } from "openclaw/plugin-sdk/text-chunking";
 import fs from "node:fs";
 import path from "node:path";
-import { mediaKindFromMime } from "openclaw/plugin-sdk/media-mime";
 import { MEDIA_FFMPEG_MAX_AUDIO_DURATION_SECS, runFfmpeg, runFfprobe } from "openclaw/plugin-sdk/media-runtime";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
 import { readRegularFile, writeExternalFileWithinRoot } from "openclaw/plugin-sdk/security-runtime";
 import { Readable } from "node:stream";
+import { mediaKindFromMime } from "openclaw/plugin-sdk/media-mime";
 import { saveMediaBuffer, saveMediaStream } from "openclaw/plugin-sdk/media-store";
 import { resolvePreferredOpenClawTmpDir, withTempDownloadPath, withTempWorkspace } from "openclaw/plugin-sdk/temp-path";
 //#region extensions/feishu/src/identity-header.ts
@@ -50,6 +50,55 @@ function normalizeFeishuExternalKey(value) {
 	return normalized;
 }
 //#endregion
+//#region extensions/feishu/src/media-chunk-idle.ts
+var FeishuInboundMediaTimeoutError = class extends Error {
+	constructor(chunkTimeoutMs) {
+		super(`Feishu media download stalled: no data received for ${chunkTimeoutMs}ms`);
+		this.name = "FeishuInboundMediaTimeoutError";
+		this.chunkTimeoutMs = chunkTimeoutMs;
+	}
+};
+function destroySource(source) {
+	const s = source;
+	if (typeof s.destroy === "function") s.destroy();
+}
+function withChunkIdleTimeout(source, chunkTimeoutMs) {
+	return { async *[Symbol.asyncIterator]() {
+		const iterator = source[Symbol.asyncIterator]();
+		let exhausted = false;
+		try {
+			while (true) {
+				const nextPromise = iterator.next();
+				let timeoutHandle;
+				const timeoutPromise = new Promise((_, reject) => {
+					timeoutHandle = setTimeout(() => {
+						reject(new FeishuInboundMediaTimeoutError(chunkTimeoutMs));
+						try {
+							destroySource(source);
+						} catch {}
+					}, chunkTimeoutMs);
+				});
+				let result;
+				try {
+					result = await Promise.race([nextPromise, timeoutPromise]);
+				} finally {
+					if (timeoutHandle !== void 0) clearTimeout(timeoutHandle);
+				}
+				if (result.done) {
+					exhausted = true;
+					return;
+				}
+				yield result.value;
+			}
+		} finally {
+			if (!exhausted && typeof iterator.return === "function") iterator.return().catch(() => void 0);
+		}
+	} };
+}
+function saveMediaStreamWithIdleTimeout(stream, contentType, maxBytes, fileName, chunkTimeoutMs) {
+	return saveMediaStream(withChunkIdleTimeout(stream, chunkTimeoutMs), contentType, "inbound", maxBytes, fileName);
+}
+//#endregion
 //#region extensions/feishu/src/send-target.ts
 function resolveFeishuSendTarget(params) {
 	const target = params.to.trim();
@@ -177,14 +226,15 @@ async function saveFeishuResponseMedia(params) {
 	if (responseWithOptionalFields.code !== void 0 && responseWithOptionalFields.code !== 0) throw new Error(`${params.errorPrefix}: ${responseWithOptionalFields.msg || `code ${responseWithOptionalFields.code}`}`);
 	if (responseWithOptionalFields.data && Buffer.isBuffer(responseWithOptionalFields.data)) return saveMediaBuffer(responseWithOptionalFields.data, contentType, "inbound", maxBytes, fileName);
 	if (responseWithOptionalFields.data instanceof ArrayBuffer) return saveMediaBuffer(Buffer.from(responseWithOptionalFields.data), contentType, "inbound", maxBytes, fileName);
-	if (typeof response.getReadableStream === "function") return saveMediaStream(response.getReadableStream(), contentType, "inbound", maxBytes, fileName);
+	const save = (stream, ct = contentType, mb = maxBytes, fn = fileName) => saveMediaStreamWithIdleTimeout(stream, ct, mb, fn, FEISHU_MEDIA_HTTP_TIMEOUT_MS);
+	if (typeof response.getReadableStream === "function") return save(response.getReadableStream());
 	if (typeof response.writeFile === "function") return await withTempDownloadPath({ prefix: params.tmpDirPrefix }, async (tmpPath) => {
 		await response.writeFile(tmpPath);
 		if ((await fs.promises.stat(tmpPath)).size > maxBytes) throw mediaLimitError(maxBytes);
-		return await saveMediaStream(fs.createReadStream(tmpPath), contentType, "inbound", maxBytes, fileName);
+		return await save(fs.createReadStream(tmpPath));
 	});
-	if (responseWithOptionalFields[Symbol.asyncIterator]) return saveMediaStream(responseWithOptionalFields, contentType, "inbound", maxBytes, fileName);
-	if (response instanceof Readable) return saveMediaStream(response, contentType, "inbound", maxBytes, fileName);
+	if (responseWithOptionalFields[Symbol.asyncIterator]) return save(responseWithOptionalFields);
+	if (response instanceof Readable) return save(response);
 	const keys = Object.keys(response);
 	throw new Error(`${params.errorPrefix}: unexpected response format. Keys: [${keys.join(", ")}]`);
 }

package/dist/{send-result-CPS7AozW.js → send-result-DsqTk27v.js}

@@ -439,6 +439,13 @@ function canEnumerateAllFeishuPeers(account) {
 //#endregion
 //#region extensions/feishu/src/markdown.ts
 const FEISHU_POST_MAX_BYTES = 30 * 1024;
+/** One parser contract for Feishu message and document Markdown decisions. */
+function parseFeishuMarkdown(text) {
+	return fromMarkdown(text, {
+		extensions: [gfmTable()],
+		mdastExtensions: [gfmTableFromMarkdown()]
+	});
+}
 function buildFeishuPostMentionElements(mentions) {
 	if (!mentions?.length) return [];
 	const elements = [];
@@ -465,10 +472,7 @@ function assertFeishuPostWithinEnvelope(content, label) {
 	if (Buffer.byteLength(content, "utf8") > FEISHU_POST_MAX_BYTES) throw new Error(`${label} exceeds the 30 KB rich-post API limit`);
 }
 function collectSoftBreakOffsets(text) {
-	const root = fromMarkdown(text, {
-		extensions: [gfmTable()],
-		mdastExtensions: [gfmTableFromMarkdown()]
-	});
+	const root = parseFeishuMarkdown(text);
 	const offsets = [];
 	const pending = [root];
 	while (pending.length > 0) {
@@ -763,4 +767,4 @@ function toFeishuSendResult(response, chatId, kind) {
 	};
 }
 //#endregion
-export { FEISHU_CARD_INTERACTION_VERSION as A, resolveFeishuGroupConfig as C, resolveFeishuReplyPolicy as D, resolveFeishuGroupToolPolicy as E, createFeishuCardInteractionEnvelope as M, decodeFeishuCardAction as N, normalizeFeishuChatType as O, resolveFeishuDmIngressAccess as S, resolveFeishuGroupSenderActivationIngressAccess as T, isFeishuGroupReadAllowed as _, readNativeFeishuCardJson as a, hasExplicitFeishuGroupConfig as b, assertFeishuPostWithinEnvelope as c, chunkFeishuPostMarkdown as d, materializeFeishuPostMarkdownSoftBreaks as f, canEnumerateAllFeishuPeers as g, canEnumerateAllFeishuGroups as h, toFeishuSendResult as i, buildFeishuCardActionTextFallback as j, resolveFeishuChatType as k, buildFeishuPostMessageContent as l, authorizeFeishuChatMemberRead as m, createFeishuSendReceipt as n, resolveFeishuCardTemplate as o, assertFeishuChatReadAllowed as p, resolveFeishuReceiptKind as r, sanitizeNativeFeishuCard as s, assertFeishuMessageApiSuccess as t, chunkFeishuMarkdown as u, isFeishuGroupReadEnabled as v, resolveFeishuGroupConversationIngressAccess as w, normalizeFeishuAllowEntry as x, resolveFeishuChatReadPreliminaryAuthorization as y };
+export { resolveFeishuChatType as A, resolveFeishuDmIngressAccess as C, resolveFeishuGroupToolPolicy as D, resolveFeishuGroupSenderActivationIngressAccess as E, buildFeishuCardActionTextFallback as M, createFeishuCardInteractionEnvelope as N, resolveFeishuReplyPolicy as O, decodeFeishuCardAction as P, normalizeFeishuAllowEntry as S, resolveFeishuGroupConversationIngressAccess as T, canEnumerateAllFeishuPeers as _, readNativeFeishuCardJson as a, resolveFeishuChatReadPreliminaryAuthorization as b, assertFeishuPostWithinEnvelope as c, chunkFeishuPostMarkdown as d, materializeFeishuPostMarkdownSoftBreaks as f, canEnumerateAllFeishuGroups as g, authorizeFeishuChatMemberRead as h, toFeishuSendResult as i, FEISHU_CARD_INTERACTION_VERSION as j, normalizeFeishuChatType as k, buildFeishuPostMessageContent as l, assertFeishuChatReadAllowed as m, createFeishuSendReceipt as n, resolveFeishuCardTemplate as o, parseFeishuMarkdown as p, resolveFeishuReceiptKind as r, sanitizeNativeFeishuCard as s, assertFeishuMessageApiSuccess as t, chunkFeishuMarkdown as u, isFeishuGroupReadAllowed as v, resolveFeishuGroupConfig as w, hasExplicitFeishuGroupConfig as x, isFeishuGroupReadEnabled as y };

package/dist/setup-api.js

@@ -1,2 +1,2 @@
-import { i as feishuSetupAdapter, n as feishuSetupWizard, t as feishuPlugin } from "./channel-DdPQ2HGh.js";
+import { i as feishuSetupAdapter, n as feishuSetupWizard, t as feishuPlugin } from "./channel-X30GQVwc.js";
 export { feishuPlugin, feishuSetupAdapter, feishuSetupWizard };