@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

package/dist/sender-identity-BiSDAk2P.js

@@ -0,0 +1,43 @@
+import { n as formatDiscordUserTag } from "./format-D8TsaXxW.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+//#region extensions/discord/src/monitor/sender-identity.ts
+function resolveDiscordWebhookId(message) {
+	const candidate = message.webhookId ?? message.webhook_id;
+	return typeof candidate === "string" && candidate.trim() ? candidate.trim() : null;
+}
+function resolveDiscordSenderIdentity(params) {
+	const pkInfo = params.pluralkitInfo ?? null;
+	const pkMember = pkInfo?.member ?? void 0;
+	const pkSystem = pkInfo?.system ?? void 0;
+	const memberId = pkMember?.id?.trim();
+	const memberName = (pkMember?.display_name ?? pkMember?.name ?? "")?.trim();
+	if (memberId && memberName) {
+		const systemName = pkSystem?.name?.trim();
+		const label = systemName ? `${memberName} (PK:${systemName})` : `${memberName} (PK)`;
+		return {
+			id: memberId,
+			name: memberName,
+			tag: normalizeOptionalString(pkMember?.name),
+			label,
+			isPluralKit: true,
+			pluralkit: {
+				memberId,
+				memberName,
+				systemId: normalizeOptionalString(pkSystem?.id),
+				systemName
+			}
+		};
+	}
+	const senderTag = formatDiscordUserTag(params.author);
+	const senderDisplay = params.member?.nickname ?? params.member?.nick ?? params.author.globalName ?? params.author.username;
+	const senderLabel = senderDisplay && senderTag && senderDisplay !== senderTag ? `${senderDisplay} (${senderTag})` : senderDisplay ?? senderTag ?? params.author.id;
+	return {
+		id: params.author.id,
+		name: params.author.username ?? void 0,
+		tag: senderTag,
+		label: senderLabel,
+		isPluralKit: false
+	};
+}
+//#endregion
+export { resolveDiscordWebhookId as n, resolveDiscordSenderIdentity as t };

package/dist/session-contract-goJZckp2.js

@@ -0,0 +1,6 @@
+//#region extensions/discord/src/session-contract.ts
+function deriveLegacySessionChatType(sessionKey) {
+	return /^discord:(?:[^:]+:)?guild-[^:]+:channel-[^:]+$/.test(sessionKey) ? "channel" : void 0;
+}
+//#endregion
+export { deriveLegacySessionChatType as t };

package/dist/session-key-api.js

@@ -0,0 +1,2 @@
+import { t as normalizeExplicitDiscordSessionKey } from "./session-key-normalization-Daag9II6.js";
+export { normalizeExplicitDiscordSessionKey };

package/dist/session-key-normalization-Daag9II6.js

@@ -0,0 +1,23 @@
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
+//#region extensions/discord/src/session-key-normalization.ts
+function normalizeDiscordChatType(raw) {
+	const normalized = normalizeLowercaseStringOrEmpty(raw);
+	if (!normalized) return;
+	if (normalized === "dm") return "direct";
+	if (normalized === "group" || normalized === "channel" || normalized === "direct") return normalized;
+}
+function normalizeExplicitDiscordSessionKey(sessionKey, ctx) {
+	let normalized = normalizeLowercaseStringOrEmpty(sessionKey);
+	if (normalizeDiscordChatType(ctx.ChatType) !== "direct") return normalized;
+	normalized = normalized.replace(/^(discord:)dm:/, "$1direct:");
+	normalized = normalized.replace(/^(agent:[^:]+:discord:)dm:/, "$1direct:");
+	const match = normalized.match(/^((?:agent:[^:]+:)?)discord:channel:([^:]+)$/);
+	if (!match) return normalized;
+	const from = normalizeLowercaseStringOrEmpty(ctx.From);
+	const senderId = normalizeLowercaseStringOrEmpty(ctx.SenderId);
+	const fromDiscordId = from.startsWith("discord:") && !from.includes(":channel:") && !from.includes(":group:") ? from.slice(8) : "";
+	const directId = senderId || fromDiscordId;
+	return directId && directId === match[2] ? `${match[1]}discord:direct:${match[2]}` : normalized;
+}
+//#endregion
+export { normalizeExplicitDiscordSessionKey as t };

package/dist/setup-entry.js

@@ -0,0 +1,11 @@
+import { defineBundledChannelSetupEntry } from "openclaw/plugin-sdk/channel-entry-contract";
+//#region extensions/discord/setup-entry.ts
+var setup_entry_default = defineBundledChannelSetupEntry({
+	importMetaUrl: import.meta.url,
+	plugin: {
+		specifier: "./setup-plugin-api.js",
+		exportName: "discordSetupPlugin"
+	}
+});
+//#endregion
+export { setup_entry_default as default };

package/dist/setup-plugin-api.js

@@ -0,0 +1,2 @@
+import { t as discordSetupPlugin } from "./channel.setup-Dt4tIDrl.js";
+export { discordSetupPlugin };

package/dist/shared-CqlrJmSs.js

@@ -0,0 +1,166 @@
+import { a as mergeDiscordAccountConfig, c as resolveDiscordAccountAllowFrom, d as resolveDiscordAccountDmPolicy, n as isDiscordAccountEnabledForRuntime, o as resolveDefaultDiscordAccountId, r as listDiscordAccountIds, s as resolveDiscordAccount, u as resolveDiscordAccountDisabledReason } from "./accounts-BKnkNaoA.js";
+import { t as inspectDiscordAccount } from "./account-inspect-C2UEUhbG.js";
+import { i as getChatChannelMeta } from "./channel-api-CTSWMrnD.js";
+import { t as DiscordChannelConfigSchema } from "./config-schema-DwFkL904.js";
+import { n as normalizeCompatibilityConfig } from "./doctor-contract-D3pSutkb.js";
+import { t as DISCORD_LEGACY_CONFIG_RULES } from "./doctor-shared-DU8RcnF5.js";
+import { n as secretTargetRegistryEntries, t as collectRuntimeConfigAssignments } from "./secret-config-contract-CoGryS5c.js";
+import { n as unsupportedSecretRefSurfacePatterns, t as collectUnsupportedSecretRefConfigCandidates } from "./security-contract-ei3Mz8Sa.js";
+import { t as deriveLegacySessionChatType } from "./session-contract-goJZckp2.js";
+import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
+import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter, createScopedDmSecurityResolver } from "openclaw/plugin-sdk/channel-config-helpers";
+import { createOpenProviderConfiguredRouteWarningCollector } from "openclaw/plugin-sdk/channel-policy";
+import { createEnvPatchedAccountSetupAdapter } from "openclaw/plugin-sdk/setup-adapter-runtime";
+import { formatAllowFromLowercase } from "openclaw/plugin-sdk/allow-from";
+//#region extensions/discord/src/security.ts
+const resolveDiscordDmPolicy = createScopedDmSecurityResolver({
+	channelKey: "discord",
+	resolvePolicy: (account) => account.config.dmPolicy,
+	resolveAllowFrom: (account) => account.config.allowFrom,
+	resolveAccess: ({ cfg, account }) => ({
+		dmPolicy: resolveDiscordAccountDmPolicy({
+			cfg,
+			accountId: account.accountId
+		}),
+		allowFrom: resolveDiscordAccountAllowFrom({
+			cfg,
+			accountId: account.accountId
+		})
+	}),
+	policyPathSuffix: "dmPolicy",
+	normalizeEntry: (raw) => raw.trim().replace(/^(discord|user):/i, "").replace(/^<@!?(\d+)>$/, "$1")
+});
+const collectDiscordSecurityWarnings = createOpenProviderConfiguredRouteWarningCollector({
+	providerConfigPresent: (cfg) => cfg.channels?.discord !== void 0,
+	resolveGroupPolicy: (account) => account.config.groupPolicy,
+	resolveRouteAllowlistConfigured: (account) => Object.keys(account.config.guilds ?? {}).length > 0,
+	configureRouteAllowlist: {
+		surface: "Discord guilds",
+		openScope: "any channel not explicitly denied",
+		groupPolicyPath: "channels.discord.groupPolicy",
+		routeAllowlistPath: "channels.discord.guilds.<id>.channels"
+	},
+	missingRouteAllowlist: {
+		surface: "Discord guilds",
+		openBehavior: "with no guild/channel allowlist; any channel can trigger (mention-gated)",
+		remediation: "Set channels.discord.groupPolicy=\"allowlist\" and configure channels.discord.guilds.<id>.channels"
+	}
+});
+let discordSecurityAuditModulePromise;
+async function loadDiscordSecurityAuditModule() {
+	discordSecurityAuditModulePromise ??= import("./security-audit.runtime-DBV1T1_N.js");
+	return await discordSecurityAuditModulePromise;
+}
+const discordSecurityAdapter = {
+	resolveDmPolicy: resolveDiscordDmPolicy,
+	collectWarnings: collectDiscordSecurityWarnings,
+	collectAuditFindings: async (params) => (await loadDiscordSecurityAuditModule()).collectDiscordSecurityAuditFindings(params)
+};
+const discordSetupAdapter = createEnvPatchedAccountSetupAdapter({
+	channelKey: "discord",
+	defaultAccountOnlyEnvError: "DISCORD_BOT_TOKEN can only be used for the default account.",
+	missingCredentialError: "Discord requires token (or --use-env).",
+	hasCredentials: (input) => Boolean(input.token),
+	buildPatch: (input) => input.token ? { token: input.token } : {}
+});
+//#endregion
+//#region extensions/discord/src/shared.ts
+const DISCORD_CHANNEL = "discord";
+let discordDoctorModulePromise;
+async function loadDiscordDoctorModule() {
+	discordDoctorModulePromise ??= import("./doctor-B2G7WqO0.js");
+	return await discordDoctorModulePromise;
+}
+const discordDoctor = {
+	dmAllowFromMode: "topOnly",
+	groupModel: "route",
+	groupAllowFromFallbackToAllowFrom: false,
+	warnOnEmptyGroupSenderAllowlist: false,
+	legacyConfigRules: DISCORD_LEGACY_CONFIG_RULES,
+	normalizeCompatibilityConfig,
+	collectPreviewWarnings: async (params) => (await loadDiscordDoctorModule()).discordDoctor.collectPreviewWarnings?.(params) ?? [],
+	collectMutableAllowlistWarnings: async (params) => (await loadDiscordDoctorModule()).discordDoctor.collectMutableAllowlistWarnings?.(params) ?? [],
+	repairConfig: async (params) => (await loadDiscordDoctorModule()).discordDoctor.repairConfig?.(params) ?? {
+		config: params.cfg,
+		changes: []
+	}
+};
+function resolveDiscordConfigAccessorAccount(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
+	const config = mergeDiscordAccountConfig(params.cfg, accountId);
+	return {
+		allowFrom: resolveDiscordAccountAllowFrom({
+			cfg: params.cfg,
+			accountId
+		}),
+		defaultTo: config.defaultTo
+	};
+}
+const discordConfigAdapter = createScopedChannelConfigAdapter({
+	sectionKey: DISCORD_CHANNEL,
+	listAccountIds: listDiscordAccountIds,
+	resolveAccount: adaptScopedAccountAccessor(resolveDiscordAccount),
+	resolveAccessorAccount: resolveDiscordConfigAccessorAccount,
+	inspectAccount: adaptScopedAccountAccessor(inspectDiscordAccount),
+	defaultAccountId: resolveDefaultDiscordAccountId,
+	clearBaseFields: ["token", "name"],
+	resolveAllowFrom: (account) => account.allowFrom,
+	formatAllowFrom: (allowFrom) => formatAllowFromLowercase({ allowFrom }),
+	resolveDefaultTo: (account) => account.defaultTo
+});
+function createDiscordPluginBase(params) {
+	return {
+		id: DISCORD_CHANNEL,
+		...params.setupWizard ? { setupWizard: params.setupWizard } : {},
+		meta: { ...getChatChannelMeta(DISCORD_CHANNEL) },
+		capabilities: {
+			chatTypes: [
+				"direct",
+				"channel",
+				"thread"
+			],
+			polls: true,
+			reactions: true,
+			threads: true,
+			media: true,
+			tts: { voice: { synthesisTarget: "voice-note" } },
+			nativeCommands: true
+		},
+		commands: {
+			nativeCommandsAutoEnabled: true,
+			nativeSkillsAutoEnabled: true,
+			resolveNativeCommandName: ({ commandKey, defaultName }) => commandKey === "tts" ? "voice" : defaultName
+		},
+		doctor: discordDoctor,
+		streaming: { blockStreamingCoalesceDefaults: {
+			minChars: 1500,
+			idleMs: 1e3
+		} },
+		reload: { configPrefixes: ["channels.discord"] },
+		configSchema: DiscordChannelConfigSchema,
+		config: {
+			...discordConfigAdapter,
+			hasConfiguredState: ({ env }) => typeof env?.DISCORD_BOT_TOKEN === "string" && env.DISCORD_BOT_TOKEN.trim().length > 0,
+			isEnabled: (account, cfg) => isDiscordAccountEnabledForRuntime(account, cfg),
+			disabledReason: (account, cfg) => resolveDiscordAccountDisabledReason(account, cfg),
+			isConfigured: (account) => Boolean(account.token?.trim()),
+			describeAccount: (account) => describeAccountSnapshot({
+				account,
+				configured: Boolean(account.token?.trim()),
+				extra: { tokenSource: account.tokenSource }
+			})
+		},
+		messaging: { deriveLegacySessionChatType },
+		security: discordSecurityAdapter,
+		secrets: {
+			secretTargetRegistryEntries,
+			unsupportedSecretRefSurfacePatterns,
+			collectUnsupportedSecretRefConfigCandidates,
+			collectRuntimeConfigAssignments
+		},
+		setup: params.setup
+	};
+}
+//#endregion
+export { discordSecurityAdapter as i, discordConfigAdapter as n, discordSetupAdapter as r, createDiscordPluginBase as t };

package/dist/shared-interactive-KgJjCqnB.js

@@ -0,0 +1,79 @@
+import { t as __exportAll } from "./rolldown-runtime-C3SqQTfK.js";
+import { presentationToInteractiveReply, reduceInteractiveReply } from "openclaw/plugin-sdk/interactive-runtime";
+//#region extensions/discord/src/shared-interactive.ts
+var shared_interactive_exports = /* @__PURE__ */ __exportAll({
+	buildDiscordInteractiveComponents: () => buildDiscordInteractiveComponents,
+	buildDiscordPresentationComponents: () => buildDiscordPresentationComponents
+});
+function resolveDiscordInteractiveButtonStyle(style) {
+	return style ?? "secondary";
+}
+const DISCORD_INTERACTIVE_BUTTON_ROW_SIZE = 5;
+function buildDiscordInteractiveComponents(interactive) {
+	const blocks = reduceInteractiveReply(interactive, [], (state, block) => {
+		if (block.type === "text") {
+			const text = block.text.trim();
+			if (text) state.push({
+				type: "text",
+				text
+			});
+			return state;
+		}
+		if (block.type === "buttons") {
+			if (block.buttons.length === 0) return state;
+			for (let index = 0; index < block.buttons.length; index += DISCORD_INTERACTIVE_BUTTON_ROW_SIZE) state.push({
+				type: "actions",
+				buttons: block.buttons.slice(index, index + DISCORD_INTERACTIVE_BUTTON_ROW_SIZE).map((button) => {
+					const spec = {
+						label: button.label,
+						style: button.url ? "link" : resolveDiscordInteractiveButtonStyle(button.style)
+					};
+					if (button.value) spec.callbackData = button.value;
+					if (button.url) spec.url = button.url;
+					return spec;
+				})
+			});
+			return state;
+		}
+		if (block.type === "select" && block.options.length > 0) state.push({
+			type: "actions",
+			select: {
+				type: "string",
+				placeholder: block.placeholder,
+				options: block.options.map((option) => ({
+					label: option.label,
+					value: option.value
+				}))
+			}
+		});
+		return state;
+	});
+	return blocks.length > 0 ? { blocks } : void 0;
+}
+function buildDiscordPresentationComponents(presentation) {
+	if (!presentation) return;
+	const spec = { blocks: [] };
+	if (presentation.title) spec.blocks?.push({
+		type: "text",
+		text: presentation.title
+	});
+	for (const block of presentation.blocks) {
+		if (block.type === "text" || block.type === "context") {
+			const text = block.text.trim();
+			if (text) spec.blocks?.push({
+				type: "text",
+				text: block.type === "context" ? `-# ${text}` : text
+			});
+			continue;
+		}
+		if (block.type === "divider") {
+			spec.blocks?.push({ type: "separator" });
+			continue;
+		}
+	}
+	const interactiveSpec = buildDiscordInteractiveComponents(presentationToInteractiveReply({ blocks: presentation.blocks.filter((block) => block.type === "buttons" || block.type === "select") }));
+	if (interactiveSpec?.blocks?.length) spec.blocks?.push(...interactiveSpec.blocks);
+	return spec.blocks?.length ? spec : void 0;
+}
+//#endregion
+export { buildDiscordPresentationComponents as n, shared_interactive_exports as r, buildDiscordInteractiveComponents as t };

package/dist/subagent-hooks-api.js

@@ -0,0 +1,22 @@
+//#region extensions/discord/subagent-hooks-api.ts
+let discordSubagentHooksPromise = null;
+function loadDiscordSubagentHooksModule() {
+	discordSubagentHooksPromise ??= import("./subagent-hooks-mEK5ARfP.js").then((n) => n.i);
+	return discordSubagentHooksPromise;
+}
+function registerDiscordSubagentHooks(api) {
+	api.on("subagent_spawning", async (event) => {
+		const { handleDiscordSubagentSpawning } = await loadDiscordSubagentHooksModule();
+		return await handleDiscordSubagentSpawning(api, event);
+	});
+	api.on("subagent_ended", async (event) => {
+		const { handleDiscordSubagentEnded } = await loadDiscordSubagentHooksModule();
+		handleDiscordSubagentEnded(event);
+	});
+	api.on("subagent_delivery_target", async (event) => {
+		const { handleDiscordSubagentDeliveryTarget } = await loadDiscordSubagentHooksModule();
+		return handleDiscordSubagentDeliveryTarget(event);
+	});
+}
+//#endregion
+export { registerDiscordSubagentHooks };

package/dist/subagent-hooks-mEK5ARfP.js

@@ -0,0 +1,113 @@
+import { t as __exportAll } from "./rolldown-runtime-C3SqQTfK.js";
+import { s as resolveDiscordAccount } from "./accounts-BKnkNaoA.js";
+import { n as autoBindSpawnedDiscordSubagent, o as unbindThreadBindingsBySessionKey, r as listThreadBindingsBySessionKey } from "./thread-bindings-Bj1R-6QH.js";
+import { normalizeOptionalLowercaseString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/text-runtime";
+import { formatThreadBindingDisabledError, formatThreadBindingSpawnDisabledError, resolveThreadBindingSpawnPolicy } from "openclaw/plugin-sdk/conversation-runtime";
+//#region extensions/discord/src/subagent-hooks.ts
+var subagent_hooks_exports = /* @__PURE__ */ __exportAll({
+	handleDiscordSubagentDeliveryTarget: () => handleDiscordSubagentDeliveryTarget,
+	handleDiscordSubagentEnded: () => handleDiscordSubagentEnded,
+	handleDiscordSubagentSpawning: () => handleDiscordSubagentSpawning
+});
+function summarizeError(err) {
+	if (err instanceof Error) return err.message;
+	if (typeof err === "string") return err;
+	return "error";
+}
+function normalizeThreadBindingTargetKind(raw) {
+	const normalized = normalizeOptionalLowercaseString(raw);
+	if (normalized === "subagent" || normalized === "acp") return normalized;
+}
+async function handleDiscordSubagentSpawning(api, event) {
+	if (!event.threadRequested) return;
+	if (normalizeOptionalLowercaseString(event.requester?.channel) !== "discord") return;
+	const account = resolveDiscordAccount({
+		cfg: api.config,
+		accountId: event.requester?.accountId
+	});
+	const threadBindingPolicy = resolveThreadBindingSpawnPolicy({
+		cfg: api.config,
+		channel: "discord",
+		accountId: account.accountId,
+		kind: "subagent"
+	});
+	if (!threadBindingPolicy.enabled) return {
+		status: "error",
+		error: formatThreadBindingDisabledError({
+			channel: threadBindingPolicy.channel,
+			accountId: threadBindingPolicy.accountId,
+			kind: "subagent"
+		})
+	};
+	if (!threadBindingPolicy.spawnEnabled) return {
+		status: "error",
+		error: formatThreadBindingSpawnDisabledError({
+			channel: threadBindingPolicy.channel,
+			accountId: threadBindingPolicy.accountId,
+			kind: "subagent"
+		})
+	};
+	try {
+		const agentId = event.agentId?.trim() || "subagent";
+		if (!await autoBindSpawnedDiscordSubagent({
+			cfg: api.config,
+			accountId: account.accountId,
+			channel: event.requester?.channel,
+			to: event.requester?.to,
+			threadId: event.requester?.threadId,
+			childSessionKey: event.childSessionKey,
+			agentId,
+			label: event.label,
+			boundBy: "system"
+		})) return {
+			status: "error",
+			error: "Unable to create or bind a Discord thread for this subagent session. Session mode is unavailable for this target."
+		};
+		return {
+			status: "ok",
+			threadBindingReady: true
+		};
+	} catch (err) {
+		return {
+			status: "error",
+			error: `Discord thread bind failed: ${summarizeError(err)}`
+		};
+	}
+}
+function handleDiscordSubagentEnded(event) {
+	unbindThreadBindingsBySessionKey({
+		targetSessionKey: event.targetSessionKey,
+		accountId: event.accountId,
+		targetKind: normalizeThreadBindingTargetKind(event.targetKind),
+		reason: event.reason,
+		sendFarewell: event.sendFarewell
+	});
+}
+function handleDiscordSubagentDeliveryTarget(event) {
+	if (!event.expectsCompletionMessage) return;
+	if (normalizeOptionalLowercaseString(event.requesterOrigin?.channel) !== "discord") return;
+	const requesterAccountId = event.requesterOrigin?.accountId?.trim();
+	const requesterThreadId = event.requesterOrigin?.threadId != null && event.requesterOrigin.threadId !== "" ? normalizeOptionalStringifiedId(event.requesterOrigin.threadId) ?? "" : "";
+	const bindings = listThreadBindingsBySessionKey({
+		targetSessionKey: event.childSessionKey,
+		...requesterAccountId ? { accountId: requesterAccountId } : {},
+		targetKind: "subagent"
+	});
+	if (bindings.length === 0) return;
+	let binding;
+	if (requesterThreadId) binding = bindings.find((entry) => {
+		if (entry.threadId !== requesterThreadId) return false;
+		if (requesterAccountId && entry.accountId !== requesterAccountId) return false;
+		return true;
+	});
+	if (!binding && bindings.length === 1) binding = bindings[0];
+	if (!binding) return;
+	return { origin: {
+		channel: "discord",
+		accountId: binding.accountId,
+		to: `channel:${binding.threadId}`,
+		threadId: binding.threadId
+	} };
+}
+//#endregion
+export { subagent_hooks_exports as i, handleDiscordSubagentEnded as n, handleDiscordSubagentSpawning as r, handleDiscordSubagentDeliveryTarget as t };

package/dist/system-events-Bu9jmO4W.js

@@ -0,0 +1,34 @@
+import { t as discord_exports } from "./discord-D1kDh0X_.js";
+import { n as formatDiscordUserTag } from "./format-D8TsaXxW.js";
+//#region extensions/discord/src/monitor/system-events.ts
+function resolveDiscordSystemEvent(message, location) {
+	switch (message.type) {
+		case discord_exports.MessageType.ChannelPinnedMessage: return buildDiscordSystemEvent(message, location, "pinned a message");
+		case discord_exports.MessageType.RecipientAdd: return buildDiscordSystemEvent(message, location, "added a recipient");
+		case discord_exports.MessageType.RecipientRemove: return buildDiscordSystemEvent(message, location, "removed a recipient");
+		case discord_exports.MessageType.UserJoin: return buildDiscordSystemEvent(message, location, "user joined");
+		case discord_exports.MessageType.GuildBoost: return buildDiscordSystemEvent(message, location, "boosted the server");
+		case discord_exports.MessageType.GuildBoostTier1: return buildDiscordSystemEvent(message, location, "boosted the server (Tier 1 reached)");
+		case discord_exports.MessageType.GuildBoostTier2: return buildDiscordSystemEvent(message, location, "boosted the server (Tier 2 reached)");
+		case discord_exports.MessageType.GuildBoostTier3: return buildDiscordSystemEvent(message, location, "boosted the server (Tier 3 reached)");
+		case discord_exports.MessageType.ThreadCreated: return buildDiscordSystemEvent(message, location, "created a thread");
+		case discord_exports.MessageType.AutoModerationAction: return buildDiscordSystemEvent(message, location, "auto moderation action");
+		case discord_exports.MessageType.GuildIncidentAlertModeEnabled: return buildDiscordSystemEvent(message, location, "raid protection enabled");
+		case discord_exports.MessageType.GuildIncidentAlertModeDisabled: return buildDiscordSystemEvent(message, location, "raid protection disabled");
+		case discord_exports.MessageType.GuildIncidentReportRaid: return buildDiscordSystemEvent(message, location, "raid reported");
+		case discord_exports.MessageType.GuildIncidentReportFalseAlarm: return buildDiscordSystemEvent(message, location, "raid report marked false alarm");
+		case discord_exports.MessageType.StageStart: return buildDiscordSystemEvent(message, location, "stage started");
+		case discord_exports.MessageType.StageEnd: return buildDiscordSystemEvent(message, location, "stage ended");
+		case discord_exports.MessageType.StageSpeaker: return buildDiscordSystemEvent(message, location, "stage speaker updated");
+		case discord_exports.MessageType.StageTopic: return buildDiscordSystemEvent(message, location, "stage topic updated");
+		case discord_exports.MessageType.PollResult: return buildDiscordSystemEvent(message, location, "poll results posted");
+		case discord_exports.MessageType.PurchaseNotification: return buildDiscordSystemEvent(message, location, "purchase notification");
+		default: return null;
+	}
+}
+function buildDiscordSystemEvent(message, location, action) {
+	const authorLabel = message.author ? formatDiscordUserTag(message.author) : "";
+	return `Discord system: ${authorLabel ? `${authorLabel} ` : ""}${action} in ${location}`;
+}
+//#endregion
+export { resolveDiscordSystemEvent };

package/dist/targets-kKlbZ4ai.js

@@ -0,0 +1,3 @@
+import "./normalize-B-ktw-T_.js";
+import "./send.shared-Db0opnak.js";
+export {};

package/dist/test-api.js

@@ -0,0 +1,45 @@
+import { t as discordPlugin } from "./channel-B3aTtBj1.js";
+import { n as discordOutbound } from "./outbound-adapter-DJf9_sfH.js";
+import { t as __testing } from "./thread-bindings.manager-BaN0l4y8.js";
+import { n as buildDiscordInboundAccessContext } from "./inbound-context-e_oBBJtF.js";
+import { finalizeInboundContext } from "openclaw/plugin-sdk/reply-dispatch-runtime";
+//#region extensions/discord/src/monitor/inbound-context.test-helpers.ts
+function buildFinalizedDiscordDirectInboundContext() {
+	const { groupSystemPrompt, ownerAllowFrom, untrustedContext } = buildDiscordInboundAccessContext({
+		channelConfig: null,
+		guildInfo: null,
+		sender: {
+			id: "U1",
+			name: "Alice",
+			tag: "alice"
+		},
+		isGuild: false
+	});
+	return finalizeInboundContext({
+		Body: "hi",
+		BodyForAgent: "hi",
+		RawBody: "hi",
+		CommandBody: "hi",
+		From: "discord:U1",
+		To: "user:U1",
+		SessionKey: "agent:main:discord:direct:u1",
+		AccountId: "default",
+		ChatType: "direct",
+		ConversationLabel: "Alice",
+		SenderName: "Alice",
+		SenderId: "U1",
+		SenderUsername: "alice",
+		GroupSystemPrompt: groupSystemPrompt,
+		OwnerAllowFrom: ownerAllowFrom,
+		UntrustedContext: untrustedContext,
+		Provider: "discord",
+		Surface: "discord",
+		WasMentioned: false,
+		MessageSid: "m1",
+		CommandAuthorized: true,
+		OriginatingChannel: "discord",
+		OriginatingTo: "user:U1"
+	});
+}
+//#endregion
+export { buildFinalizedDiscordDirectInboundContext, discordOutbound, discordPlugin, __testing as discordThreadBindingTesting };

package/dist/thread-binding-api.js

@@ -0,0 +1,4 @@
+//#region extensions/discord/thread-binding-api.ts
+const defaultTopLevelPlacement = "child";
+//#endregion
+export { defaultTopLevelPlacement };