@openclaw/discord 2026.8.1-beta.3 → 2026.8.2

package/dist/{retry-DNsVTeTo.js → retry-t5RcEsPk.js}

@@ -1,23 +1,25 @@
-import { t as parseDiscordRetryAfterBodySeconds } from "./retry-after-DdLPmPoa.js";
-import { k as parseDiscordTarget } from "./accounts-DNl-oCEw.js";
+import { t as parseDiscordRetryAfterBodySeconds } from "./retry-after-BrLjLUJi.js";
 import "node:module";
 import { redactIdentifier, redactSensitiveFieldValue } from "openclaw/plugin-sdk/logging-core";
 import { ApplicationCommandOptionType, ApplicationCommandType, ButtonStyle, ComponentType, GatewayDispatchEvents, InteractionContextType, InteractionResponseType, InteractionType, MessageFlags, Routes, TextInputStyle } from "discord-api-types/v10";
+import { Type } from "typebox";
+import { Check } from "typebox/value";
 import { createHash } from "node:crypto";
 import { asDateTimestampMs, clampTimerTimeoutMs, parseStrictNonNegativeInteger, resolveExpiresAtMsFromDurationMs, resolveIntegerOption, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
-import { Type } from "typebox";
-import { Check } from "typebox/value";
 import { inspect } from "node:util";
 import { gunzipSync } from "node:zlib";
 import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
 import { collectErrorGraphCandidates, extractErrorCode, formatErrorMessage, readErrorName } from "openclaw/plugin-sdk/error-runtime";
 import { classifyTransientNetworkErrorCode, createChannelApiRetryRunner, parseRetryAfterHeaderSeconds, resolveRetryConfig, retryAsync } from "openclaw/plugin-sdk/retry-runtime";
+import { buildMessagingTarget, parseMentionPrefixOrAtUserTarget, requireTargetKind } from "openclaw/plugin-sdk/channel-targets";
 import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { resolveAllowlistMatchByCandidates } from "openclaw/plugin-sdk/allow-from";
 import { chunkMarkdownTextWithMode } from "openclaw/plugin-sdk/reply-chunking";
 import { chunkTextForOutbound } from "openclaw/plugin-sdk/text-chunking";
 import { isSingleUseReplyToMode } from "openclaw/plugin-sdk/reply-reference";
+import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
+import { attachChannelToResults } from "openclaw/plugin-sdk/channel-send-result";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -65,6 +67,11 @@ async function overwriteGuildApplicationCommands(rest, clientId, guildId, body)
 }
 //#endregion
 //#region extensions/discord/src/internal/api.guild.ts
+const discordGuildEmojiListSchema = Type.Array(Type.Object({
+	id: Type.Union([Type.String(), Type.Null()]),
+	name: Type.Union([Type.String(), Type.Null()]),
+	animated: Type.Optional(Type.Boolean())
+}, { additionalProperties: true }));
 async function getGuild(rest, guildId) {
 	return await rest.get(Routes.guild(guildId));
 }
@@ -117,7 +124,9 @@ async function createGuildBan(rest, guildId, userId, data) {
 	await rest.put(Routes.guildBan(guildId, userId), data);
 }
 async function listGuildEmojis(rest, guildId) {
-	return await rest.get(Routes.guildEmojis(guildId));
+	const emojis = await rest.get(Routes.guildEmojis(guildId));
+	if (!Check(discordGuildEmojiListSchema, emojis)) throw new Error("Invalid Discord guild emoji response.");
+	return emojis;
 }
 async function createGuildEmoji(rest, guildId, data) {
 	return await rest.post(Routes.guildEmojis(guildId), data);
@@ -1166,6 +1175,9 @@ var DiscordEntityCache = class {
 			return new GuildMember(this.params.client, raw);
 		});
 	}
+	async fetchGuildEmojis(guildId, fetcher) {
+		return await this.fetchCached(`guild-emojis:${guildId}`, fetcher);
+	}
 	invalidateForGatewayEvent(type, data) {
 		const raw = data && typeof data === "object" ? data : {};
 		const channelUpdate = GatewayDispatchEvents.ChannelUpdate;
@@ -1173,11 +1185,13 @@ var DiscordEntityCache = class {
 		const threadUpdate = GatewayDispatchEvents.ThreadUpdate;
 		const threadDelete = GatewayDispatchEvents.ThreadDelete;
 		const guildUpdate = GatewayDispatchEvents.GuildUpdate;
+		const guildEmojisUpdate = GatewayDispatchEvents.GuildEmojisUpdate;
 		const guildMemberAdd = GatewayDispatchEvents.GuildMemberAdd;
 		const guildMemberRemove = GatewayDispatchEvents.GuildMemberRemove;
 		const guildMemberUpdate = GatewayDispatchEvents.GuildMemberUpdate;
 		if (type === channelUpdate || type === channelDelete || type === threadUpdate || type === threadDelete) this.deleteId("channel", raw.id);
 		if (type === guildUpdate) this.deleteId("guild", raw.id);
+		if (type === guildEmojisUpdate) this.deleteId("guild-emojis", raw.guild_id);
 		if (type === guildMemberAdd || type === guildMemberRemove || type === guildMemberUpdate) {
 			const guildId = raw.guild_id;
 			const user = raw.user && typeof raw.user === "object" ? raw.user : {};
@@ -1662,6 +1676,7 @@ var BaseInteraction = class {
 		this.message = null;
 		this.response = new InteractionResponseController();
 		this.pendingResponse = Promise.resolve();
+		this.sentFollowUp = false;
 		this.id = rawData.id;
 		this.token = rawData.token;
 		this.user = readInteractionUser(rawData, client);
@@ -1678,6 +1693,14 @@ var BaseInteraction = class {
 	set responseState(nextState) {
 		this.response.state = nextState;
 	}
+	/**
+	* True once a follow-up message has been delivered. Follow-ups are visible to
+	* the user but never advance `responseState`, so this is the only record that
+	* the interaction has already produced output.
+	*/
+	get hasSentFollowUp() {
+		return this.sentFollowUp;
+	}
 	enqueueResponse(operation) {
 		const result = this.pendingResponse.then(operation);
 		this.pendingResponse = result.then(() => void 0, () => void 0);
@@ -1712,6 +1735,24 @@ var BaseInteraction = class {
 	async editReply(payload) {
 		return await this.enqueueResponse(() => this.performReplyEdit(payload));
 	}
+	/**
+	* Edits the deferred placeholder only if this interaction is still an
+	* unanswered spinner when the queue reaches this operation.
+	*
+	* Both conditions are re-read inside the queue. A follow-up that was still in
+	* flight when the caller decided to report will have settled — and recorded
+	* itself in `sentFollowUp` — by the time this runs, so the decision cannot be
+	* made against state that is about to change.
+	*
+	* Resolves true when the edit was sent.
+	*/
+	async editDeferredPlaceholderIfUnanswered(payload) {
+		return await this.enqueueResponse(async () => {
+			if (this.responseState !== "deferred" || this.sentFollowUp) return false;
+			await this.performReplyEdit(payload);
+			return true;
+		});
+	}
 	async performReplyEdit(payload) {
 		const body = serializePayload(payload);
 		const query = needsComponentsV2Query(body) ? { with_components: true } : void 0;
@@ -1741,7 +1782,9 @@ var BaseInteraction = class {
 	}
 	async performFollowUp(payload) {
 		const body = serializePayload(payload);
-		return await createWebhookMessage(this.client.rest, this.client.options.clientId, this.token, { body }, needsComponentsV2Query(body) ? { with_components: true } : void 0);
+		const result = await createWebhookMessage(this.client.rest, this.client.options.clientId, this.token, { body }, needsComponentsV2Query(body) ? { with_components: true } : void 0);
+		this.sentFollowUp = true;
+		return result;
 	}
 };
 var CommandInteraction = class extends BaseInteraction {
@@ -1830,6 +1873,14 @@ async function dispatchInteraction(client, rawData) {
 		if (command.commandKind === "leaf") await command.autocomplete(autocompleteInteraction);
 		return;
 	}
+	try {
+		await dispatchAcknowledgeableInteraction(client, rawData, interaction);
+	} catch (error) {
+		await reportInteractionFailure(interaction);
+		throw error;
+	}
+}
+async function dispatchAcknowledgeableInteraction(client, rawData, interaction) {
 	if (rawData.type === InteractionType.ApplicationCommand) {
 		const command = client.commands.find((entry) => entry.name === readInteractionName(rawData));
 		if (command) {
@@ -1865,6 +1916,44 @@ async function dispatchInteraction(client, rawData) {
 		if (modal) await modal.run(interaction, modal.customIdParser(customId).data);
 	}
 }
+/**
+* Fixed text. The thrown error is deliberately not echoed here: an interaction
+* response is visible to the whole channel, and handler exceptions routinely
+* carry absolute paths, config keys, and provider responses. The rethrow keeps
+* the detail in the Gateway log where operators already look for it.
+*/
+const INTERACTION_FAILURE_NOTICE = "Command failed. Check the Gateway logs for details.";
+/**
+* Best-effort user-visible notice for a failed interaction. Never throws: a
+* reporting failure must not mask the original error.
+*
+* Deliberately narrow. It reports only for `deferred`, where a spinner is known
+* to exist and the original response is a placeholder this dispatch created:
+*
+* - `deferred`        the deferring callback succeeded (state advances only
+*                     after a REST success), so editing the original response
+*                     resolves a spinner that would otherwise hang forever.
+* - `deferred-update` a component acknowledgement. Discord leaves no spinner,
+*                     and the original response is the message the component is
+*                     attached to, so editing it would overwrite content the
+*                     user is still reading.
+* - `unacknowledged`  nothing is known to have reached Discord. A second
+*                     initial callback risks "already acknowledged" if the
+*                     first one landed after all, and Discord already shows its
+*                     own "did not respond" notice.
+* - `replied`         the user has seen a message, and nextReplyAction() would
+*                     turn this into a contradictory follow-up beside it.
+*/
+async function reportInteractionFailure(interaction) {
+	if (interaction.responseState !== "deferred") return;
+	if (interaction.hasSentFollowUp) return;
+	try {
+		await interaction.editDeferredPlaceholderIfUnanswered({
+			content: INTERACTION_FAILURE_NOTICE,
+			allowed_mentions: { parse: [] }
+		});
+	} catch {}
+}
 function resolveConditionalComponentOption(value, interaction) {
 	return typeof value === "function" ? value(interaction) : value;
 }
@@ -2040,7 +2129,8 @@ function redactDiscordErrorBody(body, fieldKey = "", sensitiveAncestorKey, state
 	return redacted;
 }
 function readDiscordCode(body) {
-	return parseStrictNonNegativeInteger(body && typeof body === "object" && "code" in body ? body.code : void 0);
+	const value = body && typeof body === "object" && "code" in body ? body.code : void 0;
+	return parseStrictNonNegativeInteger(value);
 }
 function readDiscordMessage(body, fallback) {
 	const value = body && typeof body === "object" && "message" in body ? body.message : void 0;
@@ -2050,7 +2140,8 @@ function isUnknownDiscordVoiceStateError(err) {
 	return (err && typeof err === "object" && "discordCode" in err ? parseStrictNonNegativeInteger(err.discordCode) : void 0) === DISCORD_UNKNOWN_VOICE_STATE || /unknown voice state/i.test(formatErrorMessage(err));
 }
 function readRetryAfter(body, response, fallbackSeconds = 0) {
-	return parseDiscordRetryAfterBodySeconds(body && typeof body === "object" && "retry_after" in body ? body.retry_after : void 0) ?? parseRetryAfterHeaderSeconds(response.headers.get("Retry-After")) ?? fallbackSeconds;
+	const bodyValue = body && typeof body === "object" && "retry_after" in body ? body.retry_after : void 0;
+	return parseDiscordRetryAfterBodySeconds(bodyValue) ?? parseRetryAfterHeaderSeconds(response.headers.get("Retry-After")) ?? fallbackSeconds;
 }
 function readDiscordRateLimitBucket(response) {
 	const value = response.headers.get("X-RateLimit-Bucket")?.trim();
@@ -2062,7 +2153,8 @@ function readDiscordRateLimitScope(response) {
 }
 var DiscordError = class extends Error {
 	constructor(response, body) {
-		const redactedMessage = redactSensitiveFieldValue("message", readDiscordMessage(body, `Discord API request failed (${response.status})`));
+		const fallbackMessage = `Discord API request failed (${response.status})`;
+		const redactedMessage = redactSensitiveFieldValue("message", readDiscordMessage(body, fallbackMessage));
 		const redactedBody = redactDiscordErrorBody(body);
 		super(redactedMessage);
 		this.name = "DiscordError";
@@ -2135,7 +2227,7 @@ function appendQuery(path, query) {
 }
 //#endregion
 //#region extensions/discord/src/internal/rest-scheduler.ts
-const INVALID_REQUEST_WINDOW_MS = 10 * 6e4;
+const INVALID_REQUEST_WINDOW_MS = 6e5;
 const requestPriorities = [
 	"critical",
 	"standard",
@@ -2524,7 +2616,7 @@ const defaultLaneOptions = {
 		weight: 1
 	}
 };
-const DISCORD_REST_RESPONSE_BODY_MAX_BYTES = 8 * 1024 * 1024;
+const DISCORD_REST_RESPONSE_BODY_MAX_BYTES = 8388608;
 const GZIP_MAGIC = [31, 139];
 function createResponseBodyOverflowError(size) {
 	return /* @__PURE__ */ new Error(`Discord REST response body exceeds ${DISCORD_REST_RESPONSE_BODY_MAX_BYTES} bytes (received ${size})`);
@@ -2774,6 +2866,9 @@ var Client = class {
 	async fetchMember(guildId, userId) {
 		return await this.entityCache.fetchMember(guildId, userId);
 	}
+	async fetchGuildEmojis(guildId, fetcher) {
+		return await this.entityCache.fetchGuildEmojis(guildId, fetcher);
+	}
 	async deployCommands(options = {}) {
 		return await this.commandDeployer.deploy(options);
 	}
@@ -2998,6 +3093,56 @@ var discord_exports = /* @__PURE__ */ __exportAll({
 import * as import_discord_api_types_v10 from "discord-api-types/v10";
 __reExport(discord_exports, import_discord_api_types_v10);
 //#endregion
+//#region extensions/discord/src/target-parsing.ts
+function parseDiscordTarget(raw, options = {}) {
+	const trimmed = raw.trim();
+	if (!trimmed) return;
+	const providerPrefixedTarget = parseDiscordProviderPrefixedTarget(trimmed);
+	if (providerPrefixedTarget) return providerPrefixedTarget;
+	const userTarget = parseMentionPrefixOrAtUserTarget({
+		raw: trimmed,
+		mentionPattern: /^<@!?(\d+)>$/,
+		prefixes: [
+			{
+				prefix: "user:",
+				kind: "user"
+			},
+			{
+				prefix: "channel:",
+				kind: "channel"
+			},
+			{
+				prefix: "discord:",
+				kind: "user"
+			}
+		],
+		atUserPattern: /^\d+$/,
+		atUserErrorMessage: "Discord DMs require a user id (use user:<id> or a <@id> mention)"
+	});
+	if (userTarget) return userTarget;
+	if (/^\d+$/.test(trimmed)) {
+		if (options.defaultKind) return buildMessagingTarget(options.defaultKind, trimmed, trimmed);
+		throw new Error(options.ambiguousMessage ?? `Ambiguous Discord recipient "${trimmed}". For DMs use "user:${trimmed}" or "<@${trimmed}>"; for channels use "channel:${trimmed}".`);
+	}
+	return buildMessagingTarget("channel", trimmed, trimmed);
+}
+function parseDiscordProviderPrefixedTarget(raw) {
+	const match = /^discord:(channel|user):(.+)$/i.exec(raw);
+	if (!match) return;
+	const kind = match[1]?.toLowerCase();
+	const id = match[2]?.trim();
+	if (!kind || !id) return;
+	return buildMessagingTarget(kind, id, `${kind}:${id}`);
+}
+function resolveDiscordChannelId(raw) {
+	const target = parseDiscordTarget(raw, { defaultKind: "channel" });
+	return requireTargetKind({
+		platform: "Discord",
+		target,
+		kind: "channel"
+	});
+}
+//#endregion
 //#region extensions/discord/src/normalize.ts
 function normalizeDiscordMessagingTarget(raw) {
 	return parseDiscordTarget(raw, { defaultKind: "channel" })?.normalized;
@@ -3032,8 +3177,9 @@ function normalizeDiscordOutboundTarget(to, allowFrom) {
 function allowFromContainsDiscordUserId(allowFrom, userId) {
 	const normalizedUserId = userId.trim();
 	if (!normalizedUserId) return false;
+	const normalizedAllowFrom = (allowFrom ?? []).map(normalizeAllowFromDiscordUserId).filter((entry) => Boolean(entry));
 	return resolveAllowlistMatchByCandidates({
-		allowList: (allowFrom ?? []).map(normalizeAllowFromDiscordUserId).filter((entry) => Boolean(entry)),
+		allowList: normalizedAllowFrom,
 		candidates: [{
 			value: normalizedUserId,
 			source: "id"
@@ -3079,6 +3225,80 @@ function resolveDiscordReplyMessageId(reply, isFirst) {
 	return reply && (isFirst || reply.scope === "all") ? reply.messageId : void 0;
 }
 //#endregion
+//#region extensions/discord/src/send.receipt.ts
+function toDiscordOutboundDeliveryResult(result) {
+	const { channelId, ...delivery } = result;
+	return {
+		...delivery,
+		target: {
+			kind: "channel",
+			id: channelId
+		}
+	};
+}
+function createDiscordSendReceiptFromResults(params) {
+	const receipt = createMessageReceiptFromOutboundResults({
+		results: attachChannelToResults("discord", params.results),
+		threadId: params.threadId
+	});
+	return {
+		...receipt,
+		parts: receipt.parts.map(({ platformMessageId, kind, threadId, replyToId, raw }, index) => ({
+			platformMessageId,
+			kind,
+			index,
+			threadId,
+			replyToId,
+			raw
+		}))
+	};
+}
+function createDiscordSendReceipt(params) {
+	const results = params.platformMessageIds.map((messageId) => messageId.trim()).filter((messageId) => messageId && messageId !== "unknown").map((messageId, index) => {
+		const result = {
+			channel: "discord",
+			messageId
+		};
+		if (params.channelId) result.channelId = params.channelId;
+		if (params.reply?.scope === "first" && index === 0) {
+			const rawResult = {
+				channel: "discord",
+				messageId
+			};
+			if (params.channelId) rawResult.channelId = params.channelId;
+			result.receipt = createMessageReceiptFromOutboundResults({
+				results: [rawResult],
+				kind: params.kind,
+				threadId: params.threadId,
+				replyToId: params.reply.messageId
+			});
+		}
+		return result;
+	});
+	return createMessageReceiptFromOutboundResults({
+		results,
+		kind: params.kind,
+		threadId: params.threadId,
+		replyToId: params.reply?.scope === "all" ? params.reply.messageId : void 0
+	});
+}
+function createDiscordSendResult(params) {
+	const messageId = params.result.id || "unknown";
+	const channelId = params.result.channel_id ?? params.fallbackChannelId;
+	const receiptParams = {
+		platformMessageIds: params.result.platformMessageIds?.length ? params.result.platformMessageIds : [messageId],
+		channelId,
+		kind: params.kind
+	};
+	if (params.threadId != null) receiptParams.threadId = String(params.threadId);
+	if (params.reply) receiptParams.reply = params.reply;
+	return {
+		messageId,
+		channelId,
+		receipt: createDiscordSendReceipt(receiptParams)
+	};
+}
+//#endregion
 //#region extensions/discord/src/chunk.ts
 const DEFAULT_MAX_CHARS = 2e3;
 const DEFAULT_MAX_LINES = 17;
@@ -3175,7 +3395,8 @@ function chunkDiscordText(text, opts = {}) {
 		const reopenPrefixLen = fenceToReserve ? reopenFenceLine(fenceToReserve, maxChars)?.length ?? 0 : 0;
 		const prefixLen = current.length > 0 ? current.length + 1 : 0;
 		const reopenBudget = reopenPrefixLen > 0 ? reopenPrefixLen + 1 : 0;
-		const segments = chunkTextForOutbound(originalLine, Math.max(1, charLimit - Math.max(prefixLen, reopenBudget)), { preserveWhitespace: wasInsideFence });
+		const segmentLimit = Math.max(1, charLimit - Math.max(prefixLen, reopenBudget));
+		const segments = chunkTextForOutbound(originalLine, segmentLimit, { preserveWhitespace: wasInsideFence });
 		for (let segIndex = 0; segIndex < segments.length; segIndex++) {
 			const segment = segments[segIndex];
 			const isLineContinuation = segIndex > 0;
@@ -3316,7 +3537,8 @@ const DISCORD_TRANSIENT_MESSAGE_RE = /\b(?:bad gateway|fetch failed|network erro
 const ambiguousDiscordMessageCreates = /* @__PURE__ */ new WeakSet();
 function readDiscordErrorStatus(err) {
 	if (!err || typeof err !== "object") return;
-	return parseStrictNonNegativeInteger("status" in err && err.status !== void 0 ? err.status : "statusCode" in err && err.statusCode !== void 0 ? err.statusCode : void 0);
+	const raw = "status" in err && err.status !== void 0 ? err.status : "statusCode" in err && err.statusCode !== void 0 ? err.statusCode : void 0;
+	return parseStrictNonNegativeInteger(raw);
 }
 function classifyDiscordDeliveryFailure(error) {
 	const candidates = collectErrorGraphCandidates(error, (current) => [current.cause, current.error]);
@@ -3401,4 +3623,4 @@ function createDiscordRetryRunner(params) {
 	};
 }
 //#endregion
-export { MediaGallery as $, timeoutGuildMember as $t, RateLimitError as A, pinChannelMessage as At, hasDiscordV2Components as B, deleteChannelPermission as Bt, ThreadDeleteListener as C, editChannelMessage as Ct, Plugin as D, listChannelArchivedThreads as Dt, Client as E, getThreadMember as Et, Command as F, createGuildBan as Ft, Modal as G, listGuildChannels as Gt, Embed as H, getGuildMember as Ht, CommandWithSubcommands as I, createGuildChannel as It, Button as J, listGuildScheduledEvents as Jt, RadioGroup as K, listGuildEmojis as Kt, Guild as L, createGuildEmoji as Lt, readDiscordCode as M, sendChannelTyping as Mt, readDiscordMessage as N, unpinChannelMessage as Nt, RequestClient as O, listChannelMessages as Ot, readRetryAfter as P, addGuildMemberRole as Pt, LinkButton as Q, removeGuildMemberRole as Qt, Message as R, createGuildScheduledEvent as Rt, ResumedListener as S, editChannel as St, VoiceStateUpdateListener as T, getChannelMessage as Tt, CheckboxGroup as U, getGuildVoiceState as Ut, serializePayload as V, getGuild as Vt, Label as W, listGuildActiveThreads as Wt, Container as X, putChannelPermission as Xt, ChannelSelectMenu as Y, moveGuildChannels as Yt, File as Z, removeGuildMember as Zt, MessageCreateListener as _, listMessageReactionUsers as _t, chunkDiscordTextWithMode as a, StringSelectMenu as at, PresenceUpdateListener as b, deleteChannel as bt, resolveDiscordReplyReference as c, UserSelectMenu as ct, normalizeDiscordMessagingTarget as d, stripUndefinedFields as dt, __exportAll as en, MentionableSelectMenu as et, normalizeDiscordOutboundTarget as f, createChannelWebhook as ft, InteractionCreateListener as g, deleteOwnMessageReaction as gt, GuildDeleteListener as h, createOwnMessageReaction as ht, recordDiscordMessageCreateAmbiguity as i, Separator as it, isUnknownDiscordVoiceStateError as j, searchGuildMessages as jt, DiscordError as k, listChannelPins as kt, allowFromContainsDiscordUserId as l, BaseMessageInteractiveComponent as lt, GuildCreateListener as m, getCurrentUser as mt, createDiscordRetryRunner as n, Row as nt, createReusableDiscordReplyReference as o, TextDisplay as ot, discord_exports as p, createUserDmChannel as pt, TextInput as q, listGuildRoles as qt, hasDiscordMessageCreateAmbiguity as r, Section as rt, resolveDiscordReplyMessageId as s, Thumbnail as st, classifyDiscordDeliveryFailure as t, RoleSelectMenu as tt, looksLikeDiscordTargetId as u, parseCustomId as ut, MessageReactionAddListener as v, createChannelMessage as vt, ThreadUpdateListener as w, getChannel as wt, ReadyListener as x, deleteChannelMessage as xt, MessageReactionRemoveListener as y, createThread as yt, User as z, createGuildSticker as zt };
+export { TextInput as $, listGuildRoles as $t, ThreadUpdateListener as A, getChannel as At, readRetryAfter as B, addGuildMemberRole as Bt, MessageCreateListener as C, listMessageReactionUsers as Ct, ReadyListener as D, deleteChannelMessage as Dt, PresenceUpdateListener as E, deleteChannel as Et, DiscordError as F, listChannelPins as Ft, User as G, createGuildSticker as Gt, CommandWithSubcommands as H, createGuildChannel as Ht, RateLimitError as I, pinChannelMessage as It, Embed as J, getGuildMember as Jt, hasDiscordV2Components as K, deleteChannelPermission as Kt, isUnknownDiscordVoiceStateError as L, searchGuildMessages as Lt, Client as M, getThreadMember as Mt, Plugin as N, listChannelArchivedThreads as Nt, ResumedListener as O, editChannel as Ot, RequestClient as P, listChannelMessages as Pt, RadioGroup as Q, listGuildEmojis as Qt, readDiscordCode as R, sendChannelTyping as Rt, InteractionCreateListener as S, deleteOwnMessageReaction as St, MessageReactionRemoveListener as T, createThread as Tt, Guild as U, createGuildEmoji as Ut, Command as V, createGuildBan as Vt, Message as W, createGuildScheduledEvent as Wt, Label as X, listGuildActiveThreads as Xt, CheckboxGroup as Y, getGuildVoiceState as Yt, Modal as Z, listGuildChannels as Zt, parseDiscordTarget as _, stripUndefinedFields as _t, chunkDiscordTextWithMode as a, timeoutGuildMember as an, MediaGallery as at, GuildCreateListener as b, getCurrentUser as bt, createDiscordSendResult as c, Row as ct, resolveDiscordReplyMessageId as d, StringSelectMenu as dt, listGuildScheduledEvents as en, Button as et, resolveDiscordReplyReference as f, TextDisplay as ft, normalizeDiscordOutboundTarget as g, parseCustomId as gt, normalizeDiscordMessagingTarget as h, BaseMessageInteractiveComponent as ht, recordDiscordMessageCreateAmbiguity as i, removeGuildMemberRole as in, LinkButton as it, VoiceStateUpdateListener as j, getChannelMessage as jt, ThreadDeleteListener as k, editChannelMessage as kt, toDiscordOutboundDeliveryResult as l, Section as lt, looksLikeDiscordTargetId as m, UserSelectMenu as mt, createDiscordRetryRunner as n, putChannelPermission as nn, Container as nt, createDiscordSendReceipt as o, __exportAll as on, MentionableSelectMenu as ot, allowFromContainsDiscordUserId as p, Thumbnail as pt, serializePayload as q, getGuild as qt, hasDiscordMessageCreateAmbiguity as r, removeGuildMember as rn, File as rt, createDiscordSendReceiptFromResults as s, RoleSelectMenu as st, classifyDiscordDeliveryFailure as t, moveGuildChannels as tn, ChannelSelectMenu as tt, createReusableDiscordReplyReference as u, Separator as ut, resolveDiscordChannelId as v, createChannelWebhook as vt, MessageReactionAddListener as w, createChannelMessage as wt, GuildDeleteListener as x, createOwnMessageReaction as xt, discord_exports as y, createUserDmChannel as yt, readDiscordMessage as z, unpinChannelMessage as zt };

package/dist/{runtime-CQovMsH3.js → runtime-BNlDfLwS.js}

@@ -1,5 +1,5 @@
-import { c as resolveDiscordAccount, g as selectDiscordActivitiesRuntimeConfig, n as isDiscordAccountEnabledForRuntime, r as listDiscordAccountIds } from "./accounts-DNl-oCEw.js";
-import { B as resolveDiscordProxyFetchForAccount } from "./send.shared-B3fpaLWJ.js";
+import { c as resolveDiscordAccount, g as selectDiscordActivitiesRuntimeConfig, n as isDiscordAccountEnabledForRuntime, r as listDiscordAccountIds } from "./accounts-CwJQoLjM.js";
+import { z as resolveDiscordProxyFetchForAccount } from "./send.shared-BJHt0Vyf.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/discord/src/activities/config.ts
 function resolveDiscordActivitiesConfig(account, env = process.env) {