@openclaw/discord 2026.9.1-beta.1 → 2026.9.1

package/dist/{retry-Cv4jCU5Z.js → retry-BNCxiyyR.js}

@@ -1,4 +1,4 @@
-import { t as parseDiscordRetryAfterBodySeconds } from "./retry-after-DdLPmPoa.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";
@@ -1676,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);
@@ -1692,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);
@@ -1726,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;
@@ -1755,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 {
@@ -1844,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) {
@@ -1879,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;
 }
@@ -2054,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;
@@ -2064,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();
@@ -2076,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";
@@ -2149,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",
@@ -2538,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})`);
@@ -3057,9 +3135,10 @@ function parseDiscordProviderPrefixedTarget(raw) {
 	return buildMessagingTarget(kind, id, `${kind}:${id}`);
 }
 function resolveDiscordChannelId(raw) {
+	const target = parseDiscordTarget(raw, { defaultKind: "channel" });
 	return requireTargetKind({
 		platform: "Discord",
-		target: parseDiscordTarget(raw, { defaultKind: "channel" }),
+		target,
 		kind: "channel"
 	});
 }
@@ -3098,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"
@@ -3174,35 +3254,36 @@ function createDiscordSendReceiptFromResults(params) {
 	};
 }
 function createDiscordSendReceipt(params) {
-	return createMessageReceiptFromOutboundResults({
-		results: params.platformMessageIds.map((messageId) => messageId.trim()).filter((messageId) => messageId && messageId !== "unknown").map((messageId, index) => {
-			const result = {
+	const results = params.platformMessageIds.map((messageId) => messageId.trim()).filter(Boolean).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) 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;
-		}),
+			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 messageId = params.result.id ?? "";
 	const channelId = params.result.channel_id ?? params.fallbackChannelId;
 	const receiptParams = {
 		platformMessageIds: params.result.platformMessageIds?.length ? params.result.platformMessageIds : [messageId],
@@ -3314,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;
@@ -3455,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]);
@@ -3476,6 +3559,11 @@ function recordDiscordMessageCreateAmbiguity(error) {
 function hasDiscordMessageCreateAmbiguity(error) {
 	return collectErrorGraphCandidates(error, (current) => [current.cause, current.error]).some((candidate) => candidate !== null && typeof candidate === "object" && ambiguousDiscordMessageCreates.has(candidate));
 }
+function canFallbackDiscordWebhookSend(error) {
+	if (hasDiscordMessageCreateAmbiguity(error)) return false;
+	const failure = classifyDiscordDeliveryFailure(error);
+	return failure === "rejected" || failure === "pre-connect";
+}
 function hasDiscordRateLimitRejection(error) {
 	return error instanceof RateLimitError || collectErrorGraphCandidates(error, (current) => [current.cause, current.error]).some((candidate) => readDiscordErrorStatus(candidate) === 429);
 }
@@ -3540,4 +3628,4 @@ function createDiscordRetryRunner(params) {
 	};
 }
 //#endregion
-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 };
+export { RadioGroup as $, listGuildEmojis as $t, ThreadDeleteListener as A, editChannelMessage as At, readDiscordMessage as B, unpinChannelMessage as Bt, InteractionCreateListener as C, deleteOwnMessageReaction as Ct, PresenceUpdateListener as D, deleteChannel as Dt, MessageReactionRemoveListener as E, createThread as Et, RequestClient as F, listChannelMessages as Ft, Message as G, createGuildScheduledEvent as Gt, Command as H, createGuildBan as Ht, DiscordError as I, listChannelPins as It, serializePayload as J, getGuild as Jt, User as K, createGuildSticker as Kt, RateLimitError as L, pinChannelMessage as Lt, VoiceStateUpdateListener as M, getChannelMessage as Mt, Client as N, getThreadMember as Nt, ReadyListener as O, deleteChannelMessage as Ot, Plugin as P, listChannelArchivedThreads as Pt, Modal as Q, listGuildChannels as Qt, isUnknownDiscordVoiceStateError as R, searchGuildMessages as Rt, GuildDeleteListener as S, createOwnMessageReaction as St, MessageReactionAddListener as T, createChannelMessage as Tt, CommandWithSubcommands as U, createGuildChannel as Ut, readRetryAfter as V, addGuildMemberRole as Vt, Guild as W, createGuildEmoji as Wt, CheckboxGroup as X, getGuildVoiceState as Xt, Embed as Y, getGuildMember as Yt, Label as Z, listGuildActiveThreads as Zt, normalizeDiscordOutboundTarget as _, parseCustomId as _t, recordDiscordMessageCreateAmbiguity as a, removeGuildMemberRole as an, LinkButton as at, discord_exports as b, createUserDmChannel as bt, createDiscordSendReceiptFromResults as c, RoleSelectMenu as ct, createReusableDiscordReplyReference as d, Separator as dt, listGuildRoles as en, TextInput as et, resolveDiscordReplyMessageId as f, StringSelectMenu as ft, normalizeDiscordMessagingTarget as g, BaseMessageInteractiveComponent as gt, looksLikeDiscordTargetId as h, UserSelectMenu as ht, hasDiscordMessageCreateAmbiguity as i, removeGuildMember as in, File as it, ThreadUpdateListener as j, getChannel as jt, ResumedListener as k, editChannel as kt, createDiscordSendResult as l, Row as lt, allowFromContainsDiscordUserId as m, Thumbnail as mt, classifyDiscordDeliveryFailure as n, moveGuildChannels as nn, ChannelSelectMenu as nt, chunkDiscordTextWithMode as o, timeoutGuildMember as on, MediaGallery as ot, resolveDiscordReplyReference as p, TextDisplay as pt, hasDiscordV2Components as q, deleteChannelPermission as qt, createDiscordRetryRunner as r, putChannelPermission as rn, Container as rt, createDiscordSendReceipt as s, __exportAll as sn, MentionableSelectMenu as st, canFallbackDiscordWebhookSend as t, listGuildScheduledEvents as tn, Button as tt, toDiscordOutboundDeliveryResult as u, Section as ut, parseDiscordTarget as v, stripUndefinedFields as vt, MessageCreateListener as w, listMessageReactionUsers as wt, GuildCreateListener as x, getCurrentUser as xt, resolveDiscordChannelId as y, createChannelWebhook as yt, readDiscordCode as z, sendChannelTyping as zt };

package/dist/{retry-after-DdLPmPoa.js → retry-after-BrLjLUJi.js}

@@ -3,7 +3,8 @@ import { asFiniteNumberInRange, parseStrictFiniteNumber } from "openclaw/plugin-
 const RETRY_AFTER_BODY_SECONDS_RE = /^(?:\d+\.?\d*|\.\d+)$/;
 const MAX_SAFE_RETRY_AFTER_SECONDS = Number.MAX_SAFE_INTEGER / 1e3;
 function parseDiscordRetryAfterBodySeconds(value) {
-	return asFiniteNumberInRange(typeof value === "number" ? value : typeof value === "string" && RETRY_AFTER_BODY_SECONDS_RE.test(value.trim()) ? parseStrictFiniteNumber(value.trim()) : void 0, {
+	const seconds = typeof value === "number" ? value : typeof value === "string" && RETRY_AFTER_BODY_SECONDS_RE.test(value.trim()) ? parseStrictFiniteNumber(value.trim()) : void 0;
+	return asFiniteNumberInRange(seconds, {
 		min: 0,
 		max: MAX_SAFE_RETRY_AFTER_SECONDS
 	});