@openclaw/discord 2026.7.1 → 2026.7.2-beta.2

package/dist/{message-handler-DcgvugZt.js → message-handler-DExaghWK.js}

@@ -1,24 +1,22 @@
-import { I as createDiscordRestClient } from "./send.shared-wAwMhHDN.js";
-import { o as mergeAbortSignals } from "./timeouts-C5TBc_9x.js";
-import { d as resolveDiscordChannelNameSafe, l as resolveDiscordChannelIdSafe, p as resolveDiscordChannelParentSafe, u as resolveDiscordChannelInfoSafe } from "./thread-bindings.discord-api-BjIf9lGs.js";
-import { c as hasDiscordMessageStickers, d as resolveDiscordMessageChannelId, r as resolveDiscordMessageText } from "./message-utils-B_3yA5bN.js";
-import { t as sendTyping } from "./typing-BVcJgILg.js";
-import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { finiteSecondsToTimerSafeMilliseconds } from "openclaw/plugin-sdk/number-runtime";
-import { danger, logVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { d as resolveDiscordChannelNameSafe, l as resolveDiscordChannelIdSafe, p as resolveDiscordChannelParentSafe, u as resolveDiscordChannelInfoSafe } from "./thread-bindings.discord-api-DXfXsHGZ.js";
+import { c as hasDiscordMessageStickers, d as resolveDiscordMessageChannelId, r as resolveDiscordMessageText } from "./message-utils-BU3gc01v.js";
+import { danger } from "openclaw/plugin-sdk/runtime-env";
 import { resolveBatchedReplyThreadingPolicy } from "openclaw/plugin-sdk/reply-reference";
-import { createChannelRunQueue, createTypingCallbacks, resolveChannelMessageSourceReplyDeliveryMode } from "openclaw/plugin-sdk/channel-outbound";
+import { createChannelRunQueue } from "openclaw/plugin-sdk/channel-outbound";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { resolveOpenProviderRuntimeGroupPolicy } from "openclaw/plugin-sdk/runtime-group-policy";
 import { createChannelInboundDebouncer, shouldDebounceTextInbound } from "openclaw/plugin-sdk/channel-inbound";
-import { createClaimableDedupe } from "openclaw/plugin-sdk/persistent-dedupe";
-import { logTypingFailure } from "openclaw/plugin-sdk/channel-feedback";
+import { createChannelReplayGuard } from "openclaw/plugin-sdk/persistent-dedupe";
 //#region extensions/discord/src/monitor/inbound-dedupe.ts
 const RECENT_DISCORD_MESSAGE_TTL_MS = 5 * 6e4;
 const RECENT_DISCORD_MESSAGE_MAX = 5e3;
 function createDiscordInboundReplayGuard() {
-	return createClaimableDedupe({
-		ttlMs: RECENT_DISCORD_MESSAGE_TTL_MS,
-		memoryMaxSize: RECENT_DISCORD_MESSAGE_MAX
+	return createChannelReplayGuard({
+		dedupe: {
+			ttlMs: RECENT_DISCORD_MESSAGE_TTL_MS,
+			memoryMaxSize: RECENT_DISCORD_MESSAGE_MAX
+		},
+		buildReplayKey: (keys) => keys
 	});
 }
 var DiscordRetryableInboundError = class extends Error {
@@ -37,21 +35,6 @@ function buildDiscordInboundReplayKey(params) {
 	if (!channelId) return null;
 	return `${params.accountId}:${channelId}:${messageId}`;
 }
-async function claimDiscordInboundReplay(params) {
-	const replayKey = params.replayKey?.trim();
-	if (!replayKey) return true;
-	return (await params.replayGuard.claim(replayKey)).kind === "claimed";
-}
-async function commitDiscordInboundReplay(params) {
-	const replayKeys = normalizeDiscordInboundReplayKeys(params.replayKeys);
-	await Promise.all(replayKeys.map((replayKey) => params.replayGuard.commit(replayKey)));
-}
-function releaseDiscordInboundReplay(params) {
-	normalizeDiscordInboundReplayKeys(params.replayKeys).forEach((replayKey) => params.replayGuard.release(replayKey, { error: params.error }));
-}
-function normalizeDiscordInboundReplayKeys(replayKeys) {
-	return [...new Set((replayKeys ?? []).map((replayKey) => replayKey?.trim()).filter((replayKey) => Boolean(replayKey)))];
-}
 //#endregion
 //#region extensions/discord/src/monitor/inbound-job.ts
 function resolveDiscordInboundJobQueueKey(ctx) {
@@ -62,7 +45,7 @@ function resolveDiscordInboundJobQueueKey(ctx) {
 	return ctx.messageChannelId;
 }
 function buildDiscordInboundJob(ctx, options) {
-	const { runtime, abortSignal, guildHistories, client, threadBindings, replyTypingFeedback, discordRestFetch, message, data, threadChannel, ...payload } = ctx;
+	const { runtime, abortSignal, guildHistories, client, threadBindings, discordRestFetch, message, data, threadChannel, ...payload } = ctx;
 	const sanitizedMessage = sanitizeDiscordInboundMessage(message);
 	return {
 		queueKey: resolveDiscordInboundJobQueueKey(ctx),
@@ -81,10 +64,9 @@ function buildDiscordInboundJob(ctx, options) {
 			guildHistories,
 			client,
 			threadBindings,
-			replyTypingFeedback,
 			discordRestFetch
 		},
-		replayKeys: options?.replayKeys ? [...options.replayKeys] : void 0
+		replayClaims: options?.replayClaims
 	};
 }
 function materializeDiscordInboundJob(job, abortSignal) {
@@ -122,98 +104,24 @@ function applyImplicitReplyBatchGate(ctx, replyToMode, isBatched) {
 	ctx.ReplyThreading = replyThreading;
 }
 //#endregion
-//#region extensions/discord/src/monitor/message-handler.reply-typing-policy.ts
-function resolveDiscordSourceReplyDeliveryMode(ctx) {
-	return resolveChannelMessageSourceReplyDeliveryMode({
-		cfg: ctx.cfg,
-		ctx: {
-			ChatType: ctx.isDirectMessage ? "direct" : ctx.isGroupDm ? "group" : ctx.isGuildMessage ? "channel" : void 0,
-			InboundEventKind: ctx.inboundEventKind
-		}
-	});
-}
-function resolveDiscordAcceptedTypingPrestart(ctx) {
-	const sourceReplyDeliveryMode = resolveDiscordSourceReplyDeliveryMode(ctx);
-	if (ctx.abortSignal?.aborted) return {
-		sourceReplyDeliveryMode,
-		shouldPrestart: false,
-		reason: "aborted"
-	};
-	if (!ctx.messageText.trim()) return {
-		sourceReplyDeliveryMode,
-		shouldPrestart: false,
-		reason: "empty"
-	};
-	if (ctx.inboundEventKind === "room_event") return {
-		sourceReplyDeliveryMode,
-		shouldPrestart: false,
-		reason: "room-event"
-	};
-	const configuredTypingMode = ctx.cfg.session?.typingMode ?? ctx.cfg.agents?.defaults?.typingMode;
-	if (configuredTypingMode !== void 0) return {
-		sourceReplyDeliveryMode,
-		shouldPrestart: configuredTypingMode === "instant",
-		reason: configuredTypingMode === "instant" ? "configured-instant" : "configured-not-instant"
-	};
-	if (sourceReplyDeliveryMode === "message_tool_only") return {
-		sourceReplyDeliveryMode,
-		shouldPrestart: true,
-		reason: "tool-only"
-	};
-	if (!ctx.isGuildMessage && !ctx.isGroupDm) return {
-		sourceReplyDeliveryMode,
-		shouldPrestart: true,
-		reason: "direct"
-	};
-	if (ctx.effectiveWasMentioned) return {
-		sourceReplyDeliveryMode,
-		shouldPrestart: true,
-		reason: "mentioned-group"
-	};
-	return {
-		sourceReplyDeliveryMode,
-		shouldPrestart: false,
-		reason: "defer-to-message"
-	};
-}
-//#endregion
 //#region extensions/discord/src/monitor/message-run-queue.ts
-const loadMessageProcessRuntime = createLazyRuntimeModule(() => import("./message-handler.process-Cjf30P_B.js"));
+const loadMessageProcessRuntime = createLazyRuntimeModule(() => import("./message-handler.process-ClgKz8I5.js"));
 async function processDiscordQueuedMessage(params) {
 	const processDiscordMessageImpl = params.testing?.processDiscordMessage ?? (await loadMessageProcessRuntime()).processDiscordMessage;
-	const abortSignal = mergeAbortSignals([params.job.runtime.abortSignal, params.lifecycleSignal]);
+	const abortSignal = params.job.runtime.abortSignal && params.lifecycleSignal ? AbortSignal.any([params.job.runtime.abortSignal, params.lifecycleSignal]) : params.job.runtime.abortSignal ?? params.lifecycleSignal;
 	try {
 		await processDiscordMessageImpl(materializeDiscordInboundJob(params.job, abortSignal));
-		await commitDiscordInboundReplay({
-			replayKeys: params.job.replayKeys,
-			replayGuard: params.replayGuard
-		});
+		await Promise.all(params.job.replayClaims?.map((claim) => claim.commit()) ?? []);
 	} catch (error) {
-		if (error instanceof DiscordRetryableInboundError) releaseDiscordInboundReplay({
-			replayKeys: params.job.replayKeys,
-			error,
-			replayGuard: params.replayGuard
-		});
-		else await commitDiscordInboundReplay({
-			replayKeys: params.job.replayKeys,
-			replayGuard: params.replayGuard
-		});
+		if (error instanceof DiscordRetryableInboundError) for (const claim of params.job.replayClaims ?? []) claim.release({ error });
+		else await Promise.all(params.job.replayClaims?.map((claim) => claim.commit()) ?? []);
 		throw error;
 	}
 }
 function cleanupSkippedDiscordQueuedMessage(params) {
-	try {
-		params.job.runtime.replyTypingFeedback?.onCleanup?.();
-	} finally {
-		releaseDiscordInboundReplay({
-			replayKeys: params.job.replayKeys,
-			error: new DiscordRetryableInboundError("discord queued run skipped before processing"),
-			replayGuard: params.replayGuard
-		});
-	}
+	for (const claim of params.job.replayClaims ?? []) claim.release({ error: new DiscordRetryableInboundError("discord queued run skipped before processing") });
 }
 function createDiscordMessageRunQueue(params) {
-	const replayGuard = params.replayGuard ?? createDiscordInboundReplayGuard();
 	const skippedCleanup = /* @__PURE__ */ new Set();
 	const runQueue = createChannelRunQueue({
 		setStatus: params.setStatus,
@@ -224,6 +132,7 @@ function createDiscordMessageRunQueue(params) {
 	});
 	let lifecycleActive = !params.abortSignal?.aborted;
 	const cleanupSkippedQueuedMessages = () => {
+		params.abortSignal?.removeEventListener("abort", cleanupSkippedQueuedMessages);
 		if (!lifecycleActive && skippedCleanup.size === 0) return;
 		lifecycleActive = false;
 		const cleanups = [...skippedCleanup];
@@ -235,10 +144,7 @@ function createDiscordMessageRunQueue(params) {
 	return {
 		enqueue(job) {
 			const cleanupSkipped = () => {
-				cleanupSkippedDiscordQueuedMessage({
-					job,
-					replayGuard
-				});
+				cleanupSkippedDiscordQueuedMessage({ job });
 			};
 			if (!lifecycleActive) {
 				cleanupSkipped();
@@ -250,7 +156,6 @@ function createDiscordMessageRunQueue(params) {
 				await processDiscordQueuedMessage({
 					job,
 					lifecycleSignal,
-					replayGuard,
 					testing: params.testing
 				});
 			});
@@ -262,83 +167,11 @@ function createDiscordMessageRunQueue(params) {
 	};
 }
 //#endregion
-//#region extensions/discord/src/monitor/reply-typing-feedback.ts
-const DISCORD_REPLY_TYPING_MAX_DURATION_MS = 20 * 6e4;
-function createDiscordReplyTypingFeedback(params) {
-	let channelId = params.channelId;
-	const rest = params.rest ?? createDiscordRestClient({
-		cfg: params.cfg,
-		token: params.token,
-		accountId: params.accountId
-	}).rest;
-	const createCallbacks = () => createTypingCallbacks({
-		start: () => sendTyping({
-			rest,
-			channelId
-		}),
-		onStartError: (err) => {
-			logTypingFailure({
-				log: params.log,
-				channel: "discord",
-				target: channelId,
-				error: err
-			});
-		},
-		keepaliveIntervalMs: params.keepaliveIntervalMs,
-		maxDurationMs: params.maxDurationMs ?? DISCORD_REPLY_TYPING_MAX_DURATION_MS
-	});
-	const updateChannelId = (nextChannelId) => {
-		const trimmed = nextChannelId.trim();
-		if (trimmed) channelId = trimmed;
-	};
-	let callbacks = createCallbacks();
-	return {
-		onReplyStart: () => callbacks.onReplyStart(),
-		onIdle: () => callbacks.onIdle?.(),
-		onCleanup: () => callbacks.onCleanup?.(),
-		updateChannelId,
-		restartForDispatch: (nextChannelId) => {
-			updateChannelId(nextChannelId);
-			callbacks.onCleanup?.();
-			callbacks = createCallbacks();
-		},
-		getChannelId: () => channelId
-	};
-}
-//#endregion
 //#region extensions/discord/src/monitor/message-handler.ts
-const loadMessagePreflightRuntime = createLazyRuntimeModule(() => import("./message-handler.preflight-DvLXiYVH.js"));
+const loadMessagePreflightRuntime = createLazyRuntimeModule(() => import("./message-handler.preflight-DnAH04Ss.js"));
 function isNonEmptyString(value) {
 	return typeof value === "string" && value.length > 0;
 }
-function startAcceptedTypingFeedback(params) {
-	const { ctx, createFeedback, dedupeKey, activeFeedback } = params;
-	if (!resolveDiscordAcceptedTypingPrestart(ctx).shouldPrestart) return;
-	const channelId = ctx.messageChannelId.trim();
-	if (activeFeedback.get(dedupeKey)) return;
-	const replyTypingFeedback = ctx.replyTypingFeedback ?? (createFeedback ?? createDiscordReplyTypingFeedback)({
-		cfg: ctx.cfg,
-		token: ctx.token,
-		accountId: ctx.accountId,
-		channelId: ctx.messageChannelId,
-		log: logVerbose,
-		keepaliveIntervalMs: finiteSecondsToTimerSafeMilliseconds(ctx.cfg.agents?.defaults?.typingIntervalSeconds ?? ctx.cfg.session?.typingIntervalSeconds)
-	});
-	const cleanup = replyTypingFeedback.onCleanup;
-	replyTypingFeedback.onCleanup = () => {
-		cleanup?.();
-		if (activeFeedback.get(dedupeKey)?.feedback === replyTypingFeedback) activeFeedback.delete(dedupeKey);
-	};
-	activeFeedback.set(dedupeKey, {
-		channelId,
-		feedback: replyTypingFeedback
-	});
-	ctx.replyTypingFeedback = replyTypingFeedback;
-	replyTypingFeedback.onReplyStart().catch((err) => {
-		logVerbose(`discord accepted typing feedback failed: ${String(err)}`);
-	});
-	return replyTypingFeedback;
-}
 function createDiscordMessageHandler(params) {
 	const { groupPolicy } = resolveOpenProviderRuntimeGroupPolicy({
 		providerConfigPresent: params.cfg.channels?.discord !== void 0,
@@ -348,12 +181,10 @@ function createDiscordMessageHandler(params) {
 	const ackReactionScope = params.discordConfig?.ackReactionScope ?? params.cfg.messages?.ackReactionScope ?? "group-mentions";
 	const preflightDiscordMessageImpl = params.testing?.preflightDiscordMessage;
 	const replayGuard = createDiscordInboundReplayGuard();
-	const prestartedTypingFeedback = /* @__PURE__ */ new Map();
 	const messageRunQueue = createDiscordMessageRunQueue({
 		runtime: params.runtime,
 		setStatus: params.setStatus,
 		abortSignal: params.abortSignal,
-		replayGuard,
 		testing: params.testing
 	});
 	const { debouncer } = createChannelInboundDebouncer({
@@ -382,14 +213,10 @@ function createDiscordMessageHandler(params) {
 		onFlush: async (entries) => {
 			const last = entries.at(-1);
 			if (!last) return;
-			const replayKeys = entries.map((entry) => entry.replayKey).filter(isNonEmptyString);
+			const replayClaims = entries.map((entry) => entry.replayClaim).filter((claim) => claim !== void 0);
 			const abortSignal = last.abortSignal;
 			if (abortSignal?.aborted) {
-				releaseDiscordInboundReplay({
-					replayKeys,
-					error: abortSignal.reason,
-					replayGuard
-				});
+				for (const claim of replayClaims) claim.release({ error: abortSignal.reason });
 				return;
 			}
 			try {
@@ -403,21 +230,11 @@ function createDiscordMessageHandler(params) {
 						client: last.client
 					});
 					if (!ctx) {
-						await commitDiscordInboundReplay({
-							replayKeys,
-							replayGuard
-						});
+						await Promise.all(replayClaims.map((claim) => claim.commit()));
 						return;
 					}
-					const queueKey = resolveDiscordInboundJobQueueKey(ctx);
-					startAcceptedTypingFeedback({
-						ctx,
-						createFeedback: params.testing?.createReplyTypingFeedback,
-						dedupeKey: queueKey,
-						activeFeedback: prestartedTypingFeedback
-					});
 					applyImplicitReplyBatchGate(ctx, params.replyToMode, false);
-					messageRunQueue.enqueue(buildDiscordInboundJob(ctx, { replayKeys }));
+					messageRunQueue.enqueue(buildDiscordInboundJob(ctx, { replayClaims }));
 					return;
 				}
 				const combinedBaseText = entries.map((entry) => resolveDiscordMessageText(entry.data.message, { includeForwarded: false })).filter(Boolean).join("\n");
@@ -462,19 +279,9 @@ function createDiscordMessageHandler(params) {
 					client: last.client
 				});
 				if (!ctx) {
-					await commitDiscordInboundReplay({
-						replayKeys,
-						replayGuard
-					});
+					await Promise.all(replayClaims.map((claim) => claim.commit()));
 					return;
 				}
-				const queueKey = resolveDiscordInboundJobQueueKey(ctx);
-				startAcceptedTypingFeedback({
-					ctx,
-					createFeedback: params.testing?.createReplyTypingFeedback,
-					dedupeKey: queueKey,
-					activeFeedback: prestartedTypingFeedback
-				});
 				applyImplicitReplyBatchGate(ctx, params.replyToMode, true);
 				if (entries.length > 1) {
 					const ids = entries.map((entry) => entry.data.message?.id).filter(isNonEmptyString);
@@ -485,17 +292,10 @@ function createDiscordMessageHandler(params) {
 						ctxBatch.MessageSidLast = ids[ids.length - 1];
 					}
 				}
-				messageRunQueue.enqueue(buildDiscordInboundJob(ctx, { replayKeys }));
+				messageRunQueue.enqueue(buildDiscordInboundJob(ctx, { replayClaims }));
 			} catch (error) {
-				if (error instanceof DiscordRetryableInboundError) releaseDiscordInboundReplay({
-					replayKeys,
-					error,
-					replayGuard
-				});
-				else await commitDiscordInboundReplay({
-					replayKeys,
-					replayGuard
-				});
+				if (error instanceof DiscordRetryableInboundError) for (const claim of replayClaims) claim.release({ error });
+				else await Promise.all(replayClaims.map((claim) => claim.commit()));
 				throw error;
 			}
 		},
@@ -512,15 +312,13 @@ function createDiscordMessageHandler(params) {
 				accountId: params.accountId,
 				data
 			});
-			if (!await claimDiscordInboundReplay({
-				replayKey,
-				replayGuard
-			})) return;
+			const replayClaim = await replayGuard.claim(replayKey);
+			if (replayClaim.kind !== "claimed" && replayClaim.kind !== "invalid") return;
 			await debouncer.enqueue({
 				data,
 				client,
 				abortSignal: options?.abortSignal,
-				replayKey: replayKey ?? void 0
+				...replayClaim.kind === "claimed" ? { replayClaim: replayClaim.handle } : {}
 			});
 		} catch (err) {
 			params.runtime.error(danger(`handler failed: ${String(err)}`));
@@ -530,4 +328,4 @@ function createDiscordMessageHandler(params) {
 	return handler;
 }
 //#endregion
-export { createDiscordReplyTypingFeedback as n, createDiscordMessageHandler as t };
+export { DiscordRetryableInboundError as n, createDiscordMessageHandler as t };

package/dist/{message-handler.preflight-DvLXiYVH.js → message-handler.preflight-DnAH04Ss.js}

@@ -1,31 +1,31 @@
-import { N as Message, d as discord_exports, vt as getChannelMessage } from "./send.receipt-BpBQED_5.js";
-import { o as resolveDefaultDiscordAccountId } from "./accounts-P19jm1lf.js";
-import { S as resolveTimestampMs, _ as resolveGroupDmAllow, a as normalizeDiscordSlug, b as formatDiscordUserTag, c as resolveDiscordChannelConfigWithFallback, d as resolveDiscordGuildEntry, f as resolveDiscordMemberAccessState, g as resolveDiscordShouldRequireMention, i as normalizeDiscordDisplaySlug, n as isDiscordGroupAllowedByPolicy, x as resolveDiscordSystemLocation } from "./allow-list-C-MqM-B_.js";
-import { t as resolveDiscordConversationIdentity } from "./conversation-identity-DWC5d8Sy.js";
-import { d as isRecentlyUnboundThreadWebhookMessage } from "./thread-bindings.state-iSWjCYjB.js";
-import { n as DISCORD_ATTACHMENT_TOTAL_TIMEOUT_MS, t as DISCORD_ATTACHMENT_IDLE_TIMEOUT_MS } from "./timeouts-C5TBc_9x.js";
-import { d as resolveDiscordChannelNameSafe, u as resolveDiscordChannelInfoSafe } from "./thread-bindings.discord-api-BjIf9lGs.js";
-import "./thread-bindings-DsTxqu3E.js";
-import { D as resolveDiscordDmCommandAccess, O as resolveDiscordTextCommandAccess, _ as resolveDiscordConversationRoute, b as handleDiscordDmCommandDecision, g as buildDiscordRoutePeer, v as resolveDiscordEffectiveRoute, y as shouldIgnoreStaleDiscordRouteBinding } from "./provider-BkfbC9FQ.js";
-import { a as resolveForwardedMediaList, d as resolveDiscordMessageChannelId, l as resolveDiscordMessageStickers, o as resolveMediaList, r as resolveDiscordMessageText, u as resolveDiscordChannelInfo } from "./message-utils-B_3yA5bN.js";
-import { n as resolveDiscordWebhookId, t as resolveDiscordSenderIdentity } from "./sender-identity-CEsfDF0L.js";
-import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { L as Message, St as getChannelMessage, p as discord_exports } from "./chunk-CHpY_lsO.js";
+import { o as resolveDefaultDiscordAccountId } from "./accounts-CMd4nzLB.js";
+import { C as resolveTimestampMs, S as resolveDiscordSystemLocation, _ as resolveDiscordShouldRequireMention, a as normalizeDiscordSlug, c as resolveDiscordChannelConfigWithFallback, f as resolveDiscordGuildEntry, i as normalizeDiscordDisplaySlug, n as isDiscordGroupAllowedByPolicy, p as resolveDiscordMemberAccessState, v as resolveGroupDmAllow, x as formatDiscordUserTag } from "./allow-list-B7qOH5xu.js";
+import { n as DISCORD_ATTACHMENT_TOTAL_TIMEOUT_MS, t as DISCORD_ATTACHMENT_IDLE_TIMEOUT_MS } from "./timeouts-D5lWili0.js";
+import { t as resolveDiscordConversationIdentity } from "./conversation-identity-BPcbhCAH.js";
+import { d as isRecentlyUnboundThreadWebhookMessage } from "./thread-bindings.state-C5afR9TD.js";
+import { d as resolveDiscordChannelNameSafe, u as resolveDiscordChannelInfoSafe } from "./thread-bindings.discord-api-DXfXsHGZ.js";
+import "./thread-bindings-4MV-u8vU.js";
+import { A as resolveDiscordTextCommandAccess, S as handleDiscordDmCommandDecision, b as resolveDiscordEffectiveRoute, k as resolveDiscordDmCommandAccess, v as buildDiscordRoutePeer, x as shouldIgnoreStaleDiscordRouteBinding, y as resolveDiscordConversationRoute } from "./provider-PRlF_lZm.js";
+import { a as resolveForwardedMediaList, d as resolveDiscordMessageChannelId, l as resolveDiscordMessageStickers, o as resolveMediaList, r as resolveDiscordMessageText, u as resolveDiscordChannelInfo } from "./message-utils-BU3gc01v.js";
+import { n as resolveDiscordWebhookId, t as resolveDiscordSenderIdentity } from "./sender-identity-C62lBe18.js";
 import { normalizeOptionalString, readStringValue } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { logDebug } from "openclaw/plugin-sdk/logging-core";
 import { MessageReferenceType, MessageType } from "discord-api-types/v10";
+import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
 import { getChildLogger, logVerbose, shouldLogVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { recordChannelActivity } from "openclaw/plugin-sdk/channel-activity-runtime";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { formatAllowlistMatchMeta } from "openclaw/plugin-sdk/allow-from";
-import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
 import { enqueueSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
 import { mimeTypeFromFilePath } from "openclaw/plugin-sdk/media-mime";
 import { buildMentionRegexes, classifyChannelInboundEvent, implicitMentionKindWhen, logInboundDrop, matchesMentionWithExplicit, recordChannelBotPairLoopAndCheckSuppression, recordDroppedChannelInboundHistory, resolveInboundMentionDecision, resolveUnmentionedGroupInboundPolicy, toInboundMediaFacts } from "openclaw/plugin-sdk/channel-inbound";
-import { logDebug } from "openclaw/plugin-sdk/logging-core";
 import { hasControlCommand } from "openclaw/plugin-sdk/command-detection";
 import { isAbortRequestText } from "openclaw/plugin-sdk/command-primitives-runtime";
 import { shouldHandleTextCommands } from "openclaw/plugin-sdk/command-surface";
 //#region extensions/discord/src/monitor/message-handler.dm-preflight.ts
 const loadConversationRuntime$1 = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/conversation-binding-runtime"));
-const loadDiscordSendRuntime = createLazyRuntimeModule(() => import("./send-iJ0B4bAX.js").then((n) => n.t));
+const loadDiscordSendRuntime = createLazyRuntimeModule(() => import("./send-JJzVo_sK.js").then((n) => n.t));
 function resolveDiscordDmPairingSenderId(sender) {
 	return sender.isPluralKit ? `pk:${sender.id}` : sender.id;
 }
@@ -183,8 +183,7 @@ function copyRuntimeMessageFields(source, target) {
 	const channelDescriptor = Object.getOwnPropertyDescriptor(source, "channel");
 	if (channelDescriptor) Object.defineProperty(target, "channel", channelDescriptor);
 }
-function shouldHydrateDiscordMessage(params) {
-	if (hasMissingReferencedMessagePayload(params.message)) return true;
+function shouldHydrateDiscordMessagePayload(params) {
 	let currentText;
 	try {
 		currentText = resolveDiscordMessageText(params.message, { includeForwarded: true });
@@ -202,18 +201,42 @@ function hasMissingReferencedMessagePayload(message) {
 	if (message.type != null && message.type !== MessageType.Reply) return false;
 	return !Object.hasOwn(readMessageRawData(message), "referenced_message");
 }
+async function hydrateDiscordReplyReference(params) {
+	if (!hasMissingReferencedMessagePayload(params.message)) return params.message;
+	const reference = params.message.messageReference;
+	const referencedMessageId = reference?.message_id;
+	if (!referencedMessageId) return params.message;
+	const referencedChannelId = reference.channel_id ?? params.messageChannelId;
+	try {
+		const referenced = await getChannelMessage(params.client.rest, referencedChannelId, referencedMessageId);
+		if (!referenced) return params.message;
+		return mergeFetchedDiscordMessage(params.message, {
+			...readMessageRawData(params.message),
+			referenced_message: referenced
+		});
+	} catch (err) {
+		logVerbose(`discord: failed to hydrate referenced message ${referencedMessageId}: ${String(err)}`);
+		return params.message;
+	}
+}
 async function hydrateDiscordMessageIfNeeded(params) {
 	params.channelInfo;
-	if (!shouldHydrateDiscordMessage({ message: params.message })) return params.message;
-	try {
+	let hydrated = params.message;
+	if (shouldHydrateDiscordMessagePayload({ message: params.message })) try {
 		const fetched = await getChannelMessage(params.client.rest, params.messageChannelId, params.message.id);
-		if (!fetched) return params.message;
-		logVerbose(`discord: hydrated inbound payload via REST for ${params.message.id}`);
-		return mergeFetchedDiscordMessage(params.message, fetched);
+		if (fetched) {
+			logVerbose(`discord: hydrated inbound payload via REST for ${params.message.id}`);
+			hydrated = mergeFetchedDiscordMessage(params.message, fetched);
+		}
 	} catch (err) {
 		logVerbose(`discord: failed to hydrate message ${params.message.id}: ${String(err)}`);
 		return params.message;
 	}
+	return hydrateDiscordReplyReference({
+		client: params.client,
+		message: hydrated,
+		messageChannelId: params.messageChannelId
+	});
 }
 //#endregion
 //#region extensions/discord/src/monitor/message-handler.preflight-channel-access.ts
@@ -424,10 +447,10 @@ function logDiscordPreflightInboundSummary(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/message-handler.preflight-runtime.ts
-const loadPluralKitRuntime = createLazyRuntimeModule(() => import("./pluralkit-DcD-3EcL.js").then((n) => n.n));
-const loadPreflightAudioRuntime = createLazyRuntimeModule(() => import("./preflight-audio-DYL2ABgA.js"));
-const loadSystemEventsRuntime = createLazyRuntimeModule(() => import("./system-events-DVnqSyTt.js"));
-const loadDiscordThreadingRuntime = createLazyRuntimeModule(() => import("./provider-BkfbC9FQ.js").then((n) => n.S));
+const loadPluralKitRuntime = createLazyRuntimeModule(() => import("./pluralkit-r4wiI2yy.js").then((n) => n.n));
+const loadPreflightAudioRuntime = createLazyRuntimeModule(() => import("./preflight-audio-DDSZna4F.js"));
+const loadSystemEventsRuntime = createLazyRuntimeModule(() => import("./system-events-BANBRAe3.js"));
+const loadDiscordThreadingRuntime = createLazyRuntimeModule(() => import("./provider-PRlF_lZm.js").then((n) => n.w));
 function isPreflightAborted(abortSignal) {
 	return Boolean(abortSignal?.aborted);
 }
@@ -439,7 +462,8 @@ async function resolveDiscordPreflightPluralKitInfo(params) {
 		const { fetchPluralKitMessageInfo } = await loadPluralKitRuntime();
 		const info = await fetchPluralKitMessageInfo({
 			messageId: params.message.id,
-			config: params.config
+			config: params.config,
+			signal: params.abortSignal
 		});
 		return isPreflightAborted(params.abortSignal) ? null : info;
 	} catch (err) {