@openclaw/discord 2026.7.2-beta.7 → 2026.8.1-beta.2

package/dist/{send.reactions-CtlmGd_o.js → send.reactions-BAn0iiVQ.js}

@@ -1,15 +1,6 @@
-import { Dt as sendChannelTyping, bt as getChannelMessage, dt as deleteOwnMessageReaction, ft as listMessageReactionUsers, ut as createOwnMessageReaction } from "./chunk-DX4jpFQP.js";
-import { P as createDiscordClient, R as resolveDiscordRest, i as formatReactionEmoji, r as buildReactionIdentifier, s as normalizeReactionEmoji } from "./send.shared-jpvAG_u6.js";
+import { Et as getChannelMessage, _t as deleteOwnMessageReaction, gt as createOwnMessageReaction, vt as listMessageReactionUsers } from "./retry-CLpJcXXf.js";
+import { P as createDiscordClient, i as formatReactionEmoji, r as buildReactionIdentifier, s as normalizeReactionEmoji } from "./send.shared-BmwFjW6T.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);
@@ -32,16 +23,17 @@ async function reactMessageDiscord(channelId, messageId, emoji, opts) {
 	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));
+	const { rest, request } = isDiscordReactionRuntimeContext(opts) ? createDiscordReactionRuntimeClient(opts) : resolveDiscordReactionClient(opts);
+	const encoded = normalizeReactionEmoji(emoji);
+	await request(() => deleteOwnMessageReaction(rest, channelId, messageId, encoded), "reaction-remove");
 	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 { rest, request } = isDiscordReactionRuntimeContext(opts) ? createDiscordReactionRuntimeClient(opts) : resolveDiscordReactionClient(opts);
+	const message = await request(() => getChannelMessage(rest, channelId, messageId), "reaction-list");
 	const identifiers = /* @__PURE__ */ new Set();
 	for (const reaction of message.reactions ?? []) {
-		const identifier = buildReactionIdentifier(reaction.emoji);
+		const identifier = reaction.me ? buildReactionIdentifier(reaction.emoji) : void 0;
 		if (identifier) identifiers.add(identifier);
 	}
 	if (identifiers.size === 0) return {
@@ -49,22 +41,23 @@ async function removeOwnReactionsDiscord(channelId, messageId, opts) {
 		removed: []
 	};
 	const removed = Array.from(identifiers);
-	await Promise.all(removed.map((identifier) => deleteOwnMessageReaction(rest, channelId, messageId, normalizeReactionEmoji(identifier))));
+	await Promise.all(removed.map((identifier) => request(() => deleteOwnMessageReaction(rest, channelId, messageId, normalizeReactionEmoji(identifier)), "reaction-remove")));
 	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 ?? [];
+	const { rest, request } = isDiscordReactionRuntimeContext(opts) ? createDiscordReactionRuntimeClient(opts) : resolveDiscordReactionClient(opts);
+	const reactions = (await request(() => getChannelMessage(rest, channelId, messageId), "reaction-list")).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 });
+		const encoded = encodeURIComponent(identifier);
+		const users = await request(() => listMessageReactionUsers(rest, channelId, messageId, encoded, { limit }), "reaction-users");
 		summaries.push({
 			emoji: {
 				id: reaction.emoji.id ?? null,
@@ -82,4 +75,4 @@ async function fetchReactionsDiscord(channelId, messageId, opts) {
 	return summaries;
 }
 //#endregion
-export { sendTypingDiscord as a, removeReactionDiscord as i, reactMessageDiscord as n, removeOwnReactionsDiscord as r, fetchReactionsDiscord as t };
+export { removeReactionDiscord as i, reactMessageDiscord as n, removeOwnReactionsDiscord as r, fetchReactionsDiscord as t };

package/dist/{send.receipt-CuwRrpFz.js → send.receipt-IPI1p-SP.js}

@@ -1,5 +1,23 @@
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
+import { attachChannelToResults } from "openclaw/plugin-sdk/channel-send-result";
 //#region extensions/discord/src/send.receipt.ts
+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) {
 	return createMessageReceiptFromOutboundResults({
 		results: params.platformMessageIds.map((messageId) => messageId.trim()).filter((messageId) => messageId && messageId !== "unknown").map((messageId, index) => {
@@ -45,4 +63,4 @@ function createDiscordSendResult(params) {
 	};
 }
 //#endregion
-export { createDiscordSendResult as n, createDiscordSendReceipt as t };
+export { createDiscordSendReceiptFromResults as n, createDiscordSendResult as r, createDiscordSendReceipt as t };

package/dist/{send.shared-jpvAG_u6.js → send.shared-BmwFjW6T.js}

@@ -1,14 +1,11 @@
-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-DX4jpFQP.js";
+import { A as RequestClient, Dt as getThreadMember, H as serializePayload, Ht as getGuild, Tt as getChannel, U as Embed, Ut as getGuildMember, a as chunkDiscordTextWithMode, ft as stripUndefinedFields, ht as getCurrentUser, mt as createUserDmChannel, n as createDiscordRetryRunner, s as resolveDiscordReplyMessageId, yt as createChannelMessage } from "./retry-CLpJcXXf.js";
 import { a as mergeDiscordAccountConfig, p as normalizeDiscordToken, s as resolveDiscordAccount } from "./accounts-DJTf1LtA.js";
-import { t as parseAndResolveDiscordTarget } from "./target-resolver-C3s_2m0t.js";
+import { t as parseAndResolveDiscordTarget } from "./target-resolver-maOKSqO0.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";
 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 { 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";
@@ -18,11 +15,9 @@ import { resolveTextChunksWithFallback } from "openclaw/plugin-sdk/reply-payload
 import { loadWebMedia } from "openclaw/plugin-sdk/web-media";
 //#region extensions/discord/src/proxy-fetch.ts
 function resolveDiscordProxyUrl(account, cfg) {
-	const accountProxy = account.config.proxy?.trim();
+	const accountProxy = normalizeOptionalString(account.config.proxy);
 	if (accountProxy) return accountProxy;
-	const channelProxy = cfg?.channels?.discord?.proxy;
-	if (typeof channelProxy !== "string") return;
-	return channelProxy.trim() || void 0;
+	return normalizeOptionalString(cfg?.channels?.discord?.proxy);
 }
 function resolveDiscordProxyFetchByUrl(proxyUrl, runtime) {
 	return withValidatedDiscordProxy(proxyUrl, runtime, (proxy) => makeProxyFetch(proxy));
@@ -115,74 +110,6 @@ function createDiscordRequestClient(token, options) {
 	});
 }
 //#endregion
-//#region extensions/discord/src/retry.ts
-const DISCORD_RETRY_DEFAULTS = {
-	attempts: 3,
-	minDelayMs: 500,
-	maxDelayMs: 3e4,
-	jitter: .1
-};
-const DISCORD_GATEWAY_RECONNECT_EXTRA_ATTEMPTS = 2;
-const DISCORD_RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429]);
-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;
-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);
-}
-function isRetryableDiscordTransientError(err) {
-	if (err instanceof RateLimitError) return true;
-	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;
-		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;
-	}
-	return false;
-}
-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;
-		if (classifyTransientNetworkErrorCode(extractErrorCode(candidate)) === "pre-connect") return true;
-	}
-	return false;
-}
-function resolveDiscordRetryPredicate(safety) {
-	return safety === "non-idempotent-create" ? isRetryableDiscordPreConnectError : isRetryableDiscordTransientError;
-}
-function isRetryableDiscordGatewayTransportError(err) {
-	if (!isRetryableDiscordTransientError(err) || err instanceof RateLimitError) return false;
-	return !collectErrorGraphCandidates(err, (current) => [current.cause, current.error]).some((candidate) => readDiscordErrorStatus(candidate) !== void 0);
-}
-function createDiscordRetryRunner(params) {
-	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");
-		let observedGatewayDisconnect = false;
-		const runRequest = async () => {
-			observedGatewayDisconnect ||= params.isGatewayDisconnected?.() === true;
-			try {
-				return await fn();
-			} catch (err) {
-				observedGatewayDisconnect ||= params.isGatewayDisconnected?.() === true;
-				throw err;
-			}
-		};
-		return createChannelApiRetryRunner({
-			retry: {
-				...retryConfig,
-				attempts
-			},
-			shouldRetry: (err, attempt) => isRetryable(err) && (attempt < retryConfig.attempts || observedGatewayDisconnect && isRetryableDiscordGatewayTransportError(err)),
-			strictShouldRetry: true,
-			retryAfterMs: (err) => err instanceof RateLimitError ? err.retryAfter * 1e3 : void 0,
-			verbose: params.verbose
-		})(runRequest, label);
-	};
-}
-//#endregion
 //#region extensions/discord/src/client.ts
 function createDiscordRuntimeAccountContext(params) {
 	return {
@@ -562,6 +489,9 @@ function resolveDiscordMessageFlags(params) {
 	if (params.silent) flags |= SUPPRESS_NOTIFICATIONS_FLAG;
 	return flags || void 0;
 }
+function resolveDiscordSuppressEmbeds(params) {
+	return params.override ?? params.configured ?? true;
+}
 function buildDiscordMessageRequest(params) {
 	const payload = buildDiscordMessagePayload(params);
 	const nonce = params.endpoint === "create-message" ? params.nonce ?? createDiscordMessageNonce() : void 0;
@@ -575,9 +505,6 @@ function buildDiscordMessageRequest(params) {
 		enforce_nonce: nonce ? true : void 0
 	});
 }
-function stripUndefinedFields(value) {
-	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
-}
 function hasV2Components(components) {
 	return Boolean(components?.some((component) => "isV2" in component && component.isV2));
 }
@@ -710,7 +637,7 @@ function buildDiscordTextChunks(text, opts = {}) {
 	}));
 }
 async function sendDiscordText(params) {
-	const { rest, channelId, text, request, reply, maxLinesPerMessage, components, embeds, allowedMentions, chunkMode, silent, suppressEmbeds, maxChars, onResult } = params;
+	const { rest, channelId, text, request, reply, maxLinesPerMessage, components, embeds, allowedMentions, chunkMode, silent, suppressEmbeds, maxChars, onResult, onPlatformSendDispatch } = params;
 	if (!text.trim()) throw new Error("Message must be non-empty for Discord sends");
 	const chunks = buildDiscordTextChunks(text, {
 		maxLinesPerMessage,
@@ -741,6 +668,7 @@ async function sendDiscordText(params) {
 			flags,
 			replyTo: chunkReplyTo
 		});
+		await onPlatformSendDispatch?.();
 		return {
 			result: await request(() => createChannelMessage(rest, channelId, { body }), "text", { safety: "nonce-protected-create" }),
 			replyToId: chunkReplyTo
@@ -769,7 +697,7 @@ async function sendDiscordText(params) {
 	};
 }
 async function sendDiscordMedia(params) {
-	const { rest, channelId, text, mediaUrl, filename, mediaAccess, mediaLocalRoots, mediaReadFile, maxBytes, reply, request, maxLinesPerMessage, components, embeds, allowedMentions, chunkMode, silent, suppressEmbeds, maxChars, onResult } = params;
+	const { rest, channelId, text, mediaUrl, filename, mediaAccess, mediaLocalRoots, mediaReadFile, maxBytes, reply, request, maxLinesPerMessage, components, embeds, allowedMentions, chunkMode, silent, suppressEmbeds, maxChars, onResult, onPlatformSendDispatch } = params;
 	const media = await loadWebMedia(mediaUrl, buildOutboundMediaLoadOptions({
 		maxBytes,
 		mediaAccess,
@@ -805,11 +733,13 @@ async function sendDiscordMedia(params) {
 		replyTo: resolveDiscordReplyMessageId(reply, true),
 		files: [{
 			data: media.buffer,
-			name: resolvedFileName
+			name: resolvedFileName,
+			contentType: media.contentType
 		}]
 	});
 	let res;
 	try {
+		await onPlatformSendDispatch?.();
 		res = await request(() => createChannelMessage(rest, channelId, { body }), "media", { safety: "nonce-protected-create" });
 	} catch (err) {
 		if (!isDiscordUploadTooLargeError(err)) throw err;
@@ -825,7 +755,8 @@ async function sendDiscordMedia(params) {
 			suppressEmbeds,
 			allowedMentions,
 			maxChars,
-			onResult
+			onResult,
+			onPlatformSendDispatch
 		});
 	}
 	await onResult?.(res, "media", reply?.messageId);
@@ -862,4 +793,4 @@ function formatReactionEmoji(emoji) {
 	return buildReactionIdentifier(emoji);
 }
 //#endregion
-export { hasAllGuildPermissionsDiscord as A, clearGateways as B, DISCORD_MAX_STICKER_BYTES as C, canViewDiscordGuildChannel as D, canManageGuildRoleDiscord as E, createDiscordRestClient as F, resolveDiscordProxyFetchForAccount as G, registerGateway as H, createDiscordRuntimeAccountContext as I, validateDiscordProxyUrl as K, resolveDiscordClientAccountContext as L, hasAnyGuildPermissionDiscord as M, isThreadChannelType as N, fetchChannelPermissionsDiscord as O, createDiscordClient as P, resolveDiscordRest as R, DISCORD_MAX_EVENT_COVER_BYTES as S, canManageGuildMemberRoleDiscord as T, unregisterGateway as U, getGateway as V, parseAndResolveChannelRecipient as W, resolveDiscordMessageFlags as _, normalizeDiscordPollInput as a, stripUndefinedFields as b, normalizeStickerIds as c, resolveDiscordTargetChannelId as d, sendDiscordMedia as f, createDiscordMessageNonce as g, buildDiscordMessageRequest as h, formatReactionEmoji as i, hasAnyChannelPermissionDiscord as j, fetchMemberGuildPermissionsDiscord as k, resolveChannelId as l, SUPPRESS_NOTIFICATIONS_FLAG as m, buildDiscordTextChunks as n, normalizeEmojiName as o, sendDiscordText as p, withValidatedDiscordProxy as q, buildReactionIdentifier as r, normalizeReactionEmoji as s, buildDiscordSendError as t, resolveDiscordChannel as u, resolveDiscordSendComponents as v, DiscordSendError as w, DISCORD_MAX_EMOJI_BYTES as x, resolveDiscordSendEmbeds as y, DISCORD_REST_TIMEOUT_MS as z };
+export { hasAllGuildPermissionsDiscord as A, clearGateways as B, DISCORD_MAX_STICKER_BYTES as C, canViewDiscordGuildChannel as D, canManageGuildRoleDiscord as E, createDiscordRestClient as F, resolveDiscordProxyFetchForAccount as G, registerGateway as H, createDiscordRuntimeAccountContext as I, validateDiscordProxyUrl as K, resolveDiscordClientAccountContext as L, hasAnyGuildPermissionDiscord as M, isThreadChannelType as N, fetchChannelPermissionsDiscord as O, createDiscordClient as P, resolveDiscordRest as R, DISCORD_MAX_EVENT_COVER_BYTES as S, canManageGuildMemberRoleDiscord as T, unregisterGateway as U, getGateway as V, parseAndResolveChannelRecipient as W, resolveDiscordMessageFlags as _, normalizeDiscordPollInput as a, resolveDiscordSuppressEmbeds as b, normalizeStickerIds as c, resolveDiscordTargetChannelId as d, sendDiscordMedia as f, createDiscordMessageNonce as g, buildDiscordMessageRequest as h, formatReactionEmoji as i, hasAnyChannelPermissionDiscord as j, fetchMemberGuildPermissionsDiscord as k, resolveChannelId as l, SUPPRESS_NOTIFICATIONS_FLAG as m, buildDiscordTextChunks as n, normalizeEmojiName as o, sendDiscordText as p, withValidatedDiscordProxy as q, buildReactionIdentifier as r, normalizeReactionEmoji as s, buildDiscordSendError as t, resolveDiscordChannel as u, resolveDiscordSendComponents as v, DiscordSendError as w, DISCORD_MAX_EMOJI_BYTES as x, resolveDiscordSendEmbeds as y, DISCORD_REST_TIMEOUT_MS as z };

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

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

package/dist/setup-entry.js

@@ -2,14 +2,9 @@ import { defineBundledChannelSetupEntry } from "openclaw/plugin-sdk/channel-entr
 //#region extensions/discord/setup-entry.ts
 var setup_entry_default = defineBundledChannelSetupEntry({
 	importMetaUrl: import.meta.url,
-	features: { legacyStateMigrations: true },
 	plugin: {
 		specifier: "./setup-plugin-api.js",
 		exportName: "discordSetupPlugin"
-	},
-	legacyStateMigrations: {
-		specifier: "./legacy-state-migrations-api.js",
-		exportName: "detectDiscordLegacyStateMigrations"
 	}
 });
 //#endregion

package/dist/setup-plugin-api.js

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

package/dist/{shared-CXF1tup1.js → shared-BIXIX6uJ.js}

@@ -1,8 +1,8 @@
 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-DJTf1LtA.js";
-import { t as DiscordChannelConfigSchema } from "./config-schema-WHRQcY19.js";
+import { t as DiscordChannelConfigSchema } from "./config-schema-BgEskFAs.js";
 import { i as getChatChannelMeta, o as resolveConfiguredFromCredentialStatuses } from "./channel-api-CAJ0wMoV.js";
-import { t as inspectDiscordAccount } from "./account-inspect-SXiCBCgP.js";
-import { n as normalizeCompatibilityConfig } from "./doctor-contract-CCFMIDk9.js";
+import { t as inspectDiscordAccount } from "./account-inspect-CqzrH14k.js";
+import { n as normalizeCompatibilityConfig } from "./doctor-contract-DLa-BTiU.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";
@@ -54,13 +54,6 @@ const discordSecurityAdapter = {
 	collectWarnings: collectDiscordSecurityWarnings,
 	collectAuditFindings: async (params) => (await loadDiscordSecurityAuditModule()).collectDiscordSecurityAuditFindings(params)
 };
-const discordSetupAdapter = createEnvPatchedAccountSetupAdapter({
-	channelKey: "discord",
-	defaultAccountOnlyEnvError: "DISCORD_BOT_TOKEN can only be used for the default account.",
-	missingCredentialError: "Discord requires token (or --use-env).",
-	hasCredentials: (input) => Boolean(input.token),
-	buildPatch: (input) => input.token ? { token: input.token } : {}
-});
 const discordSetupContract = defineChannelSetupContract({
 	fields: {
 		token: {
@@ -76,10 +69,17 @@ const discordSetupContract = defineChannelSetupContract({
 			cli: {
 				flags: "--use-env",
 				description: "Use DISCORD_BOT_TOKEN"
-			}
+			},
+			envVars: ["DISCORD_BOT_TOKEN"]
 		}
 	},
-	legacyAdapter: discordSetupAdapter
+	legacyAdapter: createEnvPatchedAccountSetupAdapter({
+		channelKey: "discord",
+		defaultAccountOnlyEnvError: "DISCORD_BOT_TOKEN can only be used for the default account.",
+		missingCredentialError: "Discord requires token (or --use-env).",
+		hasCredentials: (input) => Boolean(input.token),
+		buildPatch: (input) => input.token ? { token: input.token } : {}
+	})
 });
 //#endregion
 //#region extensions/discord/src/doctor-shared.ts
@@ -87,7 +87,7 @@ const DISCORD_LEGACY_CONFIG_RULES = [];
 //#endregion
 //#region extensions/discord/src/shared.ts
 const DISCORD_CHANNEL = "discord";
-const loadDiscordDoctorModule = createLazyRuntimeModule(() => import("./doctor-Bc4S1qyd.js"));
+const loadDiscordDoctorModule = createLazyRuntimeModule(() => import("./doctor-BzC-TLnB.js"));
 const discordDoctor = {
 	dmAllowFromMode: "topOnly",
 	groupModel: "route",
@@ -128,7 +128,7 @@ const discordConfigAdapter = createScopedChannelConfigAdapter({
 function createDiscordPluginBase(params) {
 	return {
 		id: DISCORD_CHANNEL,
-		...params.setupContract ? { setupContract: params.setupContract } : {},
+		setupContract: params.setupContract,
 		...params.setupWizard ? { setupWizard: params.setupWizard } : {},
 		meta: { ...getChatChannelMeta(DISCORD_CHANNEL) },
 		capabilities: {
@@ -178,9 +178,8 @@ function createDiscordPluginBase(params) {
 			unsupportedSecretRefSurfacePatterns,
 			collectUnsupportedSecretRefConfigCandidates,
 			collectRuntimeConfigAssignments
-		},
-		setup: params.setup
+		}
 	};
 }
 //#endregion
-export { discordSetupContract as a, discordSetupAdapter as i, discordConfigAdapter as n, discordSecurityAdapter as o, DISCORD_LEGACY_CONFIG_RULES as r, createDiscordPluginBase as t };
+export { discordSecurityAdapter as a, discordSetupContract as i, discordConfigAdapter as n, DISCORD_LEGACY_CONFIG_RULES as r, createDiscordPluginBase as t };

package/dist/{subagent-hooks-Dxy7Fmnq.js → subagent-hooks-CTt5KCJr.js}

@@ -1,6 +1,6 @@
-import { Yt as __exportAll } from "./chunk-DX4jpFQP.js";
+import { tn as __exportAll } from "./retry-CLpJcXXf.js";
 import { s as resolveDiscordAccount } from "./accounts-DJTf1LtA.js";
-import { n as autoBindSpawnedDiscordSubagent, o as unbindThreadBindingsBySessionKey, r as listThreadBindingsBySessionKey } from "./thread-bindings-C-M-ly7P.js";
+import { n as autoBindSpawnedDiscordSubagent, o as unbindThreadBindingsBySessionKey, r as listThreadBindingsBySessionKey } from "./thread-bindings-3L8p82GV.js";
 import { normalizeOptionalLowercaseString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { formatThreadBindingDisabledError, formatThreadBindingSpawnDisabledError, resolveThreadBindingSpawnPolicy } from "openclaw/plugin-sdk/conversation-runtime";
 //#region extensions/discord/src/subagent-hooks.ts

package/dist/subagent-hooks-api.js

@@ -1,16 +1,12 @@
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 //#region extensions/discord/subagent-hooks-api.ts
-const loadDiscordSubagentHooksModule = createLazyRuntimeModule(() => import("./subagent-hooks-Dxy7Fmnq.js").then((n) => n.i));
-const loadDiscordSubagentProgressModule = createLazyRuntimeModule(() => import("./subagent-progress-DI3sYLLo.js"));
+const loadDiscordSubagentHooksModule = createLazyRuntimeModule(() => import("./subagent-hooks-CTt5KCJr.js").then((n) => n.i));
+const loadDiscordSubagentProgressModule = createLazyRuntimeModule(() => import("./subagent-progress-DhaE_h8a.js"));
 function registerDiscordSubagentHooks(api) {
 	api.on("gateway_start", async () => {
 		const { recoverDiscordSubagentProgress } = await loadDiscordSubagentProgressModule();
 		await recoverDiscordSubagentProgress(api);
 	});
-	api.on("subagent_progress", async (event) => {
-		const { handleDiscordSubagentProgress } = await loadDiscordSubagentProgressModule();
-		await handleDiscordSubagentProgress(api, event);
-	});
 	api.on("subagent_ended", async (event) => {
 		const { handleDiscordSubagentEnded } = await loadDiscordSubagentHooksModule();
 		handleDiscordSubagentEnded(event);

package/dist/subagent-progress-DhaE_h8a.js

@@ -0,0 +1,109 @@
+import { l as resolveDiscordAccountConfig, s as resolveDiscordAccount } from "./accounts-DJTf1LtA.js";
+import { i as removeReactionDiscord } from "./send.reactions-BAn0iiVQ.js";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/routing";
+import { DEFAULT_EMOJIS } from "openclaw/plugin-sdk/channel-feedback";
+//#region extensions/discord/src/subagent-progress.ts
+const PROGRESS_STORE_TTL_MS = 10080 * 6e4;
+const MAX_TRACKED_RUNS = 4096;
+const RETRY_BASE_DELAY_MS = 1e3;
+const RETRY_MAX_DELAY_MS = 60 * 6e4;
+const RETRY_MAX_ATTEMPTS = 12;
+const HISTORICAL_RUNNING_EMOJIS = /* @__PURE__ */ new Set([
+	"1️⃣",
+	"2️⃣",
+	"3️⃣",
+	"4️⃣",
+	"5️⃣",
+	"6️⃣",
+	"7️⃣",
+	"8️⃣",
+	"9️⃣",
+	"🔟"
+]);
+const recoveryRetries = /* @__PURE__ */ new Map();
+function logFailure(api, action, error) {
+	const message = error instanceof Error ? error.message : String(error);
+	api.logger.debug?.(`discord retired subagent progress ${action} failed: ${message}`);
+}
+function reservedReactionEmojis(api, accountAckReaction) {
+	const reserved = new Set(Object.values(DEFAULT_EMOJIS));
+	for (const emoji of [api.config.messages?.ackReaction, accountAckReaction]) if (emoji?.trim()) reserved.add(emoji.trim());
+	for (const agent of api.config.agents?.list ?? []) {
+		const emoji = agent.identity?.emoji?.trim();
+		if (emoji) reserved.add(emoji);
+	}
+	return reserved;
+}
+function clearRecoveryRetry(api) {
+	const retry = recoveryRetries.get(api);
+	if (retry?.timer) clearTimeout(retry.timer);
+	recoveryRetries.delete(api);
+}
+function scheduleRecoveryRetry(api) {
+	const retry = recoveryRetries.get(api) ?? { attempts: 0 };
+	if (retry.timer || retry.attempts >= RETRY_MAX_ATTEMPTS) return;
+	const delayMs = Math.min(RETRY_BASE_DELAY_MS * 2 ** retry.attempts, RETRY_MAX_DELAY_MS);
+	retry.attempts += 1;
+	retry.timer = setTimeout(() => {
+		retry.timer = void 0;
+		recoverDiscordSubagentProgress(api);
+	}, delayMs);
+	retry.timer.unref?.();
+	recoveryRetries.set(api, retry);
+}
+async function cleanPersistedReaction(api, store, entry) {
+	try {
+		if (entry.value.accountId !== DEFAULT_ACCOUNT_ID && !resolveDiscordAccountConfig(api.config, entry.value.accountId)) return false;
+		const account = resolveDiscordAccount({
+			cfg: api.config,
+			accountId: entry.value.accountId
+		});
+		if (!account.enabled || account.tokenStatus !== "available") return false;
+		const emoji = entry.value.runningEmoji;
+		if (emoji && HISTORICAL_RUNNING_EMOJIS.has(emoji) && !reservedReactionEmojis(api, account.config.ackReaction).has(emoji)) await removeReactionDiscord(entry.value.channelId, entry.value.messageId, emoji, {
+			cfg: api.config,
+			accountId: entry.value.accountId
+		});
+		await store.consume(entry.key);
+		return true;
+	} catch (error) {
+		logFailure(api, "startup cleanup", error);
+		return false;
+	}
+}
+async function recoverDiscordSubagentProgressImpl(api) {
+	let store;
+	try {
+		store = api.runtime.state.openKeyedStore({
+			namespace: "subagent-progress",
+			maxEntries: MAX_TRACKED_RUNS,
+			overflowPolicy: "reject-new",
+			defaultTtlMs: PROGRESS_STORE_TTL_MS
+		});
+	} catch (error) {
+		logFailure(api, "state store open", error);
+		scheduleRecoveryRetry(api);
+		return;
+	}
+	let entries;
+	try {
+		entries = await store.entries();
+	} catch (error) {
+		logFailure(api, "startup recovery list", error);
+		scheduleRecoveryRetry(api);
+		return;
+	}
+	let retryNeeded = false;
+	for (const entry of entries) if (!await cleanPersistedReaction(api, store, entry)) retryNeeded = true;
+	if (retryNeeded) scheduleRecoveryRetry(api);
+	else clearRecoveryRetry(api);
+}
+function resetDiscordSubagentProgressForTest() {
+	for (const [api, retry] of recoveryRetries) {
+		if (retry.timer) clearTimeout(retry.timer);
+		recoveryRetries.delete(api);
+	}
+}
+const recoverDiscordSubagentProgress = Object.assign(recoverDiscordSubagentProgressImpl, { resetForTest: resetDiscordSubagentProgressForTest });
+//#endregion
+export { recoverDiscordSubagentProgress };

package/dist/{system-events-DdUqf91B.js → system-events-CTqDf6_s.js}

@@ -1,5 +1,5 @@
-import { d as discord_exports } from "./chunk-DX4jpFQP.js";
-import { x as formatDiscordUserTag } from "./allow-list-DzKrtfah.js";
+import { h as discord_exports } from "./retry-CLpJcXXf.js";
+import { x as formatDiscordUserTag } from "./allow-list-DnxIlPP2.js";
 //#region extensions/discord/src/monitor/system-events.ts
 function resolveDiscordSystemEvent(message, location) {
 	switch (message.type) {

package/dist/{target-resolver-C3s_2m0t.js → target-resolver-maOKSqO0.js}

@@ -1,6 +1,6 @@
-import { Yt as __exportAll, a as allowFromContainsDiscordUserId, l as parseDiscordTarget } from "./chunk-DX4jpFQP.js";
+import { l as allowFromContainsDiscordUserId, p as parseDiscordTarget, tn as __exportAll } from "./retry-CLpJcXXf.js";
 import { c as resolveDiscordAccountAllowFrom, s as resolveDiscordAccount } from "./accounts-DJTf1LtA.js";
-import { a as rememberDiscordDirectoryUser, r as listDiscordDirectoryPeersLive } from "./directory-live-Bw5Ephzv.js";
+import { a as rememberDiscordDirectoryUser, r as listDiscordDirectoryPeersLive } from "./directory-live-DGIGxpIo.js";
 import { buildMessagingTarget } from "openclaw/plugin-sdk/channel-targets";
 //#region extensions/discord/src/send-target-parsing.ts
 const parseDiscordSendTarget = (raw, options = {}) => parseDiscordTarget(raw, options);

package/dist/targets-yUFTHoAx.js

@@ -0,0 +1,3 @@
+import "./retry-CLpJcXXf.js";
+import "./target-resolver-maOKSqO0.js";
+export {};

package/dist/{thread-bindings-C-M-ly7P.js → thread-bindings-3L8p82GV.js}

@@ -1,9 +1,8 @@
-import { Yt as __exportAll, l as parseDiscordTarget } from "./chunk-DX4jpFQP.js";
-import "./targets-Dv_RN7vT.js";
-import { C as resolveThreadBindingInactivityExpiresAt, E as saveBindingsToDisk, S as resolveThreadBindingIdleTimeoutMs$1, T as resolveThreadBindingMaxAgeMs$1, h as refreshUnboundThreadWebhookIdentity, k as shouldPersistBindingMutations, m as normalizeThreadId, n as MANAGERS_BY_ACCOUNT_ID, t as BINDINGS_BY_THREAD_ID, u as getThreadBindingToken, v as removeBindingRecord, w as resolveThreadBindingMaxAgeExpiresAt } from "./thread-bindings.state-Cgi5uRn-.js";
-import { n as setThreadBindingMaxAgeBySessionKey, r as resolveBindingIdsForTargetSession, t as setThreadBindingIdleTimeoutBySessionKey } from "./thread-bindings.session-updates-DAIlp7Px.js";
-import { S as resolveThreadBindingThreadName, _ as resolveThreadBindingPersona, s as resolveChannelIdForBinding, v as resolveThreadBindingPersonaFromRecord, x as resolveThreadBindingIntroText, y as formatThreadBindingDurationLabel } from "./thread-bindings.discord-api-BoDNqamb.js";
-import { i as testing, n as createThreadBindingManager, r as getThreadBindingManager, t as createNoopThreadBindingManager } from "./thread-bindings.manager-DYvSlrva.js";
+import { p as parseDiscordTarget, tn as __exportAll } from "./retry-CLpJcXXf.js";
+import "./targets-yUFTHoAx.js";
+import { C as resolveThreadBindingMaxAgeExpiresAt, O as shouldPersistBindingMutations, S as resolveThreadBindingInactivityExpiresAt, T as saveBindingsToDisk, h as refreshUnboundThreadWebhookIdentity, m as normalizeThreadId, n as MANAGERS_BY_ACCOUNT_ID, t as BINDINGS_BY_THREAD_ID, u as getThreadBindingToken, v as removeBindingRecord, w as resolveThreadBindingMaxAgeMs$1, x as resolveThreadBindingIdleTimeoutMs$1 } from "./thread-bindings.state-aeV8HNgV.js";
+import { n as setThreadBindingMaxAgeBySessionKey, r as resolveBindingIdsForTargetSession, t as setThreadBindingIdleTimeoutBySessionKey } from "./thread-bindings.session-updates-bJ2KQFY6.js";
+import { _ as resolveThreadBindingThreadName, g as resolveThreadBindingIntroText, h as formatThreadBindingDurationLabel, m as resolveThreadBindingPersonaFromRecord, n as createThreadBindingManager, o as resolveChannelIdForBinding, p as resolveThreadBindingPersona, r as getThreadBindingManager, t as createNoopThreadBindingManager } from "./thread-bindings.manager-DCIH6WDC.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
 import { normalizeOptionalLowercaseString, normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveThreadBindingIdleTimeoutMs, resolveThreadBindingMaxAgeMs, resolveThreadBindingsEnabled } from "openclaw/plugin-sdk/conversation-runtime";
@@ -230,7 +229,6 @@ var thread_bindings_exports = /* @__PURE__ */ __exportAll({
 	resolveThreadBindingsEnabled: () => resolveThreadBindingsEnabled,
 	setThreadBindingIdleTimeoutBySessionKey: () => setThreadBindingIdleTimeoutBySessionKey,
 	setThreadBindingMaxAgeBySessionKey: () => setThreadBindingMaxAgeBySessionKey,
-	testing: () => testing,
 	unbindThreadBindingsBySessionKey: () => unbindThreadBindingsBySessionKey
 });
 //#endregion