@openclaw/feishu 2026.8.2 → 2026.9.1

package/dist/{monitor.account-CuOAmGJf.js → monitor.account-WFdlCDhR.js}

@@ -1,16 +1,16 @@
 import { o as resolveFeishuAccount, s as resolveFeishuRuntimeAccount } from "./accounts-RwSyseKr.js";
-import { i as resolveReceiveIdType } from "./targets-BUjQ1TcA.js";
-import { A as buildFeishuMediaFallbackText, C as extractMentionTargets, Ct as createFeishuCardInteractionEnvelope, D as parseInteractiveCardContent, E as isFeishuGroupChatType, H as createCommentTypingReactionLifecycle, J as buildFeishuCommentTarget, K as parseCommentContentElements, N as deliverCommentThreadText, O as parsePostContent, Q as resolveFeishuCardTemplate, S as sendStructuredCardFeishu, St as buildFeishuCardActionTextFallback, T as isMentionForwardRequest, U as encodeQuery, W as extractReplyText, Y as normalizeCommentFileType, b as sendCardFeishu, bt as resolveFeishuChatType, c as buildFeishuPresentationFallback, d as resolveFeishuRichReply, dt as hasExplicitFeishuGroupConfig, f as saveMessageResourceFeishu, ft as normalizeFeishuAllowEntry, g as chunkFeishuCardMarkdown, gt as resolveFeishuGroupSenderActivationIngressAccess, h as shouldSuppressFeishuTextForVoiceMedia, ht as resolveFeishuGroupConversationIngressAccess, i as noVisibleFeishuReplyDelivery, j as resolveFeishuIdentityEmoji, mt as resolveFeishuGroupConfig, n as createFeishuReplyDeliveryResult, nt as materializeFeishuPostMarkdownSoftBreaks, p as sendMediaFeishu, pt as resolveFeishuDmIngressAccess, q as requestFeishuApi, r as mergeFeishuReplyDeliveryResults, t as createFeishuPartialReplyDeliveryError, tt as chunkFeishuPostMarkdown, v as getMessageFeishu, vt as resolveFeishuReplyPolicy, w as isFeishuBroadcastMention, wt as decodeFeishuCardAction, x as sendMessageFeishu, y as listFeishuThreadMessages, yt as normalizeFeishuChatType$2 } from "./reply-delivery-result-BIIeISPG.js";
+import { i as resolveReceiveIdType } from "./targets-BTQCYRZQ.js";
+import { $ as parseCommentContentElements, A as isFeishuBroadcastMention, At as decodeFeishuCardAction, B as deliverCommentThreadText, D as sendMessageFeishu, E as sendCardFeishu, Et as resolveFeishuChatType, L as buildFeishuMediaFallbackText, M as isFeishuGroupChatType, N as parseInteractiveCardContent, O as sendStructuredCardFeishu, Ot as buildFeishuCardActionTextFallback, P as parsePostContent, R as resolveFeishuIdentityEmoji, S as chunkFeishuCardMarkdown, St as resolveFeishuGroupSenderActivationIngressAccess, T as listFeishuThreadMessages, Tt as normalizeFeishuChatType$2, X as encodeQuery, Y as createCommentTypingReactionLifecycle, Z as extractReplyText, _ as resolveFeishuRichReply, _t as hasExplicitFeishuGroupConfig, at as resolveFeishuCardTemplate, bt as resolveFeishuGroupConfig, ct as materializeFeishuPostMarkdownSoftBreaks, et as requestFeishuApi, g as renderFeishuReplyPayload, i as noVisibleFeishuReplyDelivery, j as isMentionForwardRequest, k as extractMentionTargets, kt as createFeishuCardInteractionEnvelope, l as buildFeishuPresentationFallback, n as createFeishuReplyDeliveryResult, nt as normalizeCommentFileType, r as mergeFeishuReplyDeliveryResults, st as chunkFeishuPostMarkdown, t as createFeishuPartialReplyDeliveryError, tt as buildFeishuCommentTarget, u as consumeFeishuPresentationFallbackMarker, v as saveMessageResourceFeishu, vt as normalizeFeishuAllowEntry, w as getMessageFeishu, wt as resolveFeishuReplyPolicy, x as shouldSuppressFeishuTextForVoiceMedia, xt as resolveFeishuGroupConversationIngressAccess, y as sendMediaFeishu, yt as resolveFeishuDmIngressAccess } from "./reply-delivery-result-CEFTDA3f.js";
 import { a as normalizeFeishuWebhookPath, o as normalizeFeishuExternalKey } from "./doctor-contract-CQAuBotF.js";
 import { o as resolveConfiguredFeishuGroupSessionScope, t as buildFeishuConversationId } from "./conversation-id-VYgGQ-GX.js";
-import { a as getFeishuUserAgent, i as createFeishuWSClient, n as createEventDispatcher, r as createFeishuClient, s as resolveConfiguredHttpTimeoutMs } from "./client-vJJyfkxI.js";
+import { a as getFeishuUserAgent, i as createFeishuWSClient, n as createEventDispatcher, r as createFeishuClient, s as resolveConfiguredHttpTimeoutMs } from "./client-DMbIL3UH.js";
 import { t as getFeishuRuntime } from "./runtime-C5JxBWZp.js";
-import { r as getChatInfo } from "./chat-Cbr7P_JH.js";
+import { r as getChatInfo } from "./chat-CxXaPTuO.js";
 import { t as createFeishuThreadBindingManager } from "./thread-bindings-BiL1wGqK.js";
 import { evaluateSupplementalContextVisibility, normalizeAgentId as normalizeAgentId$1, resolveChannelContextVisibilityMode } from "./runtime-api.js";
 import { t as readFeishuJsonResponse } from "./json-response-DXajw_FU.js";
-import { a as waitForAbortableDelay, i as raceWithTimeoutAndAbort } from "./probe-Cs1s-qSS.js";
-import { t as fetchBotIdentityForMonitor } from "./monitor-BVYpA9SO.js";
+import { a as waitForAbortableDelay, i as raceWithTimeoutAndAbort } from "./probe-D_SatdZl.js";
+import { t as fetchBotIdentityForMonitor } from "./monitor-DoMmOfaD.js";
 import { resolveAgentConfig } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { DEFAULT_INGRESS_ADOPTION_STALL_MS, bindIngressLifecycleToReplyOptions, createChannelIngressError, createChannelIngressMonitor, createChannelMessageReplyPipeline, createReplyPrefixContext, formatChannelProgressDraftLineForEntry, isChannelProgressDraftWorkToolName, resolveAgentOutboundIdentity, resolveChannelPreviewStreamMode, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
 import { createChannelPairingController } from "openclaw/plugin-sdk/channel-pairing";
@@ -1620,21 +1620,10 @@ var FeishuStreamingSession = class {
 		if (finalWriteError !== void 0 || closeError !== void 0) throw new FeishuStreamingFinalizationError(finalWriteError !== void 0 && closeError !== void 0 ? new AggregateError([finalWriteError, closeError], "Feishu streaming card finalization failed") : finalWriteError ?? closeError, result);
 		return result;
 	}
-	async close(finalText, options) {
-		try {
-			return (await this.closeWithResult(finalText, options)).visibleReplySent;
-		} catch (error) {
-			if (error instanceof FeishuStreamingFinalizationError) return error.result.visibleReplySent;
-			throw error;
-		}
-	}
 	async discard() {
-		if (!this.state || this.closed) return;
+		if (!this.state || this.closed) return { visibleReplySent: false };
 		const { cardId, messageId } = this.state;
-		if (!messageId) {
-			await this.close("");
-			return;
-		}
+		if (!messageId) return this.closeWithResult("");
 		this.closed = true;
 		this.clearFlushTimer();
 		await this.queue;
@@ -1644,10 +1633,11 @@ var FeishuStreamingSession = class {
 			this.state = null;
 			this.pendingText = null;
 			this.log?.(`Discarded streaming card: cardId=${cardId}`);
+			return { visibleReplySent: false };
 		} catch (error) {
 			this.log?.(`Discard failed: ${String(error)}`);
 			this.closed = false;
-			await this.close("");
+			return this.closeWithResult("");
 		}
 	}
 	isActive() {
@@ -1905,9 +1895,7 @@ function createFeishuReplyDispatcher(params) {
 	let activeStreamingGeneration;
 	let inFlightStreamingClose;
 	let visibleReplySent = false;
-	let skippedFinalReason = null;
-	let skippedFinalAssistantMessageIndex;
-	let preparedDeliveryAssistantMessageIndex;
+	let replyOutcome;
 	let idleSideEffectsPromise = Promise.resolve();
 	let activeIdleSideEffectsPromise = null;
 	let idleRequestedForReply = false;
@@ -2007,97 +1995,86 @@ function createFeishuReplyDispatcher(params) {
 		lastSnapshotTextLength = 0;
 		hasStreamingFinalText = false;
 	};
-	const rememberClosedStreamingSettlement = (generation, content, result, error) => {
-		if (generation === void 0 || !content) return;
+	const rememberClosedStreamingSettlement = (generation, content, result, error, disposition = "closed") => {
+		if (generation === void 0 || !content && disposition === "closed") return;
 		closedStreamingSettlements.set(generation, {
+			disposition,
 			result,
 			content,
 			...error === void 0 ? {} : { error }
 		});
 	};
-	const performStreamingClose = async () => {
+	const performStreamingClose = async (disposition) => {
 		const streamingToClose = streaming;
 		const generationToClose = activeStreamingGeneration;
 		const startPromiseToClose = streamingStartPromise;
 		const updateQueueToClose = partialUpdateQueue;
 		const finalizedAnswerText = streamText;
 		const finalizedReasoningText = reasoningText;
+		const outcome = {
+			disposition,
+			...generationToClose === void 0 ? {} : { generation: generationToClose }
+		};
 		if (generationToClose !== void 0 && activeStreamingGeneration === generationToClose) activeStreamingGeneration = void 0;
 		try {
 			if (startPromiseToClose) await startPromiseToClose;
 			await updateQueueToClose;
+			let result = noVisibleFeishuReplyDelivery;
+			let finalizationError;
 			if (streamingToClose?.isActive()) {
 				statusLine = "";
 				const text = buildCombinedStreamText(finalizedReasoningText, finalizedAnswerText);
-				const finalNote = resolveCardNote(agentId, identity, responsePrefixContextProvider());
 				let closed;
 				try {
-					closed = await streamingToClose.closeWithResult(text, { note: finalNote });
+					if (disposition === "discarded") closed = await streamingToClose.discard();
+					else {
+						const finalNote = resolveCardNote(agentId, identity, responsePrefixContextProvider());
+						closed = await streamingToClose.closeWithResult(text, { note: finalNote });
+					}
 				} catch (error) {
 					if (!(error instanceof FeishuStreamingFinalizationError)) throw error;
-					const failedResult = createFeishuReplyDeliveryResult({
-						results: [error.result],
-						visibleReplySent: error.result.visibleReplySent,
-						content: error.result.content,
-						kind: "card"
-					});
-					if (failedResult.visibleReplySent) markVisibleReplySent();
-					if (failedResult.visibleReplySent && finalizedAnswerText) {
-						const partialError = createFeishuPartialReplyDeliveryError(error.cause ?? error, failedResult);
-						if (failedResult.content === text) deliveredFinalTexts.add(finalizedAnswerText);
-						rememberClosedStreamingSettlement(generationToClose, finalizedAnswerText, failedResult, partialError);
-						return {
-							result: failedResult,
-							...generationToClose === void 0 ? {} : { generation: generationToClose },
-							error: partialError
-						};
-					}
-					rememberClosedStreamingSettlement(generationToClose, finalizedAnswerText, failedResult, error);
-					return {
-						result: failedResult,
-						...generationToClose === void 0 ? {} : { generation: generationToClose },
-						error
-					};
+					closed = error.result;
+					finalizationError = error;
 				}
-				const result = createFeishuReplyDeliveryResult({
+				result = createFeishuReplyDeliveryResult({
 					results: [closed],
 					visibleReplySent: closed.visibleReplySent,
 					content: closed.content,
 					kind: "card"
 				});
 				if (result.visibleReplySent) markVisibleReplySent();
-				if (result.visibleReplySent && finalizedAnswerText) {
-					deliveredFinalTexts.add(finalizedAnswerText);
-					rememberClosedStreamingSettlement(generationToClose, finalizedAnswerText, result);
-				}
-				return {
-					result,
-					...generationToClose === void 0 ? {} : { generation: generationToClose }
-				};
+				if (disposition === "closed" && result.visibleReplySent && finalizedAnswerText && (finalizationError === void 0 || result.content === text)) deliveredFinalTexts.add(finalizedAnswerText);
+				if (finalizationError instanceof FeishuStreamingFinalizationError && result.visibleReplySent) finalizationError = createFeishuPartialReplyDeliveryError(finalizationError.cause ?? finalizationError, result);
 			}
+			if (disposition === "discarded" || finalizationError !== void 0 || result.visibleReplySent && finalizedAnswerText) rememberClosedStreamingSettlement(generationToClose, finalizedAnswerText, result, finalizationError, disposition);
 			return {
-				result: noVisibleFeishuReplyDelivery,
-				...generationToClose === void 0 ? {} : { generation: generationToClose }
+				...outcome,
+				result,
+				...finalizationError === void 0 ? {} : { error: finalizationError }
 			};
 		} catch (error) {
+			if (disposition === "discarded") rememberClosedStreamingSettlement(generationToClose, finalizedAnswerText, noVisibleFeishuReplyDelivery, error, disposition);
 			return {
+				...outcome,
 				result: noVisibleFeishuReplyDelivery,
-				...generationToClose === void 0 ? {} : { generation: generationToClose },
 				error
 			};
 		} finally {
 			if (streaming === streamingToClose) resetStreamingState();
 		}
 	};
-	const closeStreaming = () => {
+	const closeStreaming = (disposition = "closed") => {
+		const session = streaming;
 		const generation = activeStreamingGeneration;
-		if (generation !== void 0 && inFlightStreamingClose?.generation === generation) return inFlightStreamingClose.promise;
+		if (session && inFlightStreamingClose?.session === session) return inFlightStreamingClose.promise;
 		const content = streamText;
-		const closePromise = performStreamingClose();
-		if (generation !== void 0) {
+		const closePromise = performStreamingClose(disposition);
+		if (session && generation !== void 0) {
 			const closing = {
+				session,
 				generation,
 				content,
+				disposition,
 				promise: closePromise
 			};
 			inFlightStreamingClose = closing;
@@ -2129,13 +2106,12 @@ function createFeishuReplyDispatcher(params) {
 		};
 	};
 	const discardStreamingPreview = async () => {
-		try {
-			if (streamingStartPromise) await streamingStartPromise;
-			await partialUpdateQueue;
-			if (streaming?.isActive()) await streaming.discard();
-		} finally {
+		if (streaming && inFlightStreamingClose?.session === streaming && inFlightStreamingClose.disposition === "closed") {
 			resetStreamingState();
+			return;
 		}
+		const outcome = await closeStreaming("discarded");
+		if (outcome.error !== void 0) throw toStringifiedError(outcome.error);
 	};
 	const updateStreamingStatusLine = (nextStatusLine, options) => {
 		statusLine = nextStatusLine;
@@ -2198,27 +2174,28 @@ function createFeishuReplyDispatcher(params) {
 			kind: paramsLocal.useCard ? "card" : "text"
 		});
 	};
+	const sendPostReply = (text, infoKind, firstChunkMentions) => sendChunkedTextReply({
+		text,
+		useCard: false,
+		infoKind,
+		firstChunkMentions,
+		chunkMentions: requiredMentionTargets,
+		sendChunk: ({ chunk, mentions }) => sendMessageFeishu({
+			cfg,
+			to: sendTarget,
+			text: chunk,
+			replyToMessageId: sendReplyToMessageId,
+			replyInThread: effectiveReplyInThread,
+			allowTopLevelReplyFallback,
+			accountId,
+			...mentions ? { mentions } : {}
+		})
+	});
 	const sendMediaReplies = async (payload, options) => {
 		const mediaUrls = resolveSendableOutboundReplyParts(payload).mediaUrls;
 		let sentFallbackText = false;
 		let degradedVoiceFallbackText;
 		const results = [];
-		const sendFallbackText = async (text) => await sendChunkedTextReply({
-			text,
-			useCard: false,
-			infoKind: "final",
-			chunkMentions: requiredMentionTargets,
-			sendChunk: async ({ chunk, mentions }) => await sendMessageFeishu({
-				cfg,
-				to: sendTarget,
-				text: chunk,
-				replyToMessageId: sendReplyToMessageId,
-				replyInThread: effectiveReplyInThread,
-				allowTopLevelReplyFallback,
-				accountId,
-				...mentions ? { mentions } : {}
-			})
-		});
 		try {
 			await sendMediaWithLeadingCaption({
 				mediaUrls,
@@ -2252,12 +2229,12 @@ function createFeishuReplyDispatcher(params) {
 						mediaUrl
 					});
 					sentFallbackText = true;
-					results.push(await sendFallbackText(fallbackText));
+					results.push(await sendPostReply(fallbackText, "final"));
 				}
 			});
 			if (degradedVoiceFallbackText && !sentFallbackText) {
 				sentFallbackText = true;
-				results.push(await sendFallbackText(degradedVoiceFallbackText));
+				results.push(await sendPostReply(degradedVoiceFallbackText, "final"));
 			}
 		} catch (error) {
 			const partial = isChannelPartialDeliveryError(error) ? error.deliveryResult : void 0;
@@ -2269,8 +2246,8 @@ function createFeishuReplyDispatcher(params) {
 	const ensureNoVisibleReplyFallback = async (reason) => {
 		await idleSideEffectsPromise;
 		if (visibleReplySent) return false;
-		if (skippedFinalReason === "silent") {
-			params.runtime.log?.(`feishu[${account.accountId}]: no-visible-reply fallback skipped for intentional silence (${reason})`);
+		if (replyOutcome?.kind === "suppressed" || replyOutcome?.kind === "skipped" && replyOutcome.reason === "silent") {
+			params.runtime.log?.(`feishu[${account.accountId}]: no-visible-reply fallback skipped for ${replyOutcome.reason} (${reason})`);
 			return false;
 		}
 		await sendMessageFeishu({
@@ -2344,10 +2321,17 @@ function createFeishuReplyDispatcher(params) {
 					if (completions.some((completion) => ownsCurrentClose(completion))) markClosedStreamingContentClaimed(closeOutcome.generation);
 					for (const completion of completions) {
 						const claimedSettlement = ownsCurrentClose(completion) ? {
+							disposition: closeOutcome.disposition,
 							result: finalized,
 							...closeOutcome.error === void 0 ? {} : { error: closeOutcome.error }
 						} : claimClosedStreamingResult(completion.streamingGeneration, completion.result.content);
 						const deliveryError = claimedSettlement?.error;
+						if (claimedSettlement?.disposition === "discarded") {
+							const retained = mergeFeishuReplyDeliveryResults([claimedSettlement.result, completion.result], claimedSettlement.result.content ?? "");
+							if (deliveryError !== void 0) completion.reject(createFeishuPartialReplyDeliveryError(deliveryError, retained));
+							else completion.resolve(retained);
+							continue;
+						}
 						let providerFinalized = claimedSettlement?.result;
 						try {
 							providerFinalized = await ensureVisibleStreamingDelivery(providerFinalized, completion.result.content, completion.infoKind);
@@ -2384,22 +2368,16 @@ function createFeishuReplyDispatcher(params) {
 		let finalized = noVisibleFeishuReplyDelivery;
 		let finalizationError;
 		let fallbackPartial;
-		const claimedSettlement = claimClosedStreamingResult(paramsLocal.ownerGeneration, paramsLocal.content);
-		if (claimedSettlement) {
-			finalized = claimedSettlement.result;
-			finalizationError = claimedSettlement.error;
-		} else if (paramsLocal.ownerGeneration !== void 0 && inFlightStreamingClose?.generation === paramsLocal.ownerGeneration) {
+		let settlement = claimClosedStreamingResult(paramsLocal.ownerGeneration, paramsLocal.content);
+		if (!settlement && paramsLocal.ownerGeneration !== void 0 && inFlightStreamingClose?.generation === paramsLocal.ownerGeneration) {
 			const closeOutcome = await inFlightStreamingClose.promise;
-			const completedSettlement = claimClosedStreamingResult(paramsLocal.ownerGeneration, paramsLocal.content);
-			finalized = completedSettlement?.result ?? closeOutcome?.result ?? finalized;
-			finalizationError = completedSettlement?.error ?? closeOutcome?.error;
-		} else if (paramsLocal.ownerGeneration !== void 0 && activeStreamingGeneration === paramsLocal.ownerGeneration) {
-			const closeOutcome = await closeStreaming();
-			finalized = closeOutcome.result;
-			finalizationError = closeOutcome.error;
-		}
+			settlement = claimClosedStreamingResult(paramsLocal.ownerGeneration, paramsLocal.content) ?? closeOutcome;
+		} else if (!settlement && paramsLocal.ownerGeneration !== void 0 && activeStreamingGeneration === paramsLocal.ownerGeneration) settlement = await closeStreaming();
+		finalized = settlement?.result ?? finalized;
+		finalizationError = settlement?.error;
+		const discarded = settlement?.disposition === "discarded";
 		try {
-			finalized = await ensureVisibleStreamingDelivery(finalized, paramsLocal.content, paramsLocal.infoKind) ?? finalized;
+			if (!discarded) finalized = await ensureVisibleStreamingDelivery(finalized, paramsLocal.content, paramsLocal.infoKind) ?? finalized;
 		} catch (fallbackError) {
 			fallbackPartial = isChannelPartialDeliveryError(fallbackError) ? fallbackError.deliveryResult : void 0;
 			const fallbackCause = fallbackPartial && fallbackError instanceof Error ? fallbackError.cause ?? fallbackError : fallbackError;
@@ -2410,7 +2388,7 @@ function createFeishuReplyDispatcher(params) {
 			finalized,
 			...fallbackPartial ? [fallbackPartial] : [],
 			...mediaPartial ? [mediaPartial] : []
-		], fallbackPartial?.visibleReplySent === true ? fallbackPartial.content : finalized.visibleReplySent === true ? finalized.content : paramsLocal.content);
+		], discarded ? finalized.content ?? "" : fallbackPartial?.visibleReplySent === true ? fallbackPartial.content : finalized.visibleReplySent === true ? finalized.content : paramsLocal.content);
 		const mediaCause = mediaPartial && paramsLocal.error instanceof Error ? paramsLocal.error.cause ?? paramsLocal.error : paramsLocal.error;
 		const cause = finalizationError ? new AggregateError([mediaCause, finalizationError instanceof Error ? finalizationError.cause ?? finalizationError : finalizationError], "Feishu reply delivery and streaming finalization failed") : mediaCause;
 		throw createFeishuPartialReplyDeliveryError(cause, accepted);
@@ -2426,13 +2404,14 @@ function createFeishuReplyDispatcher(params) {
 			conversationType: chatId.startsWith("oc_") ? "group" : "direct"
 		},
 		onSkip: (_payload, info) => {
-			if (info.kind === "final" || info.kind === "block" && info.reason === "silent") {
-				skippedFinalReason = info.reason;
-				skippedFinalAssistantMessageIndex = info.assistantMessageIndex;
-			}
+			if (replyOutcome?.kind !== "failed" && (info.kind === "final" || info.kind === "block" && info.reason === "silent")) replyOutcome = {
+				kind: "skipped",
+				reason: info.reason,
+				assistantMessageIndex: info.assistantMessageIndex
+			};
 		},
 		beforeDeliver: (payload, info) => {
-			preparedDeliveryAssistantMessageIndex = info.assistantMessageIndex;
+			if (!(replyOutcome?.kind === "skipped" && replyOutcome.reason === "silent" && info.kind !== "final" && replyOutcome.assistantMessageIndex !== void 0 && info.assistantMessageIndex !== void 0 && info.assistantMessageIndex < replyOutcome.assistantMessageIndex) && replyOutcome?.kind !== "failed") replyOutcome = void 0;
 			return payload;
 		},
 		onReplyStart: async () => {
@@ -2443,9 +2422,7 @@ function createFeishuReplyDispatcher(params) {
 				sentIndependentBlockText = false;
 				idleRequestedForReply = false;
 				visibleReplySent = false;
-				skippedFinalReason = null;
-				skippedFinalAssistantMessageIndex = void 0;
-				preparedDeliveryAssistantMessageIndex = void 0;
+				replyOutcome = void 0;
 			}
 			if (previewStreamingEnabled && renderMode === "card") startStreaming();
 			await Promise.resolve(typingCallbacks?.onReplyStart?.());
@@ -2456,6 +2433,7 @@ function createFeishuReplyDispatcher(params) {
 		}
 	};
 	const handleDeliveryError = async (error, info) => {
+		if (info.kind === "final") replyOutcome = { kind: "failed" };
 		if (isChannelPartialDeliveryError(error)) markVisibleReplySent();
 		params.runtime.error?.(`feishu[${account.accountId}] ${info.kind} reply failed: ${String(error)}`);
 		await queueIdleSideEffects().catch((cleanupError) => params.runtime.error?.(`feishu[${account.accountId}] reply error cleanup failed: ${String(cleanupError)}`));
@@ -2464,19 +2442,36 @@ function createFeishuReplyDispatcher(params) {
 		dispatcherOptions,
 		delivery: {
 			observeMessageSent: true,
-			deliver: async (payload, info) => {
-				const deliveryAssistantMessageIndex = preparedDeliveryAssistantMessageIndex;
-				preparedDeliveryAssistantMessageIndex = void 0;
-				if (info?.kind === "final" || skippedFinalReason !== "silent" || skippedFinalAssistantMessageIndex === void 0 || deliveryAssistantMessageIndex === void 0 || deliveryAssistantMessageIndex >= skippedFinalAssistantMessageIndex) {
-					skippedFinalReason = null;
-					skippedFinalAssistantMessageIndex = void 0;
+			onDelivered: (_payload, info, result) => {
+				if (result?.visibleReplySent) {
+					markVisibleReplySent();
+					if (info.kind === "final") replyOutcome = void 0;
+					return;
 				}
-				const payloadText = payload.isReasoning && payload.text ? formatReasoningMessage(payload.text) : payload.text;
+				const reason = result?.suppression?.reason;
+				if (info.kind === "final" && replyOutcome?.kind !== "failed" && (reason === "cancelled_by_reply_payload_sending_hook" || reason === "empty_after_reply_payload_sending_hook" || reason === "cancelled_by_message_sending_hook" || reason === "empty_after_message_sending_hook" || reason === "channel_transform")) replyOutcome = {
+					kind: "suppressed",
+					reason
+				};
+			},
+			deliver: async (inputPayload, info) => {
+				const prepared = await renderFeishuReplyPayload(inputPayload, {
+					to: sendTarget,
+					identity,
+					mentions: requiredMentionTargets
+				});
+				const rendered = consumeFeishuPresentationFallbackMarker(prepared.payload);
+				const payload = rendered.payload;
+				const presentationCard = prepared.card;
+				const hasPresentationFallback = rendered.presentationFallback?.hasVisibleContent === true;
+				const hasIndependentPresentation = presentationCard !== void 0 || hasPresentationFallback;
+				const resolvedText = payload.text;
+				const payloadText = payload.isReasoning && resolvedText ? formatReasoningMessage(resolvedText) : resolvedText;
 				const reply = resolveSendableOutboundReplyParts({
 					...payload,
 					text: payloadText
 				});
-				const text = info?.kind === "final" ? mergeStreamingFinalText(streamText, reply.text, payload.isError === true && hasStreamingFinalText) : reply.text;
+				const text = info?.kind === "final" && !hasIndependentPresentation ? mergeStreamingFinalText(streamText, reply.text, payload.isError === true && hasStreamingFinalText) : reply.text;
 				const hasText = reply.hasText;
 				const hasMedia = reply.hasMedia;
 				const ttsSupplement = getReplyPayloadTtsSupplement(payload);
@@ -2490,52 +2485,61 @@ function createFeishuReplyDispatcher(params) {
 				const useStaticCard = hasText && (renderMode === "card" || info?.kind === "block" && coreBlockStreamingEnabled && renderMode !== "raw" || renderMode === "auto" && shouldUseCard(text));
 				const useStreamingCard = hasText && streamingEnabled && !finalTextExceedsStreamingLimit && (info?.kind === "final" || useStaticCard);
 				const useCard = useStaticCard || useStreamingCard;
-				const skipTextForDuplicateFinal = info?.kind === "final" && hasText && deliveredFinalTexts.has(text);
-				const shouldDeliverText = hasText && !hasVoiceMedia && !skipTextForDuplicateFinal;
-				const shouldDiscardStreamingPreview = info?.kind === "final" && (finalTextExceedsStreamingLimit || hasMedia && (hasVoiceMedia && !shouldDeliverText && !ttsTextAlreadyVisible || skipTextForDuplicateFinal));
+				const skipTextForDuplicateFinal = !hasIndependentPresentation && info?.kind === "final" && hasText && deliveredFinalTexts.has(text);
+				const shouldDeliverText = hasText && (!hasVoiceMedia || hasPresentationFallback) && !skipTextForDuplicateFinal;
+				const shouldDiscardStreamingPreview = info?.kind === "final" && !(hasIndependentPresentation && payload.isError === true && hasStreamingFinalText) && (hasIndependentPresentation || finalTextExceedsStreamingLimit || hasMedia && (hasVoiceMedia && !shouldDeliverText && !ttsTextAlreadyVisible || skipTextForDuplicateFinal));
 				const priorClosedStreamingSettlement = info?.kind === "final" && hasText && skipTextForDuplicateFinal ? claimClosedStreamingResult(void 0, text) : void 0;
-				if (!shouldDeliverText && !hasMedia) {
+				if (!shouldDeliverText && !hasMedia && !presentationCard) {
 					if (priorClosedStreamingSettlement?.error !== void 0) throw toStringifiedError(priorClosedStreamingSettlement.error);
 					return priorClosedStreamingSettlement?.result ?? noVisibleFeishuReplyDelivery;
 				}
 				const deliveredResults = priorClosedStreamingSettlement ? [priorClosedStreamingSettlement.result] : [];
-				const collectMediaDelivery = async (mediaPayload, mediaOptions) => {
+				const collectDelivery = async (pending, acceptedContent) => {
 					try {
-						deliveredResults.push(await sendMediaReplies(mediaPayload, mediaOptions));
+						deliveredResults.push(await pending);
 					} catch (error) {
 						const partial = isChannelPartialDeliveryError(error) ? error.deliveryResult : void 0;
-						const accumulated = mergeFeishuReplyDeliveryResults([...deliveredResults, ...partial ? [partial] : []]);
-						throw createFeishuPartialReplyDeliveryError(partial && error instanceof Error ? error.cause ?? error : error, accumulated);
+						const accumulated = mergeFeishuReplyDeliveryResults([...deliveredResults, ...partial ? [{
+							...partial,
+							content: partial.content ?? acceptedContent
+						}] : []]);
+						throw createFeishuPartialReplyDeliveryError(partial && error instanceof Error ? error.cause ?? error : error, {
+							...accumulated,
+							content: accumulated.content ?? ""
+						});
 					}
 				};
 				if (shouldDiscardStreamingPreview) await discardStreamingPreview();
+				if (presentationCard) {
+					if (hasMedia) await collectDelivery(sendMediaReplies(payload));
+					await collectDelivery(sendCardFeishu({
+						cfg,
+						to: sendTarget,
+						card: presentationCard,
+						replyToMessageId: sendReplyToMessageId,
+						replyInThread: effectiveReplyInThread,
+						allowTopLevelReplyFallback,
+						accountId
+					}).then((result) => createFeishuReplyDeliveryResult({
+						results: [result],
+						visibleReplySent: true,
+						content: resolvedText,
+						kind: "card"
+					})), resolvedText);
+					markVisibleReplySent();
+					return mergeFeishuReplyDeliveryResults(deliveredResults, resolvedText);
+				}
 				if (shouldDeliverText) {
-					if (info?.kind === "block") {
-						if (!useStreamingCard) {
-							if (coreBlockStreamingEnabled) {
-								const firstChunkMentions = !sentIndependentBlockText && mentionTargets?.length ? mentionTargets : void 0;
-								deliveredResults.push(await sendChunkedTextReply({
-									text,
-									useCard: false,
-									infoKind: "block",
-									firstChunkMentions,
-									chunkMentions: requiredMentionTargets,
-									sendChunk: async ({ chunk, mentions }) => await sendMessageFeishu({
-										cfg,
-										to: sendTarget,
-										text: chunk,
-										replyToMessageId: sendReplyToMessageId,
-										replyInThread: effectiveReplyInThread,
-										allowTopLevelReplyFallback,
-										accountId,
-										...mentions ? { mentions } : {}
-									})
-								}));
-								sentIndependentBlockText = true;
-								if (hasMedia) await collectMediaDelivery(payload);
-							}
-							return mergeFeishuReplyDeliveryResults(deliveredResults, text);
+					if (hasPresentationFallback || info?.kind === "block" && !useStreamingCard) {
+						if (hasPresentationFallback || coreBlockStreamingEnabled) {
+							const firstChunkMentions = info?.kind === "final" || info?.kind === "block" && !sentIndependentBlockText ? mentionTargets : void 0;
+							await collectDelivery(sendPostReply(text, info?.kind, firstChunkMentions));
+							if (info?.kind === "block") sentIndependentBlockText = true;
+							if (hasMedia) await collectDelivery(sendMediaReplies(payload));
 						}
+						return mergeFeishuReplyDeliveryResults(deliveredResults, text);
+					}
+					if (info?.kind === "block") {
 						startStreaming();
 						if (streamingStartPromise) await streamingStartPromise;
 					}
@@ -2544,7 +2548,7 @@ function createFeishuReplyDispatcher(params) {
 						if (streamingStartPromise) await streamingStartPromise;
 					}
 					const shouldStreamText = info?.kind === "block" || info?.kind === "final";
-					const matchingInFlightClose = info?.kind === "final" && inFlightStreamingClose?.content === text ? inFlightStreamingClose : void 0;
+					const matchingInFlightClose = info?.kind === "final" && inFlightStreamingClose?.disposition === "closed" && inFlightStreamingClose.content === text ? inFlightStreamingClose : void 0;
 					const ownerGeneration = activeStreamingGeneration ?? matchingInFlightClose?.generation;
 					if (shouldStreamText && ownerGeneration !== void 0 && (streaming?.isActive() || matchingInFlightClose !== void 0)) {
 						if (activeStreamingGeneration !== void 0) {
@@ -2561,7 +2565,7 @@ function createFeishuReplyDispatcher(params) {
 							}
 						}
 						if (hasMedia) try {
-							await collectMediaDelivery(payload);
+							await collectDelivery(sendMediaReplies(payload));
 						} catch (error) {
 							await throwStreamingDeliveryFailure({
 								error,
@@ -2597,26 +2601,10 @@ function createFeishuReplyDispatcher(params) {
 						}));
 					} else {
 						const firstChunkMentions = info?.kind === "final" && mentionTargets?.length ? mentionTargets : void 0;
-						deliveredResults.push(await sendChunkedTextReply({
-							text,
-							useCard: false,
-							infoKind: info?.kind,
-							firstChunkMentions,
-							chunkMentions: requiredMentionTargets,
-							sendChunk: async ({ chunk, mentions }) => await sendMessageFeishu({
-								cfg,
-								to: sendTarget,
-								text: chunk,
-								replyToMessageId: sendReplyToMessageId,
-								replyInThread: effectiveReplyInThread,
-								allowTopLevelReplyFallback,
-								accountId,
-								...mentions ? { mentions } : {}
-							})
-						}));
+						deliveredResults.push(await sendPostReply(text, info?.kind, firstChunkMentions));
 					}
 				}
-				if (hasMedia) await collectMediaDelivery(payload, !ttsTextAlreadyVisible && hasVoiceMedia && hasText ? { fallbackText: text } : void 0);
+				if (hasMedia) await collectDelivery(sendMediaReplies(payload, !shouldDeliverText && !ttsTextAlreadyVisible && hasVoiceMedia && hasText ? { fallbackText: text } : void 0));
 				const deliveredContent = hasVoiceMedia ? deliveredResults.at(-1)?.content ?? text : text;
 				const result = mergeFeishuReplyDeliveryResults(deliveredResults, deliveredContent);
 				if (priorClosedStreamingSettlement?.error !== void 0) throw createFeishuPartialReplyDeliveryError(isChannelPartialDeliveryError(priorClosedStreamingSettlement.error) && priorClosedStreamingSettlement.error instanceof Error ? priorClosedStreamingSettlement.error.cause ?? priorClosedStreamingSettlement.error : priorClosedStreamingSettlement.error, result);
@@ -2666,7 +2654,7 @@ function createFeishuReplyDispatcher(params) {
 		ensureNoVisibleReplyFallback,
 		getVisibleReplyState: () => ({
 			visibleReplySent,
-			skippedFinalReason
+			skippedFinalReason: replyOutcome?.kind === "skipped" || replyOutcome?.kind === "suppressed" ? replyOutcome.reason : null
 		})
 	};
 }

package/dist/{probe-Cs1s-qSS.js → probe-D_SatdZl.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { r as createFeishuClient } from "./client-vJJyfkxI.js";
+import { r as createFeishuClient } from "./client-DMbIL3UH.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { asDateTimestampMs, resolveExpiresAtMsFromDurationMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { createHash } from "node:crypto";