@openclaw/discord 2026.9.5 → 2026.9.7

package/dist/.setup/{message-handler-DnUrDpaU.mjs → message-handler-B-Jk4oDk.mjs}

@@ -1,18 +1,17 @@
-import { E as getDiscordEndpointRuntime, O as resolveDiscordEndpointMediaGuard } from "./channel-type-DKnjV1XW.mjs";
+import { D as getDiscordEndpointRuntime, k as resolveDiscordEndpointMediaGuard } from "./channel-type-DRCrEMss.mjs";
 import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.mjs";
-import { a as resolveDiscordChannelParentSafe, n as resolveDiscordChannelInfoSafe, r as resolveDiscordChannelNameSafe, t as resolveDiscordChannelIdSafe } from "./channel-access-C12aDZ0p.mjs";
-import { E as hasDiscordMessageStickers, T as resolveDiscordCdnPolicy, b as resolveDiscordMessageText, j as resolveDiscordMessageChannelId, k as resolveDiscordReferencedReplyMessageId } from "./transcripts-source-CuWYgayu.mjs";
-import { v as createDiscordLivePolicyReader, y as mapGatewayDispatchData } from "./provider-72zIvN-i.mjs";
+import { A as resolveDiscordMessageChannelId, O as resolveDiscordReferencedReplyMessageId, T as hasDiscordMessageStickers, w as resolveDiscordCdnPolicy, y as resolveDiscordMessageText } from "./transcripts-source-p8EV179h.mjs";
+import { D as createDiscordLivePolicyReader, O as mapGatewayDispatchData } from "./provider-B_G5hASF.mjs";
 import { logDebug } from "openclaw/plugin-sdk/logging-core";
 import { GatewayDispatchEvents } from "discord-api-types/v10";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { normalizeNullableString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createRuntimeConfigReader } from "openclaw/plugin-sdk/runtime-config-snapshot";
 import { danger } from "openclaw/plugin-sdk/runtime-env";
-import { resolveBatchedReplyThreadingPolicy } from "openclaw/plugin-sdk/reply-reference";
 import { DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS, createChannelIngressError, createChannelIngressMonitor, createChannelRunQueue } from "openclaw/plugin-sdk/channel-outbound";
 import { saveRemoteMedia } from "openclaw/plugin-sdk/media-runtime";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import { createChannelInboundDebouncer, resolveInboundDebounceMs, shouldDebounceTextInbound } from "openclaw/plugin-sdk/channel-inbound";
 import { fanInChannelIngressLifecycles } from "openclaw/plugin-sdk/channel-ingress-runtime";
 //#region extensions/discord/src/monitor/ingress.ts
@@ -117,61 +116,6 @@ function createDiscordIngressMonitor(params) {
 	};
 }
 //#endregion
-//#region extensions/discord/src/monitor/inbound-job.ts
-function buildDiscordInboundJob(ctx, options) {
-	const { runtime, buildContext, abortSignal, guildHistories, client, turnAdoptionLifecycle, threadBindings, discordRestFetch, message, data, threadChannel, ...payload } = ctx;
-	const sanitizedMessage = sanitizeDiscordInboundMessage(message);
-	return {
-		payload: {
-			...payload,
-			message: sanitizedMessage,
-			data: {
-				...data,
-				message: sanitizedMessage
-			},
-			threadChannel: normalizeDiscordThreadChannel(threadChannel)
-		},
-		runtime: {
-			runtime,
-			buildContext,
-			abortSignal,
-			guildHistories,
-			client,
-			turnAdoptionLifecycle,
-			threadBindings,
-			discordRestFetch
-		},
-		ingressSettlement: options?.ingressSettlement
-	};
-}
-function materializeDiscordInboundJob(job, abortSignal) {
-	return {
-		...job.payload,
-		...job.runtime,
-		abortSignal: abortSignal ?? job.runtime.abortSignal
-	};
-}
-function sanitizeDiscordInboundMessage(message) {
-	const descriptors = Object.getOwnPropertyDescriptors(message);
-	delete descriptors.channel;
-	return Object.create(Object.getPrototypeOf(message), descriptors);
-}
-function normalizeDiscordThreadChannel(threadChannel) {
-	if (!threadChannel) return null;
-	const channelInfo = resolveDiscordChannelInfoSafe(threadChannel);
-	const parent = resolveDiscordChannelParentSafe(threadChannel);
-	return {
-		id: threadChannel.id,
-		name: channelInfo.name,
-		parentId: channelInfo.parentId,
-		parent: parent ? {
-			id: resolveDiscordChannelIdSafe(parent),
-			name: resolveDiscordChannelNameSafe(parent)
-		} : void 0,
-		ownerId: channelInfo.ownerId
-	};
-}
-//#endregion
 //#region extensions/discord/src/monitor/message-avatar.ts
 const DISCORD_AVATAR_MAX_BYTES = 262144;
 const DISCORD_AVATAR_CACHE_MAX_ENTRIES = 128;
@@ -179,11 +123,7 @@ const DISCORD_GUILD_ICON_TTL_MS = 3e5;
 function setBoundedEntry(map, key, value) {
 	map.delete(key);
 	map.set(key, value);
-	while (map.size > DISCORD_AVATAR_CACHE_MAX_ENTRIES) {
-		const oldest = map.keys().next().value;
-		if (oldest === void 0) break;
-		map.delete(oldest);
-	}
+	pruneMapToMaxSize(map, DISCORD_AVATAR_CACHE_MAX_ENTRIES);
 }
 function discordAvatarUrl(owner, id, hash) {
 	return `https://cdn.discordapp.com/${owner}/${id}/${hash}.png?size=128`;
@@ -252,19 +192,15 @@ function createDiscordAvatarResolver() {
 	} };
 }
 //#endregion
-//#region extensions/discord/src/monitor/message-handler.batch-gate.ts
-function applyImplicitReplyBatchGate(ctx, replyToMode, isBatched) {
-	const replyThreading = resolveBatchedReplyThreadingPolicy(replyToMode, isBatched);
-	if (!replyThreading) return;
-	ctx.ReplyThreading = replyThreading;
-}
-//#endregion
 //#region extensions/discord/src/monitor/message-run-queue.ts
-const loadMessageProcessRuntime = createLazyRuntimeModule(() => import("./message-handler.process-Dz1xvuQU.mjs"));
+const loadMessageProcessRuntime = createLazyRuntimeModule(() => import("./message-handler.process-BNFFuChn.mjs"));
 async function processDiscordQueuedMessage(params) {
-	const abortSignal = params.job.runtime.abortSignal && params.lifecycleSignal ? AbortSignal.any([params.job.runtime.abortSignal, params.lifecycleSignal]) : params.job.runtime.abortSignal ?? params.lifecycleSignal;
+	const abortSignal = params.job.context.abortSignal && params.lifecycleSignal ? AbortSignal.any([params.job.context.abortSignal, params.lifecycleSignal]) : params.job.context.abortSignal ?? params.lifecycleSignal;
 	try {
-		await (params.testing?.processDiscordMessage ?? (await loadMessageProcessRuntime()).processDiscordMessage)(materializeDiscordInboundJob(params.job, abortSignal));
+		await (params.testing?.processDiscordMessage ?? (await loadMessageProcessRuntime()).processDiscordMessage)({
+			...params.job.context,
+			abortSignal
+		});
 		if (abortSignal?.aborted) await params.job.ingressSettlement?.cancel();
 		else await params.job.ingressSettlement?.settle();
 	} catch (error) {
@@ -273,9 +209,6 @@ async function processDiscordQueuedMessage(params) {
 		throw error;
 	}
 }
-async function cleanupSkippedDiscordQueuedMessage(params) {
-	await params.job.ingressSettlement?.cancel();
-}
 function createDiscordMessageRunQueue(params) {
 	const skippedCleanup = /* @__PURE__ */ new Set();
 	const runQueue = createChannelRunQueue({
@@ -311,7 +244,7 @@ function createDiscordMessageRunQueue(params) {
 			};
 			const cleanupSkipped = async () => {
 				try {
-					await cleanupSkippedDiscordQueuedMessage({ job });
+					await job.ingressSettlement?.cancel();
 				} catch (error) {
 					try {
 						params.runtime.error(danger(`discord queued message cleanup failed: ${String(error)}`));
@@ -325,7 +258,7 @@ function createDiscordMessageRunQueue(params) {
 				return;
 			}
 			skippedCleanup.add(cleanupSkipped);
-			runQueue.enqueue(job.payload.message.id, async ({ lifecycleSignal }) => {
+			runQueue.enqueue(job.context.message.id, async ({ lifecycleSignal }) => {
 				skippedCleanup.delete(cleanupSkipped);
 				try {
 					await processDiscordQueuedMessage({
@@ -347,10 +280,7 @@ function createDiscordMessageRunQueue(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/message-dispatcher.ts
-const loadMessagePreflightRuntime = createLazyRuntimeModule(() => import("./message-handler.preflight-CtqaF_fb.mjs"));
-function isNonEmptyString(value) {
-	return typeof value === "string" && value.length > 0;
-}
+const loadMessagePreflightRuntime = createLazyRuntimeModule(() => import("./message-handler.preflight-v-__NSDq.mjs"));
 function createDiscordMessageDispatcher(params) {
 	const readPolicy = params.readPolicy ?? createDiscordLivePolicyReader({
 		...params,
@@ -449,15 +379,10 @@ function createDiscordMessageDispatcher(params) {
 							await ingress.settle();
 							return;
 						}
-						applyImplicitReplyBatchGate(ctx, params.replyToMode, entries.length > 1);
-						const ids = entries.map((entry) => entry.data.message?.id).filter(isNonEmptyString);
-						if (entries.length > 1 && ids.length > 0) {
-							const ctxBatch = ctx;
-							ctxBatch.MessageSids = ids;
-							ctxBatch.MessageSidFirst = ids[0];
-							ctxBatch.MessageSidLast = ids[ids.length - 1];
-						}
-						messageRunQueue.enqueue(buildDiscordInboundJob(ctx, { ingressSettlement: ingress }));
+						messageRunQueue.enqueue({
+							context: ctx,
+							ingressSettlement: ingress
+						});
 					} catch (error) {
 						if (abortSignal?.aborted) {
 							await ingress.cancel();

package/dist/.setup/message-handler.preflight-pluralkit-CWLUBVcx.mjs

@@ -0,0 +1,141 @@
+import { t as isDiscordThreadChannelType } from "./channel-type-DRCrEMss.mjs";
+import { E as resolveDiscordMessageStickers } from "./transcripts-source-p8EV179h.mjs";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { findCodeRegions, isInsideCode } from "openclaw/plugin-sdk/text-chunking";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { implicitMentionKindWhen, matchesMentionWithExplicit, normalizeMentionText } from "openclaw/plugin-sdk/channel-inbound";
+import { filterSupplementalContextItems } from "openclaw/plugin-sdk/security-runtime";
+//#region extensions/discord/src/monitor/message-handler.preflight-helpers.ts
+const DISCORD_BOUND_THREAD_SYSTEM_PREFIXES = [
+	"⚙️",
+	"🤖",
+	"🧰"
+];
+function isBoundThreadBotSystemMessage(params) {
+	if (!params.isBoundThreadSession || !params.isBotAuthor) return false;
+	const text = params.text?.trim();
+	if (!text) return false;
+	return DISCORD_BOUND_THREAD_SYSTEM_PREFIXES.some((prefix) => text.startsWith(prefix));
+}
+function isDiscordThreadChannelMessage(params) {
+	if (!params.isGuildMessage) return false;
+	const channel = "channel" in params.message ? params.message.channel : void 0;
+	return Boolean(channel && typeof channel === "object" && "isThread" in channel && typeof channel.isThread === "function" && channel.isThread() || isDiscordThreadChannelType(params.channelInfo?.type));
+}
+function resolveInjectedBoundThreadLookupRecord(params) {
+	const getByThreadId = params.threadBindings.getByThreadId;
+	if (typeof getByThreadId !== "function") return;
+	const binding = getByThreadId(params.threadId);
+	return binding && typeof binding === "object" ? binding : void 0;
+}
+function resolveDiscordMentionState(params) {
+	if (params.isDirectMessage) return {
+		implicitMentionKinds: [],
+		wasMentioned: false
+	};
+	const wasMentioned = params.mentionedEveryone && (!params.authorIsBot || params.senderIsPluralKit) || matchesMentionWithExplicit({
+		text: params.mentionText,
+		mentionRegexes: params.mentionRegexes,
+		explicit: {
+			hasAnyMention: params.hasAnyMention,
+			isExplicitlyMentioned: params.isExplicitlyMentioned,
+			canResolveExplicit: Boolean(params.botId)
+		},
+		transcript: params.transcript
+	});
+	return {
+		implicitMentionKinds: implicitMentionKindWhen("reply_to_bot", Boolean(params.botId) && Boolean(params.referencedAuthorId) && params.referencedAuthorId === params.botId),
+		wasMentioned
+	};
+}
+function hasRawDiscordUserMention(text, userId) {
+	if (!userId) return false;
+	const codeRegions = findCodeRegions(text);
+	for (const mention of [`<@${userId}>`, `<@!${userId}>`]) {
+		let index = text.indexOf(mention);
+		while (index >= 0) {
+			let precedingBackslashes = 0;
+			for (let offset = index - 1; offset >= 0 && text[offset] === "\\"; offset -= 1) precedingBackslashes += 1;
+			if (precedingBackslashes % 2 === 0 && !isInsideCode(index, codeRegions)) return true;
+			index = text.indexOf(mention, index + mention.length);
+		}
+	}
+	return false;
+}
+function matchesActiveDiscordMentionPatterns(text, mentionRegexes) {
+	if (mentionRegexes.length === 0) return false;
+	const cleaned = normalizeMentionText(text);
+	const normalizedOffset = (offset) => Math.min(cleaned.length, normalizeMentionText(`${text.slice(0, offset)}\0`).length - 1);
+	const codeRegions = findCodeRegions(text).map(({ start, end }) => ({
+		start: normalizedOffset(start),
+		end: normalizedOffset(end)
+	}));
+	for (const regex of mentionRegexes) for (const match of cleaned.matchAll(new RegExp(regex.source, `${regex.flags}g`))) if (!codeRegions.some(({ start, end }) => match.index < end && (match.index >= start || match.index + match[0].length > start))) return true;
+	return false;
+}
+function resolvePreflightMentionRequirement(params) {
+	return params.shouldRequireMention && !params.bypassMentionRequirement;
+}
+function shouldIgnoreBoundThreadWebhookMessage(params) {
+	const webhookId = normalizeOptionalString(params.webhookId) ?? "";
+	if (!webhookId) return false;
+	const boundWebhookId = normalizeOptionalString(params.threadBinding?.webhookId) ?? normalizeOptionalString(params.threadBinding?.metadata?.webhookId) ?? "";
+	if (boundWebhookId && webhookId === boundWebhookId) return true;
+	const threadId = normalizeOptionalString(params.threadId) ?? "";
+	return Boolean(threadId && params.threadBinding);
+}
+//#endregion
+//#region extensions/discord/src/monitor/message-handler.history.ts
+function createDiscordHistorySenderProvenance(params) {
+	return Object.freeze({
+		id: params.sender.id,
+		name: params.sender.name,
+		tag: params.sender.tag,
+		memberRoleIds: Object.freeze([...params.memberRoleIds])
+	});
+}
+function filterDiscordHistoryEntriesForContext(params) {
+	if (params.mode === "all") return {
+		entries: [...params.entries],
+		omitted: 0
+	};
+	const filtered = filterSupplementalContextItems({
+		items: params.entries,
+		mode: params.mode,
+		kind: "history",
+		isSenderAllowed: (entry) => Boolean(entry.senderProvenance) && params.isSenderAllowed(entry.senderProvenance)
+	});
+	return {
+		entries: filtered.items,
+		omitted: filtered.omitted
+	};
+}
+function resolveDiscordHistoryMediaIds(message) {
+	return [...(message.attachments ?? []).map((attachment) => `attachment:${attachment.id}`), ...resolveDiscordMessageStickers(message).map((sticker) => `sticker:${sticker.id}`)];
+}
+//#endregion
+//#region extensions/discord/src/monitor/message-handler.preflight-runtime.ts
+const loadPluralKitRuntime = createLazyRuntimeModule(() => import("./pluralkit-a6_NLfH9.mjs").then((n) => n.n));
+const loadPreflightAudioRuntime = createLazyRuntimeModule(() => import("./preflight-audio-DHGIHEpv.mjs"));
+const loadSystemEventsRuntime = createLazyRuntimeModule(() => import("./system-events-CdeZnvPV.mjs"));
+const loadDiscordThreadingRuntime = createLazyRuntimeModule(() => import("./transcripts-source-p8EV179h.mjs").then((n) => n.d));
+//#endregion
+//#region extensions/discord/src/monitor/message-handler.preflight-pluralkit.ts
+async function resolveDiscordPreflightPluralKitInfo(params) {
+	if (!params.config?.enabled || !params.webhookId) return null;
+	try {
+		const { fetchPluralKitMessageInfo } = await loadPluralKitRuntime();
+		const info = await fetchPluralKitMessageInfo({
+			messageId: params.message.id,
+			config: params.config,
+			signal: params.abortSignal
+		});
+		return params.abortSignal?.aborted ? null : info;
+	} catch (err) {
+		logVerbose(`discord: pluralkit lookup failed for ${params.message.id}: ${String(err)}`);
+		return null;
+	}
+}
+//#endregion
+export { createDiscordHistorySenderProvenance as a, hasRawDiscordUserMention as c, matchesActiveDiscordMentionPatterns as d, resolveDiscordMentionState as f, shouldIgnoreBoundThreadWebhookMessage as h, loadSystemEventsRuntime as i, isBoundThreadBotSystemMessage as l, resolvePreflightMentionRequirement as m, loadDiscordThreadingRuntime as n, filterDiscordHistoryEntriesForContext as o, resolveInjectedBoundThreadLookupRecord as p, loadPreflightAudioRuntime as r, resolveDiscordHistoryMediaIds as s, resolveDiscordPreflightPluralKitInfo as t, isDiscordThreadChannelMessage as u };