@openclaw/discord 2026.7.2-beta.2 → 2026.7.2-beta.4

package/dist/{send.outbound-Cvulb-k_.js → send.outbound-BbC2qjpH.js}

@@ -1,7 +1,8 @@
-import { gt as createThread, ht as createChannelMessage, i as createReusableDiscordReplyReference, r as createDiscordSendResult } from "./chunk-CHpY_lsO.js";
-import { s as resolveDiscordAccount } from "./accounts-CMd4nzLB.js";
-import { P as createDiscordClient, W as parseAndResolveChannelRecipient, _ as resolveDiscordMessageFlags, a as normalizeDiscordPollInput, c as normalizeStickerIds, f as sendDiscordMedia, g as createDiscordMessageNonce, h as buildDiscordMessageRequest, l as resolveChannelId, n as buildDiscordTextChunks, p as sendDiscordText, t as buildDiscordSendError, u as resolveDiscordChannel, v as resolveDiscordSendComponents, y as resolveDiscordSendEmbeds } from "./send.shared-XuOTO1dW.js";
-import { a as resolveDiscordDirectoryUserId } from "./directory-live-nfvekMil.js";
+import { mt as createThread, n as createReusableDiscordReplyReference, pt as createChannelMessage } from "./chunk-BrZocpfs.js";
+import { s as resolveDiscordAccount } from "./accounts-D2LKPukU.js";
+import { P as createDiscordClient, W as parseAndResolveChannelRecipient, _ as resolveDiscordMessageFlags, a as normalizeDiscordPollInput, c as normalizeStickerIds, f as sendDiscordMedia, g as createDiscordMessageNonce, h as buildDiscordMessageRequest, l as resolveChannelId, n as buildDiscordTextChunks, p as sendDiscordText, t as buildDiscordSendError, u as resolveDiscordChannel, v as resolveDiscordSendComponents, y as resolveDiscordSendEmbeds } from "./send.shared-Dfacnk-E.js";
+import { a as resolveDiscordDirectoryUserId } from "./directory-live-CrMtTrb0.js";
+import { n as createDiscordSendResult } from "./send.receipt-CuwRrpFz.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { ChannelType } from "discord-api-types/v10";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
@@ -10,7 +11,301 @@ import { recordChannelActivity } from "openclaw/plugin-sdk/channel-activity-runt
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
 import { resolveChunkMode } from "openclaw/plugin-sdk/reply-chunking";
-import { convertMarkdownTables } from "openclaw/plugin-sdk/text-chunking";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { convertMarkdownTables, renderMarkdownWithMarkers } from "openclaw/plugin-sdk/text-chunking";
+//#region extensions/discord/src/markdown.ts
+const DISCORD_FORMAT_PROFILE = {
+	mechanism: "markdown",
+	constructs: {
+		bold: "native",
+		italic: "native",
+		underline: "native",
+		strikethrough: "native",
+		spoiler: "native",
+		codeInline: "native",
+		codeBlock: "native",
+		codeLanguage: "native",
+		linkLabel: "native",
+		heading: "native",
+		bulletList: "native",
+		orderedList: "native",
+		taskList: "native",
+		table: "fallback",
+		blockquote: "native",
+		image: "native",
+		mention: "native"
+	},
+	chunk: {
+		limit: 2e3,
+		unit: "utf16"
+	}
+};
+const DISCORD_BOLD_PROBE_TEXT = "openclaw-discord-bold";
+const DISCORD_BOLD_PROBE = renderMarkdownWithMarkers({
+	text: DISCORD_BOLD_PROBE_TEXT,
+	styles: [{
+		start: 0,
+		end: 21,
+		style: "bold"
+	}],
+	links: []
+}, {
+	styleMarkers: { bold: {
+		open: "**",
+		close: "**"
+	} },
+	escapeText: (value) => value
+}, DISCORD_FORMAT_PROFILE);
+const DISCORD_BOLD_MARKERS = {
+	open: DISCORD_BOLD_PROBE.slice(0, DISCORD_BOLD_PROBE.indexOf(DISCORD_BOLD_PROBE_TEXT)),
+	close: DISCORD_BOLD_PROBE.slice(DISCORD_BOLD_PROBE.indexOf(DISCORD_BOLD_PROBE_TEXT) + 21)
+};
+const DISCORD_NATIVE_TOKEN_RE = /<a?:[A-Za-z0-9_]+:\d+>|<\/[^>]+:\d+>/giu;
+const DISCORD_URL_START_RE = /(?:[A-Za-z][A-Za-z0-9+.-]*:\/\/|www\.)/giu;
+function findDiscordUrlRanges(markdown) {
+	const ranges = [];
+	for (const match of markdown.matchAll(DISCORD_URL_START_RE)) {
+		const start = match.index;
+		if (start === void 0) continue;
+		const preceding = markdown[start - 1] ?? "";
+		if (/[\p{L}\p{N}]/u.test(preceding) || preceding === "_" && markdown[start - 2] !== "_") continue;
+		let end = start + match[0].length;
+		let parenthesisDepth = 0;
+		while (end < markdown.length) {
+			const char = markdown[end];
+			if (!char || /[\s<>]/u.test(char)) break;
+			if (char === "(") parenthesisDepth += 1;
+			else if (char === ")") {
+				if (parenthesisDepth === 0) break;
+				parenthesisDepth -= 1;
+			}
+			end += 1;
+		}
+		ranges.push({
+			start,
+			end
+		});
+	}
+	return ranges;
+}
+function markdownSemanticSignature(root) {
+	const parts = [];
+	const pending = [{
+		node: root,
+		parentStrong: false
+	}];
+	while (pending.length > 0) {
+		const event = pending.pop();
+		if (!event) continue;
+		if (event.exiting) {
+			parts.push(")");
+			continue;
+		}
+		const { node } = event;
+		const redundantStrong = event.parentStrong && node.type === "strong";
+		const fields = Object.fromEntries(Object.entries(node).filter(([key]) => key !== "children" && key !== "position"));
+		const children = node.children ?? [];
+		if (!redundantStrong) {
+			parts.push(`(${JSON.stringify(fields)}`);
+			pending.push({
+				node,
+				parentStrong: event.parentStrong,
+				exiting: true
+			});
+		}
+		const parentStrong = event.parentStrong || node.type === "strong";
+		for (let index = children.length - 1; index >= 0; index -= 1) {
+			const child = children[index];
+			if (child) pending.push({
+				node: child,
+				parentStrong
+			});
+		}
+	}
+	return parts.join("\n");
+}
+function normalizeDiscordBold(markdown) {
+	const spans = [];
+	const contentEdits = [];
+	const starEmphasisDelimiters = /* @__PURE__ */ new Set();
+	const astLinkRanges = [];
+	const sourceTree = fromMarkdown(markdown);
+	const activeSpanIds = [];
+	const pending = [{ node: sourceTree }];
+	while (pending.length > 0) {
+		const event = pending.pop();
+		if (!event) continue;
+		if (event.exiting !== void 0) {
+			activeSpanIds.pop();
+			continue;
+		}
+		const { node } = event;
+		const start = node.position?.start.offset;
+		const end = node.position?.end.offset;
+		if (node.type === "link" && start !== void 0 && end !== void 0 && markdown[start] === "<" && markdown[end - 1] === ">") astLinkRanges.push({
+			start,
+			end
+		});
+		let enteredSpanId;
+		if (node.type === "strong" && start !== void 0 && end !== void 0 && markdown.startsWith("__", start) && markdown.slice(end - 2, end) === "__") {
+			enteredSpanId = spans.length;
+			spans.push({
+				start,
+				end
+			});
+			activeSpanIds.push(enteredSpanId);
+		}
+		const spanId = activeSpanIds.at(-1);
+		if (spanId !== void 0 && start !== void 0 && end !== void 0) {
+			if (node.type === "strong" && enteredSpanId === void 0 && markdown.startsWith("**", start) && markdown.slice(end - 2, end) === "**") contentEdits.push({
+				spanId,
+				start,
+				marker: "****",
+				consume: 2,
+				delimiter: false
+			}, {
+				spanId,
+				start: end - 2,
+				marker: "****",
+				consume: 2,
+				delimiter: false
+			});
+			else if (node.type === "emphasis" && markdown[start] === "*" && markdown[end - 1] === "*") {
+				starEmphasisDelimiters.add(start);
+				starEmphasisDelimiters.add(end - 1);
+				if (!(/[\p{L}\p{N}]/u.test(markdown[start - 1] ?? "") || /[\p{L}\p{N}]/u.test(markdown[end] ?? ""))) contentEdits.push({
+					spanId,
+					start,
+					marker: "_",
+					consume: 1,
+					delimiter: false
+				}, {
+					spanId,
+					start: end - 1,
+					marker: "_",
+					consume: 1,
+					delimiter: false
+				});
+			} else if (node.type === "text") for (let offset = start; offset < end; offset += 1) {
+				if (markdown[offset] !== "*") continue;
+				let precedingSlashes = 0;
+				for (let index = offset - 1; index >= start && markdown[index] === "\\"; index -= 1) precedingSlashes += 1;
+				if (precedingSlashes % 2 === 0) contentEdits.push({
+					spanId,
+					start: offset,
+					marker: "\\",
+					consume: 0,
+					delimiter: false
+				});
+			}
+		}
+		if (enteredSpanId !== void 0) pending.push({
+			node,
+			exiting: enteredSpanId
+		});
+		const children = node.children ?? [];
+		for (let index = children.length - 1; index >= 0; index -= 1) {
+			const child = children[index];
+			if (child) pending.push({ node: child });
+		}
+	}
+	if (spans.length === 0) return markdown;
+	const strongInteriorStartByEnd = /* @__PURE__ */ new Map();
+	for (const span of spans) {
+		const interiorStart = span.start + 2;
+		strongInteriorStartByEnd.set(span.end, Math.min(strongInteriorStartByEnd.get(span.end) ?? interiorStart, interiorStart));
+	}
+	const nativeTokenRanges = [...markdown.matchAll(DISCORD_NATIVE_TOKEN_RE)].flatMap((match) => match.index === void 0 ? [] : [{
+		start: match.index,
+		end: match.index + match[0].length
+	}]);
+	const protectedRanges = [
+		...findDiscordUrlRanges(markdown),
+		...astLinkRanges,
+		...nativeTokenRanges
+	].toSorted((left, right) => left.start - right.start).map(({ start, end: rawEnd }) => {
+		let end = rawEnd;
+		while (/[.,!?;:'"]/u.test(markdown[end - 1] ?? "")) end -= 1;
+		let previousEnd = -1;
+		while (end !== previousEnd) {
+			previousEnd = end;
+			while (starEmphasisDelimiters.has(end - 1)) end -= 1;
+			let strongInteriorStart = strongInteriorStartByEnd.get(end);
+			while (strongInteriorStart !== void 0 && start >= strongInteriorStart) {
+				end -= 2;
+				strongInteriorStart = strongInteriorStartByEnd.get(end);
+			}
+		}
+		return {
+			start,
+			end
+		};
+	});
+	const edits = [...spans.flatMap((span, spanId) => [{
+		spanId,
+		start: span.start,
+		marker: DISCORD_BOLD_MARKERS.open,
+		consume: 2,
+		delimiter: true
+	}, {
+		spanId,
+		start: span.end - 2,
+		marker: DISCORD_BOLD_MARKERS.close,
+		consume: 2,
+		delimiter: true
+	}]), ...contentEdits].toSorted((left, right) => left.start - right.start);
+	const editsBySpan = /* @__PURE__ */ new Map();
+	for (const edit of edits) {
+		const spanEdits = editsBySpan.get(edit.spanId);
+		if (spanEdits) spanEdits.push(edit);
+		else editsBySpan.set(edit.spanId, [edit]);
+	}
+	const protectedSpanIds = /* @__PURE__ */ new Set();
+	const protectedEditKeys = /* @__PURE__ */ new Set();
+	const spansWithProtectedContent = /* @__PURE__ */ new Set();
+	let rangeIndex = 0;
+	for (const edit of edits) {
+		while ((protectedRanges[rangeIndex]?.end ?? Number.POSITIVE_INFINITY) <= edit.start) rangeIndex += 1;
+		const range = protectedRanges[rangeIndex];
+		if (range && (edit.consume === 0 ? edit.start >= range.start && edit.start < range.end : edit.start < range.end && edit.start + edit.consume > range.start)) if (edit.delimiter) protectedSpanIds.add(edit.spanId);
+		else {
+			protectedEditKeys.add(`${edit.start}:${edit.consume}:${edit.marker}`);
+			spansWithProtectedContent.add(edit.spanId);
+		}
+	}
+	for (const spanId of spansWithProtectedContent) {
+		const span = spans[spanId];
+		if (!span) continue;
+		let localCursor = span.start;
+		const localRendered = (editsBySpan.get(spanId) ?? []).filter((edit) => {
+			const key = `${edit.start}:${edit.consume}:${edit.marker}`;
+			return !protectedEditKeys.has(key);
+		}).map((edit) => {
+			const chunk = `${markdown.slice(localCursor, edit.start)}${edit.marker}`;
+			localCursor = edit.start + edit.consume;
+			return chunk;
+		}).join("") + markdown.slice(localCursor, span.end);
+		const localSource = markdown.slice(span.start, span.end);
+		if (markdownSemanticSignature(fromMarkdown(localRendered)) !== markdownSemanticSignature(fromMarkdown(localSource))) protectedSpanIds.add(spanId);
+	}
+	let cursor = 0;
+	const seenEdits = /* @__PURE__ */ new Set();
+	const rendered = edits.filter((edit) => {
+		const key = `${edit.start}:${edit.consume}:${edit.marker}`;
+		if (protectedSpanIds.has(edit.spanId) || protectedEditKeys.has(key) || seenEdits.has(key)) return false;
+		seenEdits.add(key);
+		return true;
+	}).map((edit) => {
+		const chunk = `${markdown.slice(cursor, edit.start)}${edit.marker}`;
+		cursor = edit.start + edit.consume;
+		return chunk;
+	}).join("") + markdown.slice(cursor);
+	return markdownSemanticSignature(fromMarkdown(rendered)) === markdownSemanticSignature(sourceTree) ? rendered : markdown;
+}
+function renderDiscordMarkdown(markdown, tableMode) {
+	return normalizeDiscordBold(convertMarkdownTables(markdown, tableMode));
+}
+//#endregion
 //#region extensions/discord/src/mentions.ts
 const MENTION_CANDIDATE_PATTERN = /(^|[\s([{"'.,;:!?])@([a-z0-9_.-]{2,32}(?:#[0-9]{4})?)/gi;
 const DISCORD_RESERVED_MENTIONS = /* @__PURE__ */ new Set(["everyone", "here"]);
@@ -217,8 +512,8 @@ async function sendMessageDiscord(to, text, opts) {
 	});
 	const textLimit = typeof opts.textLimit === "number" && Number.isFinite(opts.textLimit) ? Math.max(1, Math.min(Math.floor(opts.textLimit), 2e3)) : void 0;
 	const mediaMaxBytes = typeof accountInfo.config.mediaMaxMb === "number" ? accountInfo.config.mediaMaxMb * 1024 * 1024 : DEFAULT_DISCORD_MEDIA_MAX_MB * 1024 * 1024;
-	const textWithTables = convertMarkdownTables(text ?? "", effectiveTableMode);
-	const textWithMentions = rewriteDiscordKnownMentions(textWithTables, {
+	const renderedText = renderDiscordMarkdown(text ?? "", effectiveTableMode);
+	const textWithMentions = rewriteDiscordKnownMentions(renderedText, {
 		accountId: accountInfo.accountId,
 		mentionAliases: accountInfo.config.mentionAliases
 	});
@@ -229,7 +524,7 @@ async function sendMessageDiscord(to, text, opts) {
 	const { channelId } = await resolveChannelId(rest, await parseAndResolveChannelRecipient(to, cfg, opts.accountId), request);
 	const channel = await resolveDiscordChannel(rest, channelId);
 	if (isForumLikeChannel(channel)) {
-		const threadName = deriveForumThreadName(textWithTables);
+		const threadName = deriveForumThreadName(renderedText);
 		const chunks = buildDiscordTextChunks(textWithMentions, {
 			maxLinesPerMessage,
 			chunkMode,

package/dist/send.reactions-bLrJCZ4G.js

@@ -0,0 +1,85 @@
+import { Dt as sendChannelTyping, bt as getChannelMessage, dt as deleteOwnMessageReaction, ft as listMessageReactionUsers, ut as createOwnMessageReaction } from "./chunk-BrZocpfs.js";
+import { P as createDiscordClient, R as resolveDiscordRest, i as formatReactionEmoji, r as buildReactionIdentifier, s as normalizeReactionEmoji } from "./send.shared-Dfacnk-E.js";
+import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
+//#region extensions/discord/src/send.typing.ts
+async function sendTypingDiscord(channelId, opts) {
+	await sendChannelTyping(resolveDiscordRest(opts), channelId);
+	return {
+		ok: true,
+		channelId
+	};
+}
+//#endregion
+//#region extensions/discord/src/send.reactions.ts
+function createDiscordReactionRuntimeClient(opts) {
+	return createDiscordClient(opts);
+}
+function resolveDiscordReactionClient(opts) {
+	if (!opts.cfg) throw new Error("Discord reactions requires a resolved runtime config. Load and resolve config at the command or gateway boundary, then pass cfg through the runtime path.");
+	const cfg = requireRuntimeConfig(opts.cfg, "Discord reactions");
+	return createDiscordClient({
+		...opts,
+		cfg
+	});
+}
+function isDiscordReactionRuntimeContext(opts) {
+	return Boolean(opts.rest && opts.cfg && opts.accountId);
+}
+async function reactMessageDiscord(channelId, messageId, emoji, opts) {
+	const { rest, request } = isDiscordReactionRuntimeContext(opts) ? createDiscordReactionRuntimeClient(opts) : resolveDiscordReactionClient(opts);
+	const encoded = normalizeReactionEmoji(emoji);
+	await request(() => createOwnMessageReaction(rest, channelId, messageId, encoded), "react");
+	return { ok: true };
+}
+async function removeReactionDiscord(channelId, messageId, emoji, opts) {
+	const { rest } = isDiscordReactionRuntimeContext(opts) ? createDiscordReactionRuntimeClient(opts) : resolveDiscordReactionClient(opts);
+	await deleteOwnMessageReaction(rest, channelId, messageId, normalizeReactionEmoji(emoji));
+	return { ok: true };
+}
+async function removeOwnReactionsDiscord(channelId, messageId, opts) {
+	const { rest } = isDiscordReactionRuntimeContext(opts) ? createDiscordReactionRuntimeClient(opts) : resolveDiscordReactionClient(opts);
+	const message = await getChannelMessage(rest, channelId, messageId);
+	const identifiers = /* @__PURE__ */ new Set();
+	for (const reaction of message.reactions ?? []) {
+		const identifier = buildReactionIdentifier(reaction.emoji);
+		if (identifier) identifiers.add(identifier);
+	}
+	if (identifiers.size === 0) return {
+		ok: true,
+		removed: []
+	};
+	const removed = Array.from(identifiers);
+	await Promise.all(removed.map((identifier) => deleteOwnMessageReaction(rest, channelId, messageId, normalizeReactionEmoji(identifier))));
+	return {
+		ok: true,
+		removed
+	};
+}
+async function fetchReactionsDiscord(channelId, messageId, opts) {
+	const { rest } = isDiscordReactionRuntimeContext(opts) ? createDiscordReactionRuntimeClient(opts) : resolveDiscordReactionClient(opts);
+	const reactions = (await getChannelMessage(rest, channelId, messageId)).reactions ?? [];
+	if (reactions.length === 0) return [];
+	const limit = typeof opts.limit === "number" && Number.isFinite(opts.limit) ? Math.min(Math.max(Math.floor(opts.limit), 1), 100) : 100;
+	const summaries = [];
+	for (const reaction of reactions) {
+		const identifier = buildReactionIdentifier(reaction.emoji);
+		if (!identifier) continue;
+		const users = await listMessageReactionUsers(rest, channelId, messageId, encodeURIComponent(identifier), { limit });
+		summaries.push({
+			emoji: {
+				id: reaction.emoji.id ?? null,
+				name: reaction.emoji.name ?? null,
+				raw: formatReactionEmoji(reaction.emoji)
+			},
+			count: reaction.count,
+			users: users.map((user) => ({
+				id: user.id,
+				username: user.username,
+				tag: user.username && user.discriminator ? `${user.username}#${user.discriminator}` : user.username
+			}))
+		});
+	}
+	return summaries;
+}
+//#endregion
+export { sendTypingDiscord as a, removeReactionDiscord as i, reactMessageDiscord as n, removeOwnReactionsDiscord as r, fetchReactionsDiscord as t };

package/dist/send.receipt-CuwRrpFz.js

@@ -0,0 +1,48 @@
+import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
+//#region extensions/discord/src/send.receipt.ts
+function createDiscordSendReceipt(params) {
+	return createMessageReceiptFromOutboundResults({
+		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;
+		}),
+		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
+export { createDiscordSendResult as n, createDiscordSendReceipt as t };

package/dist/{send.shared-XuOTO1dW.js → send.shared-Dfacnk-E.js}

@@ -1,6 +1,6 @@
-import { B as Embed, Ct as getThreadMember, D as RequestClient, Rt as getGuild, a as resolveDiscordReplyMessageId, dt as getCurrentUser, ht as createChannelMessage, k as RateLimitError, t as chunkDiscordTextWithMode, ut as createUserDmChannel, xt as getChannel, z as serializePayload, zt as getGuildMember } from "./chunk-CHpY_lsO.js";
-import { a as mergeDiscordAccountConfig, p as normalizeDiscordToken, s as resolveDiscordAccount } from "./accounts-CMd4nzLB.js";
-import { t as parseAndResolveDiscordTarget } from "./target-resolver-BaEmTxeK.js";
+import { D as RateLimitError, It as getGuild, L as serializePayload, Lt as getGuildMember, R as Embed, T as RequestClient, ct as createUserDmChannel, lt as getCurrentUser, pt as createChannelMessage, r as resolveDiscordReplyMessageId, t as chunkDiscordTextWithMode, xt as getThreadMember, yt as getChannel } from "./chunk-BrZocpfs.js";
+import { a as mergeDiscordAccountConfig, p as normalizeDiscordToken, s as resolveDiscordAccount } from "./accounts-D2LKPukU.js";
+import { t as parseAndResolveDiscordTarget } from "./target-resolver-Bo1oWLPO.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
 import { normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { ChannelType, MessageFlags, PermissionFlagsBits } from "discord-api-types/v10";
@@ -8,7 +8,7 @@ import { randomBytes } from "node:crypto";
 import { parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { collectErrorGraphCandidates, extractErrorCode, formatErrorMessage, readErrorName } from "openclaw/plugin-sdk/error-runtime";
-import { createChannelApiRetryRunner, resolveRetryConfig } from "openclaw/plugin-sdk/retry-runtime";
+import { classifyTransientNetworkErrorCode, createChannelApiRetryRunner, resolveRetryConfig } from "openclaw/plugin-sdk/retry-runtime";
 import { makeProxyFetch } from "openclaw/plugin-sdk/fetch-runtime";
 import { danger } from "openclaw/plugin-sdk/runtime-env";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
@@ -124,27 +124,7 @@ const DISCORD_RETRY_DEFAULTS = {
 };
 const DISCORD_GATEWAY_RECONNECT_EXTRA_ATTEMPTS = 2;
 const DISCORD_RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429]);
-const DISCORD_RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set([
-	"EAI_AGAIN",
-	"ECONNREFUSED",
-	"ECONNRESET",
-	"ENETUNREACH",
-	"ENOTFOUND",
-	"EPIPE",
-	"ETIMEDOUT",
-	"UND_ERR_BODY_TIMEOUT",
-	"UND_ERR_CONNECT_TIMEOUT",
-	"UND_ERR_HEADERS_TIMEOUT",
-	"UND_ERR_SOCKET"
-]);
 const DISCORD_TRANSIENT_MESSAGE_RE = /\b(?:bad gateway|fetch failed|network error|networkerror|service unavailable|socket hang up|temporarily unavailable|timed out|timeout)\b|connection (?:closed|reset|refused)/i;
-const DISCORD_PRECONNECT_ERROR_CODES = /* @__PURE__ */ new Set([
-	"EAI_AGAIN",
-	"ECONNREFUSED",
-	"ENETUNREACH",
-	"ENOTFOUND",
-	"UND_ERR_CONNECT_TIMEOUT"
-]);
 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);
@@ -154,8 +134,7 @@ function isRetryableDiscordTransientError(err) {
 	for (const candidate of collectErrorGraphCandidates(err, (current) => [current.cause, current.error])) {
 		const status = readDiscordErrorStatus(candidate);
 		if (status !== void 0 && (DISCORD_RETRYABLE_STATUS_CODES.has(status) || status >= 500)) return true;
-		const code = extractErrorCode(candidate);
-		if (code && DISCORD_RETRYABLE_ERROR_CODES.has(code.toUpperCase())) return true;
+		if (classifyTransientNetworkErrorCode(extractErrorCode(candidate))) return true;
 		if (readErrorName(candidate) === "AbortError") return true;
 		if ((candidate instanceof Error || candidate !== null && typeof candidate === "object") && DISCORD_TRANSIENT_MESSAGE_RE.test(formatErrorMessage(candidate))) return true;
 	}
@@ -165,8 +144,7 @@ function isRetryableDiscordPreConnectError(err) {
 	if (err instanceof RateLimitError) return true;
 	for (const candidate of collectErrorGraphCandidates(err, (current) => [current.cause, current.error])) {
 		if (readDiscordErrorStatus(candidate) === 429) return true;
-		const code = extractErrorCode(candidate);
-		if (code && DISCORD_PRECONNECT_ERROR_CODES.has(code.toUpperCase())) return true;
+		if (classifyTransientNetworkErrorCode(extractErrorCode(candidate)) === "pre-connect") return true;
 	}
 	return false;
 }
@@ -178,10 +156,7 @@ function isRetryableDiscordGatewayTransportError(err) {
 	return !collectErrorGraphCandidates(err, (current) => [current.cause, current.error]).some((candidate) => readDiscordErrorStatus(candidate) !== void 0);
 }
 function createDiscordRetryRunner(params) {
-	const retryConfig = resolveRetryConfig(DISCORD_RETRY_DEFAULTS, {
-		...params.configRetry,
-		...params.retry
-	});
+	const retryConfig = resolveRetryConfig(DISCORD_RETRY_DEFAULTS, params.retry);
 	const attempts = retryConfig.attempts > 1 ? retryConfig.attempts + DISCORD_GATEWAY_RECONNECT_EXTRA_ATTEMPTS : retryConfig.attempts;
 	return (fn, label, options) => {
 		const isRetryable = resolveDiscordRetryPredicate(options?.safety ?? "idempotent");
@@ -285,7 +260,6 @@ function createDiscordClient(opts) {
 		rest,
 		request: createDiscordRetryRunner({
 			retry: opts.retry,
-			configRetry: account.config.retry,
 			verbose: opts.verbose,
 			isGatewayDisconnected: () => {
 				const gateway = getGateway(account.accountId);

package/dist/{sender-identity-C62lBe18.js → sender-identity-mG_zsdox.js}

@@ -1,4 +1,4 @@
-import { x as formatDiscordUserTag } from "./allow-list-B7qOH5xu.js";
+import { x as formatDiscordUserTag } from "./allow-list-DzKrtfah.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/discord/src/monitor/sender-identity.ts
 function resolveDiscordWebhookId(message) {

package/dist/session-binding-contract-api.js

@@ -1,2 +1,2 @@
-import { i as testing, n as createThreadBindingManager } from "./thread-bindings.manager-DJ4cO5Eu.js";
+import { i as testing, n as createThreadBindingManager } from "./thread-bindings.manager-DlZEGvC1.js";
 export { createThreadBindingManager, testing as discordThreadBindingTesting };

package/dist/setup-plugin-api.js

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

package/dist/{shared-Bngr0I-v.js → shared-DMA7f3a8.js}

@@ -1,18 +1,19 @@
-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-CMd4nzLB.js";
+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-D2LKPukU.js";
+import { t as DiscordChannelConfigSchema } from "./config-schema-D-YrV-5E.js";
 import { i as getChatChannelMeta, o as resolveConfiguredFromCredentialStatuses } from "./channel-api-CAJ0wMoV.js";
-import { t as inspectDiscordAccount } from "./account-inspect-dFV0JrnR.js";
-import { t as DiscordChannelConfigSchema } from "./config-schema-CoDck1GW.js";
-import { n as normalizeCompatibilityConfig } from "./doctor-contract-wId6pV41.js";
-import { n as secretTargetRegistryEntries, t as collectRuntimeConfigAssignments } from "./secret-config-contract-BDNrRWvd.js";
+import { t as inspectDiscordAccount } from "./account-inspect-Dztmn4J4.js";
+import { n as normalizeCompatibilityConfig } from "./doctor-contract-BPUD3Di9.js";
+import { n as secretTargetRegistryEntries, t as collectRuntimeConfigAssignments } from "./secret-config-contract-B1akrlyY.js";
 import { n as unsupportedSecretRefSurfacePatterns, t as collectUnsupportedSecretRefConfigCandidates } from "./security-contract-DSHk7I2w.js";
 import { t as deriveLegacySessionChatType } from "./session-contract-BO5tlIdl.js";
 import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter, createScopedDmSecurityResolver } from "openclaw/plugin-sdk/channel-config-helpers";
+import { formatAllowFromLowercase } from "openclaw/plugin-sdk/allow-from";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { createOpenProviderConfiguredRouteWarningCollector } from "openclaw/plugin-sdk/channel-policy";
+import { defineChannelSetupContract } from "openclaw/plugin-sdk/channel-setup";
 import { createEnvPatchedAccountSetupAdapter } from "openclaw/plugin-sdk/setup-runtime";
-import { formatAllowFromLowercase } from "openclaw/plugin-sdk/allow-from";
 //#region extensions/discord/src/security.ts
 const resolveDiscordDmPolicy = createScopedDmSecurityResolver({
 	channelKey: "discord",
@@ -47,7 +48,7 @@ const collectDiscordSecurityWarnings = createOpenProviderConfiguredRouteWarningC
 		remediation: "Set channels.discord.groupPolicy=\"allowlist\" and configure channels.discord.guilds.<id>.channels"
 	}
 });
-const loadDiscordSecurityAuditModule = createLazyRuntimeModule(() => import("./security-audit.runtime-K0nkzjzJ.js"));
+const loadDiscordSecurityAuditModule = createLazyRuntimeModule(() => import("./security-audit.runtime-DZbDdAnw.js"));
 const discordSecurityAdapter = {
 	resolveDmPolicy: resolveDiscordDmPolicy,
 	collectWarnings: collectDiscordSecurityWarnings,
@@ -60,13 +61,33 @@ const discordSetupAdapter = createEnvPatchedAccountSetupAdapter({
 	hasCredentials: (input) => Boolean(input.token),
 	buildPatch: (input) => input.token ? { token: input.token } : {}
 });
+const discordSetupContract = defineChannelSetupContract({
+	fields: {
+		token: {
+			kind: "string",
+			sensitive: true,
+			cli: {
+				flags: "--token <token>",
+				description: "Discord bot token"
+			}
+		},
+		useEnv: {
+			kind: "boolean",
+			cli: {
+				flags: "--use-env",
+				description: "Use DISCORD_BOT_TOKEN"
+			}
+		}
+	},
+	legacyAdapter: discordSetupAdapter
+});
 //#endregion
 //#region extensions/discord/src/doctor-shared.ts
 const DISCORD_LEGACY_CONFIG_RULES = [];
 //#endregion
 //#region extensions/discord/src/shared.ts
 const DISCORD_CHANNEL = "discord";
-const loadDiscordDoctorModule = createLazyRuntimeModule(() => import("./doctor-Bq4pJAQk.js"));
+const loadDiscordDoctorModule = createLazyRuntimeModule(() => import("./doctor-CORGPgoY.js"));
 const discordDoctor = {
 	dmAllowFromMode: "topOnly",
 	groupModel: "route",
@@ -107,6 +128,7 @@ const discordConfigAdapter = createScopedChannelConfigAdapter({
 function createDiscordPluginBase(params) {
 	return {
 		id: DISCORD_CHANNEL,
+		...params.setupContract ? { setupContract: params.setupContract } : {},
 		...params.setupWizard ? { setupWizard: params.setupWizard } : {},
 		meta: { ...getChatChannelMeta(DISCORD_CHANNEL) },
 		capabilities: {
@@ -161,4 +183,4 @@ function createDiscordPluginBase(params) {
 	};
 }
 //#endregion
-export { discordSecurityAdapter as a, discordSetupAdapter as i, discordConfigAdapter as n, DISCORD_LEGACY_CONFIG_RULES as r, createDiscordPluginBase as t };
+export { discordSetupContract as a, discordSetupAdapter as i, discordConfigAdapter as n, discordSecurityAdapter as o, DISCORD_LEGACY_CONFIG_RULES as r, createDiscordPluginBase as t };