@openclaw/discord 2026.7.1-beta.1 → 2026.7.1-beta.4

package/dist/{outbound-adapter-B0iwUl6c.js → outbound-adapter-82RWi_SR.js}

@@ -1,48 +1,14 @@
-import { o as normalizeDiscordOutboundTarget, s as chunkDiscordTextWithMode, t as createDiscordSendReceipt, x as DiscordError } from "./send.receipt-CK162xD0.js";
-import { s as resolveDiscordAccount } from "./accounts-P19jm1lf.js";
-import { d as readDiscordComponentSpec } from "./components-CBPNJhVP.js";
-import { t as parseDiscordRetryAfterBodySeconds } from "./retry-after-D5_VmM-_.js";
+import { a as resolveDiscordReplyReference, l as normalizeDiscordOutboundTarget, t as createDiscordSendReceipt, u as chunkDiscordTextWithMode } from "./send.receipt-BpBQED_5.js";
+import { d as readDiscordComponentSpec } from "./components-BIBizbtZ.js";
 import { n as notifyDiscordInboundEventOutboundPayloadSuccess } from "./inbound-event-delivery-CEPlt2uz.js";
+import { createLazyRuntimeModule, createLazyRuntimeNamedExport } from "openclaw/plugin-sdk/lazy-runtime";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { resolvePayloadMediaUrls, sendPayloadMediaSequenceOrFallback, sendTextMediaPayload } from "openclaw/plugin-sdk/reply-payload";
-import { resolveRetryConfig, retryAsync } from "openclaw/plugin-sdk/retry-runtime";
+import { getReplyPayloadTtsSupplement, resolvePayloadMediaUrls, sendPayloadMediaSequenceOrFallback, sendTextMediaPayload } from "openclaw/plugin-sdk/reply-payload";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createReplyToFanout, resolveOutboundSendDep } from "openclaw/plugin-sdk/channel-outbound";
 import { attachChannelToResult, createAttachedChannelResultAdapter } from "openclaw/plugin-sdk/channel-send-result";
-//#region extensions/discord/src/delivery-retry.ts
-const DISCORD_DELIVERY_RETRY_DEFAULTS = {
-	attempts: 3,
-	minDelayMs: 1e3,
-	maxDelayMs: 3e4,
-	jitter: 0
-};
-function isRetryableDiscordDeliveryError(err) {
-	if (err instanceof DiscordError) return false;
-	const status = err.status ?? err.statusCode;
-	return status === 429 || status !== void 0 && status >= 500;
-}
-function getDiscordDeliveryRetryAfterMs(err) {
-	if (!err || typeof err !== "object") return;
-	const retryAfterSeconds = "retryAfter" in err ? parseDiscordRetryAfterBodySeconds(err.retryAfter) : void 0;
-	if (retryAfterSeconds !== void 0) return retryAfterSeconds * 1e3;
-	const retryAfterRaw = err.headers?.["retry-after"];
-	if (!retryAfterRaw) return;
-	const headerSeconds = parseDiscordRetryAfterBodySeconds(retryAfterRaw);
-	return headerSeconds === void 0 ? void 0 : headerSeconds * 1e3;
-}
-async function withDiscordDeliveryRetry(params) {
-	const retryConfig = resolveRetryConfig(DISCORD_DELIVERY_RETRY_DEFAULTS, resolveDiscordAccount({
-		cfg: params.cfg,
-		accountId: params.accountId
-	}).config.retry);
-	return await retryAsync(params.fn, {
-		...retryConfig,
-		shouldRetry: (err) => isRetryableDiscordDeliveryError(err),
-		retryAfterMs: getDiscordDeliveryRetryAfterMs
-	});
-}
-//#endregion
 //#region extensions/discord/src/media-detection.ts
-const DISCORD_VIDEO_MEDIA_EXTENSIONS = new Set([
+const DISCORD_VIDEO_MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
 	".avi",
 	".m4v",
 	".mkv",
@@ -83,16 +49,11 @@ function normalizeDiscordApprovalPayload(payload) {
 }
 //#endregion
 //#region extensions/discord/src/outbound-components.ts
-let discordComponentSendPromise;
-let discordSharedInteractivePromise;
+const loadDiscordComponentSend = createLazyRuntimeNamedExport(() => import("./send.components-D0I39utR.js").then((n) => n.i), "sendDiscordComponentMessage");
 async function sendDiscordComponentMessageLazy(...args) {
-	discordComponentSendPromise ??= import("./send.components-Cmv2qMB5.js").then((n) => n.i).then((module) => module.sendDiscordComponentMessage);
-	return await (await discordComponentSendPromise)(...args);
-}
-function loadDiscordSharedInteractive() {
-	discordSharedInteractivePromise ??= import("./components-CBPNJhVP.js").then((n) => n.a);
-	return discordSharedInteractivePromise;
+	return await (await loadDiscordComponentSend())(...args);
 }
+const loadDiscordSharedInteractive = createLazyRuntimeModule(() => import("./components-BIBizbtZ.js").then((n) => n.a));
 function addPayloadTextFallback(spec, payload) {
 	return spec.text ? spec : {
 		...spec,
@@ -123,11 +84,7 @@ async function resolveDiscordComponentSpec(payload) {
 }
 //#endregion
 //#region extensions/discord/src/outbound-send-context.ts
-let discordSendRuntimePromise;
-async function loadDiscordSendRuntime() {
-	discordSendRuntimePromise ??= import("./send-BYTToRY1.js").then((n) => n.t);
-	return await discordSendRuntimePromise;
-}
+const loadDiscordSendRuntime = createLazyRuntimeModule(() => import("./send-iJ0B4bAX.js").then((n) => n.t));
 function resolveDiscordOutboundTarget(params) {
 	if (params.threadId == null) return params.to;
 	const threadId = normalizeOptionalStringifiedId(params.threadId) ?? "";
@@ -145,28 +102,29 @@ function resolveDiscordFormattingOptions(ctx) {
 }
 async function createDiscordPayloadSendContext(ctx) {
 	const runtime = await loadDiscordSendRuntime();
+	const nextReplyToId = createReplyToFanout(ctx);
 	return {
 		target: resolveDiscordOutboundTarget({
 			to: ctx.to,
 			threadId: ctx.threadId
 		}),
 		formatting: resolveDiscordFormattingOptions(ctx),
-		resolveReplyTo: createReplyToFanout({
-			replyToId: ctx.replyToId,
+		resolveReply: () => resolveDiscordReplyReference({
+			replyToId: nextReplyToId(),
 			replyToIdSource: ctx.replyToIdSource,
 			replyToMode: ctx.replyToMode
 		}),
 		send: resolveOutboundSendDep(ctx.deps, "discord") ?? runtime.sendMessageDiscord,
-		sendVoice: resolveOutboundSendDep(ctx.deps, "discordVoice") ?? runtime.sendVoiceMessageDiscord,
-		withRetry: async (fn) => await withDiscordDeliveryRetry({
-			cfg: ctx.cfg,
-			accountId: ctx.accountId,
-			fn
-		})
+		sendVoice: resolveOutboundSendDep(ctx.deps, "discordVoice") ?? runtime.sendVoiceMessageDiscord
 	};
 }
 //#endregion
 //#region extensions/discord/src/outbound-payload.ts
+function resolveDiscordDeliveryProgress(ctx) {
+	return ctx.onDeliveryResult ? async (result) => {
+		await ctx.onDeliveryResult?.(attachChannelToResult("discord", result));
+	} : void 0;
+}
 function createDiscordUnknownPayloadResult(target) {
 	return {
 		messageId: "",
@@ -178,17 +136,17 @@ function createDiscordUnknownPayloadResult(target) {
 		})
 	};
 }
-function resolveDiscordDeliveryOptions(ctx, sendContext) {
+function resolveDiscordDeliveryOptions(ctx, sendContext, reply = sendContext.resolveReply()) {
 	return {
-		replyTo: sendContext.resolveReplyTo(),
+		reply,
 		accountId: ctx.accountId ?? void 0,
 		silent: ctx.silent ?? void 0,
 		cfg: ctx.cfg
 	};
 }
-function resolveDiscordFormattedDeliveryOptions(ctx, sendContext) {
+function resolveDiscordFormattedDeliveryOptions(ctx, sendContext, reply = sendContext.resolveReply()) {
 	return {
-		...resolveDiscordDeliveryOptions(ctx, sendContext),
+		...resolveDiscordDeliveryOptions(ctx, sendContext, reply),
 		...sendContext.formatting
 	};
 }
@@ -210,21 +168,36 @@ async function sendDiscordOutboundPayload(params) {
 	const mediaUrls = resolvePayloadMediaUrls(payload);
 	const sendContext = await createDiscordPayloadSendContext(ctx);
 	if (payload.audioAsVoice && mediaUrls.length > 0) {
-		const voiceReplyTo = sendContext.resolveReplyTo();
-		let lastResult = await sendContext.withRetry(async () => await sendContext.sendVoice(sendContext.target, mediaUrls[0], {
-			...resolveDiscordDeliveryOptions(ctx, sendContext),
-			replyTo: voiceReplyTo
-		}));
-		if (payload.text?.trim()) lastResult = await sendContext.withRetry(async () => await sendContext.send(sendContext.target, payload.text, {
+		const voiceReply = sendContext.resolveReply();
+		let deliveredVoice = false;
+		let lastResult;
+		try {
+			lastResult = await sendContext.sendVoice(sendContext.target, mediaUrls[0], { ...resolveDiscordDeliveryOptions(ctx, sendContext, voiceReply) });
+			deliveredVoice = true;
+		} catch (err) {
+			const supplement = getReplyPayloadTtsSupplement(payload);
+			const visibleFallbackText = payload.text?.trim() ? payload.text : void 0;
+			const hiddenFallbackText = supplement?.visibleTextAlreadyDelivered ? void 0 : supplement?.spokenText;
+			const fallbackText = visibleFallbackText ?? hiddenFallbackText;
+			if (!fallbackText) if (supplement?.visibleTextAlreadyDelivered) lastResult = createDiscordUnknownPayloadResult(sendContext.target);
+			else throw err;
+			else lastResult = await sendContext.send(sendContext.target, fallbackText, {
+				verbose: false,
+				...resolveDiscordFormattedDeliveryOptions(ctx, sendContext, voiceReply),
+				onDeliveryResult: resolveDiscordDeliveryProgress(ctx)
+			});
+		}
+		if (deliveredVoice) await ctx.onDeliveryResult?.(attachChannelToResult("discord", lastResult));
+		if (deliveredVoice && payload.text?.trim()) lastResult = await sendContext.send(sendContext.target, payload.text, {
 			verbose: false,
 			...resolveDiscordFormattedDeliveryOptions(ctx, sendContext),
-			replyTo: voiceReplyTo
-		}));
-		for (const mediaUrl of mediaUrls.slice(1)) lastResult = await sendContext.withRetry(async () => await sendContext.send(sendContext.target, "", {
+			onDeliveryResult: resolveDiscordDeliveryProgress(ctx)
+		});
+		for (const mediaUrl of mediaUrls.slice(1)) lastResult = await sendContext.send(sendContext.target, "", {
 			verbose: false,
 			...resolveDiscordMediaDeliveryOptions(ctx, sendContext, mediaUrl),
-			replyTo: voiceReplyTo
-		}));
+			onDeliveryResult: resolveDiscordDeliveryProgress(ctx)
+		});
 		return attachChannelToResult("discord", lastResult);
 	}
 	const componentSpec = await resolveDiscordComponentSpec(payload);
@@ -237,20 +210,22 @@ async function sendDiscordOutboundPayload(params) {
 			text: payload.text ?? "",
 			mediaUrls,
 			fallbackResult: createDiscordUnknownPayloadResult(sendContext.target),
-			sendNoMedia: async () => await sendContext.withRetry(async () => await sendContext.send(sendContext.target, payload.text ?? "", {
+			sendNoMedia: async () => await sendContext.send(sendContext.target, payload.text ?? "", {
 				verbose: false,
 				components: nativeComponents,
 				embeds,
 				filename,
-				...resolveDiscordFormattedDeliveryOptions(ctx, sendContext)
-			})),
-			send: async ({ text, mediaUrl, isFirst }) => await sendContext.withRetry(async () => await sendContext.send(sendContext.target, text, {
+				...resolveDiscordFormattedDeliveryOptions(ctx, sendContext),
+				onDeliveryResult: resolveDiscordDeliveryProgress(ctx)
+			}),
+			send: async ({ text, mediaUrl, isFirst }) => await sendContext.send(sendContext.target, text, {
 				verbose: false,
 				...resolveDiscordMediaDeliveryOptions(ctx, sendContext, mediaUrl),
 				components: isFirst ? nativeComponents : void 0,
 				embeds: isFirst ? embeds : void 0,
-				filename: isFirst ? filename : void 0
-			}))
+				filename: isFirst ? filename : void 0,
+				onDeliveryResult: resolveDiscordDeliveryProgress(ctx)
+			})
 		}));
 		return await sendTextMediaPayload({
 			channel: "discord",
@@ -265,13 +240,22 @@ async function sendDiscordOutboundPayload(params) {
 		text: payload.text ?? "",
 		mediaUrls,
 		fallbackResult: createDiscordUnknownPayloadResult(sendContext.target),
-		sendNoMedia: async () => await sendContext.withRetry(async () => await sendDiscordComponentMessageLazy(sendContext.target, componentSpec, { ...resolveDiscordFormattedDeliveryOptions(ctx, sendContext) })),
+		sendNoMedia: async () => {
+			return await sendDiscordComponentMessageLazy(sendContext.target, componentSpec, {
+				...resolveDiscordFormattedDeliveryOptions(ctx, sendContext),
+				onDeliveryResult: resolveDiscordDeliveryProgress(ctx)
+			});
+		},
 		send: async ({ text, mediaUrl, isFirst }) => {
-			if (isFirst) return await sendContext.withRetry(async () => await sendDiscordComponentMessageLazy(sendContext.target, componentSpec, { ...resolveDiscordMediaDeliveryOptions(ctx, sendContext, mediaUrl) }));
-			return await sendContext.withRetry(async () => await sendContext.send(sendContext.target, text, {
+			if (isFirst) return await sendDiscordComponentMessageLazy(sendContext.target, componentSpec, {
+				...resolveDiscordMediaDeliveryOptions(ctx, sendContext, mediaUrl),
+				onDeliveryResult: resolveDiscordDeliveryProgress(ctx)
+			});
+			return await sendContext.send(sendContext.target, text, {
 				verbose: false,
-				...resolveDiscordMediaDeliveryOptions(ctx, sendContext, mediaUrl)
-			}));
+				...resolveDiscordMediaDeliveryOptions(ctx, sendContext, mediaUrl),
+				onDeliveryResult: resolveDiscordDeliveryProgress(ctx)
+			});
 		}
 	}));
 }
@@ -284,16 +268,12 @@ const DISCORD_INTERNAL_RUNTIME_SCAFFOLDING_TAG_RE = /<\s*\/?\s*(?:system-reminde
 function stripDiscordInternalRuntimeScaffolding(text) {
 	return text.replace(DISCORD_INTERNAL_RUNTIME_SCAFFOLDING_BLOCK_RE, "").replace(DISCORD_INTERNAL_RUNTIME_SCAFFOLDING_SELF_CLOSING_RE, "").replace(DISCORD_INTERNAL_RUNTIME_SCAFFOLDING_TAG_RE, "");
 }
-let discordThreadBindingsPromise;
-function loadDiscordThreadBindings() {
-	discordThreadBindingsPromise ??= import("./thread-bindings-C1yhwdOw.js").then((n) => n.t);
-	return discordThreadBindingsPromise;
-}
+const loadDiscordThreadBindings = createLazyRuntimeModule(() => import("./thread-bindings-DsTxqu3E.js").then((n) => n.t));
 function resolveDiscordWebhookIdentity(params) {
 	const usernameRaw = normalizeOptionalString(params.identity?.name);
 	const fallbackUsername = normalizeOptionalString(params.binding.label) ?? params.binding.agentId;
 	return {
-		username: (usernameRaw || fallbackUsername || "").slice(0, 80) || void 0,
+		username: truncateUtf16Safe(usernameRaw || fallbackUsername || "", 80) || void 0,
 		avatarUrl: normalizeOptionalString(params.identity?.avatarUrl)
 	};
 }
@@ -381,7 +361,7 @@ const discordOutbound = {
 	}),
 	...createAttachedChannelResultAdapter({
 		channel: "discord",
-		sendText: async ({ cfg, to, text, accountId, deps, replyToId, threadId, identity, silent, formatting }) => {
+		sendText: async ({ cfg, to, text, accountId, deps, replyToId, replyToIdSource, replyToMode, threadId, identity, silent, formatting, onDeliveryResult }) => {
 			if (!silent) {
 				const webhookResult = await maybeSendDiscordWebhookText({
 					cfg,
@@ -393,100 +373,94 @@ const discordOutbound = {
 				}).catch(() => null);
 				if (webhookResult) return webhookResult;
 			}
-			const send = resolveOutboundSendDep(deps, "discord") ?? (await loadDiscordSendRuntime()).sendMessageDiscord;
-			return await withDiscordDeliveryRetry({
+			return await (resolveOutboundSendDep(deps, "discord") ?? (await loadDiscordSendRuntime()).sendMessageDiscord)(resolveDiscordOutboundTarget({
+				to,
+				threadId
+			}), text, {
+				verbose: false,
+				reply: resolveDiscordReplyReference({
+					replyToId,
+					replyToIdSource,
+					replyToMode
+				}),
+				accountId: accountId ?? void 0,
+				silent: silent ?? void 0,
 				cfg,
-				accountId,
-				fn: async () => await send(resolveDiscordOutboundTarget({
-					to,
-					threadId
-				}), text, {
-					verbose: false,
-					replyTo: replyToId ?? void 0,
-					accountId: accountId ?? void 0,
-					silent: silent ?? void 0,
-					cfg,
-					...resolveDiscordFormattingOptions({ formatting })
-				})
+				...resolveDiscordFormattingOptions({ formatting }),
+				onDeliveryResult: onDeliveryResult ? async (result) => {
+					await onDeliveryResult(attachChannelToResult("discord", result));
+				} : void 0
 			});
 		},
-		sendMedia: async ({ cfg, to, text, mediaUrl, audioAsVoice, mediaAccess, mediaLocalRoots, mediaReadFile, accountId, deps, replyToId, threadId, silent, formatting }) => {
+		sendMedia: async ({ cfg, to, text, mediaUrl, audioAsVoice, mediaAccess, mediaLocalRoots, mediaReadFile, accountId, deps, replyToId, replyToIdSource, replyToMode, threadId, silent, formatting, onDeliveryResult }) => {
 			const send = resolveOutboundSendDep(deps, "discord") ?? (await loadDiscordSendRuntime()).sendMessageDiscord;
 			const target = resolveDiscordOutboundTarget({
 				to,
 				threadId
 			});
 			const formattingOptions = resolveDiscordFormattingOptions({ formatting });
-			if (audioAsVoice && mediaUrl) {
-				const sendVoice = resolveOutboundSendDep(deps, "discordVoice") ?? (await loadDiscordSendRuntime()).sendVoiceMessageDiscord;
-				return await withDiscordDeliveryRetry({
-					cfg,
-					accountId,
-					fn: async () => await sendVoice(target, mediaUrl, {
-						cfg,
-						replyTo: replyToId ?? void 0,
-						accountId: accountId ?? void 0,
-						silent: silent ?? void 0
-					})
-				});
-			}
+			const reply = resolveDiscordReplyReference({
+				replyToId,
+				replyToIdSource,
+				replyToMode
+			});
+			if (audioAsVoice && mediaUrl) return await (resolveOutboundSendDep(deps, "discordVoice") ?? (await loadDiscordSendRuntime()).sendVoiceMessageDiscord)(target, mediaUrl, {
+				cfg,
+				reply,
+				accountId: accountId ?? void 0,
+				silent: silent ?? void 0
+			});
 			if (text.trim() && mediaUrl && isLikelyDiscordVideoMedia(mediaUrl)) {
-				await withDiscordDeliveryRetry({
-					cfg,
-					accountId,
-					fn: async () => await send(target, text, {
-						verbose: false,
-						replyTo: replyToId ?? void 0,
-						accountId: accountId ?? void 0,
-						silent: silent ?? void 0,
-						cfg,
-						...formattingOptions
-					})
-				});
-				return await withDiscordDeliveryRetry({
+				await send(target, text, {
+					verbose: false,
+					reply,
+					accountId: accountId ?? void 0,
+					silent: silent ?? void 0,
 					cfg,
-					accountId,
-					fn: async () => await send(target, "", {
-						verbose: false,
-						mediaUrl,
-						mediaAccess,
-						mediaLocalRoots,
-						mediaReadFile,
-						accountId: accountId ?? void 0,
-						silent: silent ?? void 0,
-						cfg,
-						...formattingOptions
-					})
+					...formattingOptions,
+					onDeliveryResult: onDeliveryResult ? async (result) => {
+						await onDeliveryResult(attachChannelToResult("discord", result));
+					} : void 0
 				});
-			}
-			return await withDiscordDeliveryRetry({
-				cfg,
-				accountId,
-				fn: async () => await send(target, text, {
+				return await send(target, "", {
 					verbose: false,
 					mediaUrl,
+					reply: reply?.scope === "all" ? reply : void 0,
 					mediaAccess,
 					mediaLocalRoots,
 					mediaReadFile,
-					replyTo: replyToId ?? void 0,
 					accountId: accountId ?? void 0,
 					silent: silent ?? void 0,
 					cfg,
-					...formattingOptions
-				})
-			});
-		},
-		sendPoll: async ({ cfg, to, poll, accountId, threadId, silent }) => await withDiscordDeliveryRetry({
-			cfg,
-			accountId,
-			fn: async () => await (await loadDiscordSendRuntime()).sendPollDiscord(resolveDiscordOutboundTarget({
-				to,
-				threadId
-			}), poll, {
+					...formattingOptions,
+					onDeliveryResult: onDeliveryResult ? async (result) => {
+						await onDeliveryResult(attachChannelToResult("discord", result));
+					} : void 0
+				});
+			}
+			return await send(target, text, {
+				verbose: false,
+				mediaUrl,
+				mediaAccess,
+				mediaLocalRoots,
+				mediaReadFile,
+				reply,
 				accountId: accountId ?? void 0,
 				silent: silent ?? void 0,
-				cfg
-			})
+				cfg,
+				...formattingOptions,
+				onDeliveryResult: onDeliveryResult ? async (result) => {
+					await onDeliveryResult(attachChannelToResult("discord", result));
+				} : void 0
+			});
+		},
+		sendPoll: async ({ cfg, to, poll, accountId, threadId, silent }) => await (await loadDiscordSendRuntime()).sendPollDiscord(resolveDiscordOutboundTarget({
+			to,
+			threadId
+		}), poll, {
+			accountId: accountId ?? void 0,
+			silent: silent ?? void 0,
+			cfg
 		})
 	}),
 	afterDeliverPayload: async ({ target, payload }) => {

package/dist/{pluralkit-DaWTJTmF.js → pluralkit-DcD-3EcL.js}

@@ -1,4 +1,4 @@
-import { Wt as __exportAll } from "./send.receipt-CK162xD0.js";
+import { Jt as __exportAll } from "./send.receipt-BpBQED_5.js";
 import { resolveFetch } from "openclaw/plugin-sdk/fetch-runtime";
 import { readProviderJsonResponse, readResponseTextLimited } from "openclaw/plugin-sdk/provider-http";
 //#region extensions/discord/src/pluralkit.ts

package/dist/{preflight-audio-ClWbnQto.js → preflight-audio-DYL2ABgA.js}

@@ -1,13 +1,10 @@
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { getFileExtension } from "openclaw/plugin-sdk/media-mime";
 //#region extensions/discord/src/monitor/preflight-audio.ts
-let discordPreflightAudioRuntimePromise;
-function loadDiscordPreflightAudioRuntime() {
-	discordPreflightAudioRuntimePromise ??= import("./preflight-audio.runtime-CoCXMM8r.js");
-	return discordPreflightAudioRuntimePromise;
-}
-const AUDIO_ATTACHMENT_MIME_BY_EXT = new Map([
+const loadDiscordPreflightAudioRuntime = createLazyRuntimeModule(() => import("./preflight-audio.runtime-CoCXMM8r.js"));
+const AUDIO_ATTACHMENT_MIME_BY_EXT = /* @__PURE__ */ new Map([
 	[".aac", "audio/aac"],
 	[".caf", "audio/x-caf"],
 	[".flac", "audio/flac"],

package/dist/presence-cache-z1N8MbJ3.js

@@ -0,0 +1,45 @@
+//#region extensions/discord/src/monitor/presence-cache.ts
+/**
+* In-memory cache of Discord user presence data.
+* Populated by PRESENCE_UPDATE gateway events when the GuildPresences intent is enabled.
+* Per-account maps are capped to prevent unbounded growth (#4948).
+*/
+const MAX_PRESENCE_PER_ACCOUNT = 5e3;
+const presenceCache = /* @__PURE__ */ new Map();
+function resolveAccountKey(accountId) {
+	return accountId ?? "default";
+}
+/** Update cached presence for a user. */
+function setPresence(accountId, userId, data) {
+	const accountKey = resolveAccountKey(accountId);
+	let accountCache = presenceCache.get(accountKey);
+	if (!accountCache) {
+		accountCache = /* @__PURE__ */ new Map();
+		presenceCache.set(accountKey, accountCache);
+	}
+	accountCache.set(userId, data);
+	if (accountCache.size > MAX_PRESENCE_PER_ACCOUNT) {
+		const oldest = accountCache.keys().next().value;
+		if (oldest !== void 0) accountCache.delete(oldest);
+	}
+}
+/** Get cached presence for a user. Returns undefined if not cached. */
+function getPresence(accountId, userId) {
+	return presenceCache.get(resolveAccountKey(accountId))?.get(userId);
+}
+/** Clear cached presence data. */
+function clearPresences(accountId) {
+	if (accountId) {
+		presenceCache.delete(resolveAccountKey(accountId));
+		return;
+	}
+	presenceCache.clear();
+}
+/** Get the number of cached presence entries. */
+function presenceCacheSize() {
+	let total = 0;
+	for (const accountCache of presenceCache.values()) total += accountCache.size;
+	return total;
+}
+//#endregion
+export { setPresence as i, getPresence as n, presenceCacheSize as r, clearPresences as t };

package/dist/{probe-Bkf8mJlj.js → probe-D1ImJEo2.js}

@@ -1,7 +1,7 @@
 import { p as normalizeDiscordToken } from "./accounts-P19jm1lf.js";
-import { n as fetchDiscord, t as DiscordApiError } from "./api-CJvEMuA6.js";
-import { resolveFetch } from "openclaw/plugin-sdk/fetch-runtime";
+import { n as fetchDiscord, t as DiscordApiError } from "./api-DPRqYi4Z.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { resolveFetch } from "openclaw/plugin-sdk/fetch-runtime";
 import { readProviderJsonResponse } from "openclaw/plugin-sdk/provider-http";
 import { fetchWithTimeout } from "openclaw/plugin-sdk/text-utility-runtime";
 //#region extensions/discord/src/probe.ts

package/dist/{probe.runtime-3Rerer9g.js → probe.runtime-B1dsEeBD.js}

@@ -1,2 +1,2 @@
-import { a as resolveDiscordPrivilegedIntentsFromFlags, i as probeDiscord, n as fetchDiscordApplicationSummary, r as parseApplicationIdFromToken, t as fetchDiscordApplicationId } from "./probe-Bkf8mJlj.js";
+import { a as resolveDiscordPrivilegedIntentsFromFlags, i as probeDiscord, n as fetchDiscordApplicationSummary, r as parseApplicationIdFromToken, t as fetchDiscordApplicationId } from "./probe-D1ImJEo2.js";
 export { fetchDiscordApplicationId, fetchDiscordApplicationSummary, parseApplicationIdFromToken, probeDiscord, resolveDiscordPrivilegedIntentsFromFlags };