@openclaw/discord 2026.8.1-beta.2 → 2026.8.1-beta.3

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

@@ -1,53 +1,18 @@
-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-maOKSqO0.js";
-import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
-import { normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { B as hasDiscordV2Components, Et as getThreadMember, H as Embed, Ht as getGuildMember, O as RequestClient, V as serializePayload, Vt as getGuild, a as chunkDiscordTextWithMode, mt as getCurrentUser, n as createDiscordRetryRunner, pt as createUserDmChannel, s as resolveDiscordReplyMessageId, vt as createChannelMessage, wt as getChannel } from "./retry-DNsVTeTo.js";
+import { c as resolveDiscordAccount, m as normalizeDiscordToken, o as mergeDiscordAccountConfig } from "./accounts-DNl-oCEw.js";
+import { t as parseAndResolveDiscordTarget } from "./target-resolver-DIXShHaZ.js";
 import { ChannelType, MessageFlags, PermissionFlagsBits } from "discord-api-types/v10";
 import { randomBytes } from "node:crypto";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
+import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
+import { normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-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";
 import { PollLayoutType } from "discord-api-types/payloads/v10";
 import { buildOutboundMediaLoadOptions, extensionForMime, normalizePollDurationHours, normalizePollInput } from "openclaw/plugin-sdk/media-runtime";
 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 = normalizeOptionalString(account.config.proxy);
-	if (accountProxy) return accountProxy;
-	return normalizeOptionalString(cfg?.channels?.discord?.proxy);
-}
-function resolveDiscordProxyFetchByUrl(proxyUrl, runtime) {
-	return withValidatedDiscordProxy(proxyUrl, runtime, (proxy) => makeProxyFetch(proxy));
-}
-function resolveDiscordProxyFetchForAccount(account, cfg, runtime) {
-	return resolveDiscordProxyFetchByUrl(resolveDiscordProxyUrl(account, cfg), runtime);
-}
-function withValidatedDiscordProxy(proxyUrl, runtime, createValue) {
-	const proxy = proxyUrl?.trim();
-	if (!proxy) return;
-	try {
-		validateDiscordProxyUrl(proxy);
-		return createValue(proxy);
-	} catch (err) {
-		runtime?.error?.(danger(`discord: invalid rest proxy: ${String(err)}`));
-		return;
-	}
-}
-function validateDiscordProxyUrl(proxyUrl) {
-	let parsed;
-	try {
-		parsed = new URL(proxyUrl);
-	} catch {
-		throw new Error("Proxy URL must be a valid http or https URL");
-	}
-	if (!["http:", "https:"].includes(parsed.protocol)) throw new Error("Proxy URL must use http or https");
-	if (!parsed.hostname) throw new Error("Proxy URL must include a host");
-	return proxyUrl;
-}
-//#endregion
 //#region extensions/discord/src/recipient-resolution.ts
 async function parseAndResolveRecipient(raw, cfg, accountId, parseOptions = {}) {
 	if (!cfg) throw new Error("Discord recipient resolution requires a resolved runtime config. Load and resolve config at the command or gateway boundary, then pass cfg through the runtime path.");
@@ -97,6 +62,41 @@ function clearGateways() {
 	gatewayRegistry.clear();
 }
 //#endregion
+//#region extensions/discord/src/proxy-fetch.ts
+function resolveDiscordProxyUrl(account, cfg) {
+	const accountProxy = normalizeOptionalString(account.config.proxy);
+	if (accountProxy) return accountProxy;
+	return normalizeOptionalString(cfg?.channels?.discord?.proxy);
+}
+function resolveDiscordProxyFetchByUrl(proxyUrl, runtime) {
+	return withValidatedDiscordProxy(proxyUrl, runtime, (proxy) => makeProxyFetch(proxy));
+}
+function resolveDiscordProxyFetchForAccount(account, cfg, runtime) {
+	return resolveDiscordProxyFetchByUrl(resolveDiscordProxyUrl(account, cfg), runtime);
+}
+function withValidatedDiscordProxy(proxyUrl, runtime, createValue) {
+	const proxy = proxyUrl?.trim();
+	if (!proxy) return;
+	try {
+		validateDiscordProxyUrl(proxy);
+		return createValue(proxy);
+	} catch (err) {
+		runtime?.error?.(danger(`discord: invalid rest proxy: ${String(err)}`));
+		return;
+	}
+}
+function validateDiscordProxyUrl(proxyUrl) {
+	let parsed;
+	try {
+		parsed = new URL(proxyUrl);
+	} catch {
+		throw new Error("Proxy URL must be a valid http or https URL");
+	}
+	if (!["http:", "https:"].includes(parsed.protocol)) throw new Error("Proxy URL must use http or https");
+	if (!parsed.hostname) throw new Error("Proxy URL must include a host");
+	return proxyUrl;
+}
+//#endregion
 //#region extensions/discord/src/proxy-request-client.ts
 const DISCORD_REST_TIMEOUT_MS = 15e3;
 function createDiscordRequestClient(token, options) {
@@ -199,6 +199,59 @@ function resolveDiscordRest(opts) {
 	return createDiscordRestClient(opts).rest;
 }
 //#endregion
+//#region extensions/discord/src/send.message-request.ts
+const SUPPRESS_EMBEDS_FLAG = MessageFlags.SuppressEmbeds;
+const SUPPRESS_NOTIFICATIONS_FLAG = MessageFlags.SuppressNotifications;
+function createDiscordMessageNonce() {
+	return randomBytes(12).toString("hex");
+}
+function resolveDiscordSendComponents(params) {
+	if (!params.components || !params.isFirst) return;
+	return typeof params.components === "function" ? params.components(params.text) : params.components;
+}
+function normalizeDiscordEmbeds(embeds) {
+	if (!embeds?.length) return;
+	return embeds.map((embed) => embed instanceof Embed ? embed : new Embed(embed));
+}
+function resolveDiscordSendEmbeds(params) {
+	if (!params.embeds || !params.isFirst) return;
+	return normalizeDiscordEmbeds(params.embeds);
+}
+function buildDiscordMessagePayload(params) {
+	const payload = {};
+	const hasV2 = hasDiscordV2Components(params.components);
+	const trimmed = params.text.trim();
+	if (!hasV2 && trimmed) payload.content = params.text;
+	if (params.components?.length) payload.components = params.components;
+	if (!hasV2 && params.embeds?.length) payload.embeds = params.embeds;
+	if (params.allowedMentions) payload.allowed_mentions = params.allowedMentions;
+	if (params.flags !== void 0) payload.flags = params.flags;
+	if (params.files?.length) payload.files = params.files;
+	return payload;
+}
+function resolveDiscordMessageFlags(params) {
+	let flags = 0;
+	if (params.suppressEmbeds) flags |= SUPPRESS_EMBEDS_FLAG;
+	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;
+	return {
+		...serializePayload(payload),
+		...params.replyTo ? { message_reference: {
+			message_id: params.replyTo,
+			fail_if_not_exists: false
+		} } : {},
+		...nonce !== void 0 ? { nonce } : {},
+		...nonce ? { enforce_nonce: true } : {}
+	};
+}
+//#endregion
 //#region extensions/discord/src/send.permissions.ts
 const PERMISSION_ENTRIES = Object.entries(PermissionFlagsBits).filter(([, value]) => typeof value === "bigint");
 const ALL_PERMISSIONS = PERMISSION_ENTRIES.reduce((acc, [, value]) => acc | value, 0n);
@@ -453,62 +506,6 @@ const DISCORD_MAX_EMOJI_BYTES = 256 * 1024;
 const DISCORD_MAX_STICKER_BYTES = 512 * 1024;
 const DISCORD_MAX_EVENT_COVER_BYTES = 8 * 1024 * 1024;
 //#endregion
-//#region extensions/discord/src/send.message-request.ts
-const SUPPRESS_EMBEDS_FLAG = MessageFlags.SuppressEmbeds;
-const SUPPRESS_NOTIFICATIONS_FLAG = MessageFlags.SuppressNotifications;
-function createDiscordMessageNonce() {
-	return randomBytes(12).toString("hex");
-}
-function resolveDiscordSendComponents(params) {
-	if (!params.components || !params.isFirst) return;
-	return typeof params.components === "function" ? params.components(params.text) : params.components;
-}
-function normalizeDiscordEmbeds(embeds) {
-	if (!embeds?.length) return;
-	return embeds.map((embed) => embed instanceof Embed ? embed : new Embed(embed));
-}
-function resolveDiscordSendEmbeds(params) {
-	if (!params.embeds || !params.isFirst) return;
-	return normalizeDiscordEmbeds(params.embeds);
-}
-function buildDiscordMessagePayload(params) {
-	const payload = {};
-	const hasV2 = hasV2Components(params.components);
-	const trimmed = params.text.trim();
-	if (!hasV2 && trimmed) payload.content = params.text;
-	if (params.components?.length) payload.components = params.components;
-	if (!hasV2 && params.embeds?.length) payload.embeds = params.embeds;
-	if (params.allowedMentions) payload.allowed_mentions = params.allowedMentions;
-	if (params.flags !== void 0) payload.flags = params.flags;
-	if (params.files?.length) payload.files = params.files;
-	return payload;
-}
-function resolveDiscordMessageFlags(params) {
-	let flags = 0;
-	if (params.suppressEmbeds) flags |= SUPPRESS_EMBEDS_FLAG;
-	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;
-	return stripUndefinedFields({
-		...serializePayload(payload),
-		...params.replyTo ? { message_reference: {
-			message_id: params.replyTo,
-			fail_if_not_exists: false
-		} } : {},
-		nonce,
-		enforce_nonce: nonce ? true : void 0
-	});
-}
-function hasV2Components(components) {
-	return Boolean(components?.some((component) => "isV2" in component && component.isV2));
-}
-//#endregion
 //#region extensions/discord/src/send.shared.ts
 const DISCORD_TEXT_LIMIT = 2e3;
 const DISCORD_MAX_STICKERS = 3;
@@ -638,14 +635,13 @@ function buildDiscordTextChunks(text, opts = {}) {
 }
 async function sendDiscordText(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,
 		chunkMode,
 		maxChars
 	});
+	if (!chunks.length) chunks.push("");
 	const sendChunk = async (chunk, isFirst) => {
-		const chunkReplyTo = resolveDiscordReplyMessageId(reply, isFirst);
 		const chunkComponents = resolveDiscordSendComponents({
 			components,
 			text: chunk,
@@ -655,6 +651,9 @@ async function sendDiscordText(params) {
 			embeds,
 			isFirst
 		});
+		if (!chunk.trim() && !chunkComponents?.length && !chunkEmbeds?.length) throw new Error("Message must be non-empty for Discord sends");
+		const chunkReplyTo = resolveDiscordReplyMessageId(reply, isFirst);
+		const kind = chunkComponents?.length || chunkEmbeds?.length ? "card" : "text";
 		const flags = resolveDiscordMessageFlags({
 			silent,
 			suppressEmbeds: suppressEmbeds && !chunkEmbeds?.length
@@ -671,12 +670,13 @@ async function sendDiscordText(params) {
 		await onPlatformSendDispatch?.();
 		return {
 			result: await request(() => createChannelMessage(rest, channelId, { body }), "text", { safety: "nonce-protected-create" }),
-			replyToId: chunkReplyTo
+			replyToId: chunkReplyTo,
+			kind
 		};
 	};
 	if (chunks.length === 1) {
-		const { result, replyToId } = await sendChunk(expectDefined(chunks.at(0), "single Discord text chunk"), true);
-		await onResult?.(result, "text", replyToId);
+		const { result, replyToId, kind } = await sendChunk(expectDefined(chunks.at(0), "single Discord text chunk"), true);
+		await onResult?.(result, kind, replyToId);
 		return {
 			...result,
 			platformMessageIds: result.id ? [result.id] : []
@@ -687,7 +687,7 @@ async function sendDiscordText(params) {
 	for (const [index, chunk] of chunks.entries()) {
 		const sent = await sendChunk(chunk, index === 0);
 		last = sent.result;
-		await onResult?.(last, "text", sent.replyToId);
+		await onResult?.(last, sent.kind, sent.replyToId);
 		if (last.id) platformMessageIds.push(last.id);
 	}
 	if (!last) throw new Error("Discord send failed (empty chunk result)");
@@ -793,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, 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 };
+export { resolveDiscordMessageFlags as A, resolveDiscordProxyFetchForAccount as B, hasAllGuildPermissionsDiscord as C, SUPPRESS_NOTIFICATIONS_FLAG as D, isThreadChannelType as E, createDiscordRestClient as F, registerGateway as G, withValidatedDiscordProxy as H, createDiscordRuntimeAccountContext as I, unregisterGateway as K, resolveDiscordClientAccountContext as L, resolveDiscordSendEmbeds as M, resolveDiscordSuppressEmbeds as N, buildDiscordMessageRequest as O, createDiscordClient as P, resolveDiscordRest as R, fetchMemberGuildPermissionsDiscord as S, hasAnyGuildPermissionDiscord as T, clearGateways as U, validateDiscordProxyUrl as V, getGateway as W, DiscordSendError as _, normalizeDiscordPollInput as a, canViewDiscordGuildChannel as b, normalizeStickerIds as c, resolveDiscordTargetChannelId as d, sendDiscordMedia as f, DISCORD_MAX_STICKER_BYTES as g, DISCORD_MAX_EVENT_COVER_BYTES as h, formatReactionEmoji as i, resolveDiscordSendComponents as j, createDiscordMessageNonce as k, resolveChannelId as l, DISCORD_MAX_EMOJI_BYTES as m, buildDiscordTextChunks as n, normalizeEmojiName as o, sendDiscordText as p, parseAndResolveChannelRecipient as q, buildReactionIdentifier as r, normalizeReactionEmoji as s, buildDiscordSendError as t, resolveDiscordChannel as u, canManageGuildMemberRoleDiscord as v, hasAnyChannelPermissionDiscord as w, fetchChannelPermissionsDiscord as x, canManageGuildRoleDiscord as y, DISCORD_REST_TIMEOUT_MS as z };

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

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

package/dist/setup-plugin-api.js

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

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

@@ -1,9 +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-BgEskFAs.js";
-import { i as getChatChannelMeta, o as resolveConfiguredFromCredentialStatuses } from "./channel-api-CAJ0wMoV.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 { t as DiscordChannelConfigSchema } from "./config-schema-DC5kDtQ5.js";
+import { I as resolveConfiguredFromCredentialStatuses, P as getChatChannelMeta, c as resolveDiscordAccount, d as resolveDiscordAccountDisabledReason, f as resolveDiscordAccountDmPolicy, l as resolveDiscordAccountAllowFrom, n as isDiscordAccountEnabledForRuntime, o as mergeDiscordAccountConfig, r as listDiscordAccountIds, s as resolveDefaultDiscordAccountId } from "./accounts-DNl-oCEw.js";
+import { t as inspectDiscordAccount } from "./account-inspect-D5xmUpnj.js";
+import { n as normalizeCompatibilityConfig } from "./doctor-contract-DsWvKIXF.js";
+import { r as secretTargetRegistryEntries, t as collectRuntimeConfigAssignments } from "./secret-config-contract-B3i6WxV5.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";
@@ -11,7 +10,7 @@ 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 { createConditionalWarningCollector, createOpenProviderConfiguredRouteWarningCollector } from "openclaw/plugin-sdk/channel-policy";
 import { defineChannelSetupContract } from "openclaw/plugin-sdk/channel-setup";
 import { createEnvPatchedAccountSetupAdapter } from "openclaw/plugin-sdk/setup-runtime";
 //#region extensions/discord/src/security.ts
@@ -48,10 +47,16 @@ const collectDiscordSecurityWarnings = createOpenProviderConfiguredRouteWarningC
 		remediation: "Set channels.discord.groupPolicy=\"allowlist\" and configure channels.discord.guilds.<id>.channels"
 	}
 });
-const loadDiscordSecurityAuditModule = createLazyRuntimeModule(() => import("./security-audit.runtime-CPN0xFYz.js"));
+const collectDiscordSecurityFindings = createConditionalWarningCollector.findings({
+	collectWarnings: collectDiscordSecurityWarnings,
+	checkId: "channels.discord.groups.open",
+	severity: "critical",
+	title: "Discord security warning"
+});
+const loadDiscordSecurityAuditModule = createLazyRuntimeModule(() => import("./security-audit.runtime-BVKF9VtY.js"));
 const discordSecurityAdapter = {
 	resolveDmPolicy: resolveDiscordDmPolicy,
-	collectWarnings: collectDiscordSecurityWarnings,
+	collectWarnings: collectDiscordSecurityFindings,
 	collectAuditFindings: async (params) => (await loadDiscordSecurityAuditModule()).collectDiscordSecurityAuditFindings(params)
 };
 const discordSetupContract = defineChannelSetupContract({
@@ -87,7 +92,7 @@ const DISCORD_LEGACY_CONFIG_RULES = [];
 //#endregion
 //#region extensions/discord/src/shared.ts
 const DISCORD_CHANNEL = "discord";
-const loadDiscordDoctorModule = createLazyRuntimeModule(() => import("./doctor-BzC-TLnB.js"));
+const loadDiscordDoctorModule = createLazyRuntimeModule(() => import("./doctor-DYY31GrO.js"));
 const discordDoctor = {
 	dmAllowFromMode: "topOnly",
 	groupModel: "route",

package/dist/subagent-hooks-CNT2ZJTJ.js

@@ -0,0 +1,49 @@
+import { en as __exportAll } from "./retry-DNsVTeTo.js";
+import { o as unbindThreadBindingsBySessionKey, r as listThreadBindingsBySessionKey } from "./thread-bindings-VlymUnbz.js";
+import { normalizeOptionalLowercaseString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/discord/src/subagent-hooks.ts
+var subagent_hooks_exports = /* @__PURE__ */ __exportAll({
+	handleDiscordSubagentDeliveryTarget: () => handleDiscordSubagentDeliveryTarget,
+	handleDiscordSubagentEnded: () => handleDiscordSubagentEnded
+});
+function normalizeThreadBindingTargetKind(raw) {
+	const normalized = normalizeOptionalLowercaseString(raw);
+	if (normalized === "subagent" || normalized === "acp") return normalized;
+}
+function handleDiscordSubagentEnded(event) {
+	unbindThreadBindingsBySessionKey({
+		targetSessionKey: event.targetSessionKey,
+		accountId: event.accountId,
+		targetKind: normalizeThreadBindingTargetKind(event.targetKind),
+		reason: event.reason,
+		sendFarewell: event.sendFarewell
+	});
+}
+function handleDiscordSubagentDeliveryTarget(event) {
+	if (!event.expectsCompletionMessage) return;
+	if (normalizeOptionalLowercaseString(event.requesterOrigin?.channel) !== "discord") return;
+	const requesterAccountId = event.requesterOrigin?.accountId?.trim();
+	const requesterThreadId = event.requesterOrigin?.threadId != null && event.requesterOrigin.threadId !== "" ? normalizeOptionalStringifiedId(event.requesterOrigin.threadId) ?? "" : "";
+	const bindings = listThreadBindingsBySessionKey({
+		targetSessionKey: event.childSessionKey,
+		...requesterAccountId ? { accountId: requesterAccountId } : {},
+		targetKind: "subagent"
+	});
+	if (bindings.length === 0) return;
+	let binding;
+	if (requesterThreadId) binding = bindings.find((entry) => {
+		if (entry.threadId !== requesterThreadId) return false;
+		if (requesterAccountId && entry.accountId !== requesterAccountId) return false;
+		return true;
+	});
+	if (!binding && bindings.length === 1) binding = bindings[0];
+	if (!binding) return;
+	return { origin: {
+		channel: "discord",
+		accountId: binding.accountId,
+		to: `channel:${binding.threadId}`,
+		threadId: binding.threadId
+	} };
+}
+//#endregion
+export { handleDiscordSubagentEnded as n, subagent_hooks_exports as r, handleDiscordSubagentDeliveryTarget as t };

package/dist/subagent-hooks-api.js

@@ -1,7 +1,7 @@
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 //#region extensions/discord/subagent-hooks-api.ts
-const loadDiscordSubagentHooksModule = createLazyRuntimeModule(() => import("./subagent-hooks-CTt5KCJr.js").then((n) => n.i));
-const loadDiscordSubagentProgressModule = createLazyRuntimeModule(() => import("./subagent-progress-DhaE_h8a.js"));
+const loadDiscordSubagentHooksModule = createLazyRuntimeModule(() => import("./subagent-hooks-CNT2ZJTJ.js").then((n) => n.r));
+const loadDiscordSubagentProgressModule = createLazyRuntimeModule(() => import("./subagent-progress-FPLqBY1s.js"));
 function registerDiscordSubagentHooks(api) {
 	api.on("gateway_start", async () => {
 		const { recoverDiscordSubagentProgress } = await loadDiscordSubagentProgressModule();

package/dist/{subagent-progress-DhaE_h8a.js → subagent-progress-FPLqBY1s.js}

@@ -1,6 +1,7 @@
-import { l as resolveDiscordAccountConfig, s as resolveDiscordAccount } from "./accounts-DJTf1LtA.js";
-import { i as removeReactionDiscord } from "./send.reactions-BAn0iiVQ.js";
+import { c as resolveDiscordAccount, u as resolveDiscordAccountConfig } from "./accounts-DNl-oCEw.js";
+import { i as removeReactionDiscord } from "./send.reactions-gmJ6yFPo.js";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/routing";
+import { listAgentIds, resolveAgentConfig } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { DEFAULT_EMOJIS } from "openclaw/plugin-sdk/channel-feedback";
 //#region extensions/discord/src/subagent-progress.ts
 const PROGRESS_STORE_TTL_MS = 10080 * 6e4;
@@ -28,8 +29,8 @@ function logFailure(api, action, error) {
 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();
+	for (const agentId of listAgentIds(api.config)) {
+		const emoji = resolveAgentConfig(api.config, agentId)?.identity?.emoji?.trim();
 		if (emoji) reserved.add(emoji);
 	}
 	return reserved;

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

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

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

@@ -1,6 +1,6 @@
-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-DGIGxpIo.js";
+import { en as __exportAll, l as allowFromContainsDiscordUserId } from "./retry-DNsVTeTo.js";
+import { c as resolveDiscordAccount, k as parseDiscordTarget, l as resolveDiscordAccountAllowFrom } from "./accounts-DNl-oCEw.js";
+import { a as rememberDiscordDirectoryUser, r as listDiscordDirectoryPeersLive } from "./directory-live-Df0NbFJB.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-B2pf49zc.js

@@ -0,0 +1,3 @@
+import "./accounts-DNl-oCEw.js";
+import "./target-resolver-DIXShHaZ.js";
+export {};

package/dist/{thread-bindings-3L8p82GV.js → thread-bindings-VlymUnbz.js}

@@ -1,13 +1,14 @@
-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 { en as __exportAll } from "./retry-DNsVTeTo.js";
+import { k as parseDiscordTarget } from "./accounts-DNl-oCEw.js";
+import "./targets-B2pf49zc.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-D8OMdk4O.js";
+import { n as setThreadBindingMaxAgeBySessionKey, r as resolveBindingIdsForTargetSession, t as setThreadBindingIdleTimeoutBySessionKey } from "./thread-bindings.session-updates-CJb-BpPL.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-CngsgErq.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";
 import { readAcpSessionEntry } from "openclaw/plugin-sdk/acp-runtime";
-import pMap from "p-map";
+import { runTasksWithConcurrency } from "openclaw/plugin-sdk/concurrency-runtime";
 //#region extensions/discord/src/monitor/thread-bindings.config.ts
 function resolveDiscordThreadBindingIdleTimeoutMs(params) {
 	const accountId = normalizeAccountId(params.accountId);
@@ -160,27 +161,29 @@ async function reconcileAcpThreadBindingsOnStartup(params) {
 		});
 	}
 	if (params.healthProbe && probeTargets.length > 0) {
-		const probeResults = await pMap(probeTargets, async ({ binding, sessionKey, session }) => {
-			try {
-				return {
-					binding,
-					status: (await params.healthProbe?.({
-						cfg: params.cfg,
-						accountId: manager.accountId,
-						sessionKey,
+		const { results: probeResults } = await runTasksWithConcurrency({
+			tasks: probeTargets.map(({ binding, sessionKey, session }) => async () => {
+				try {
+					return {
 						binding,
-						session
-					}))?.status ?? "uncertain"
-				};
-			} catch {
-				return {
-					binding,
-					status: "uncertain"
-				};
-			}
-		}, {
-			concurrency: ACP_STARTUP_HEALTH_PROBE_CONCURRENCY_LIMIT,
-			stopOnError: true
+						status: (await params.healthProbe?.({
+							cfg: params.cfg,
+							accountId: manager.accountId,
+							sessionKey,
+							binding,
+							session
+						}))?.status ?? "uncertain"
+					};
+				} catch {
+					return {
+						binding,
+						status: "uncertain"
+					};
+				}
+			}),
+			limit: ACP_STARTUP_HEALTH_PROBE_CONCURRENCY_LIMIT,
+			errorMode: "stop",
+			throwOnError: true
 		});
 		for (const probeResult of probeResults) if (probeResult.status === "stale") staleBindings.push(probeResult.binding);
 	}

package/dist/{thread-bindings.manager-DCIH6WDC.js → thread-bindings.manager-CngsgErq.js}

@@ -1,13 +1,14 @@
-import { Tt as getChannel, m as resolveDiscordChannelId, pt as createChannelWebhook, tn as __exportAll } from "./retry-CLpJcXXf.js";
-import { F as createDiscordRestClient } from "./send.shared-BmwFjW6T.js";
-import { t as sendMessageDiscord } from "./send.outbound-DS5tHwfR.js";
-import { i as sendWebhookMessageDiscord, o as createThreadDiscord } from "./send-B7Q6Oc1I.js";
-import { A as toReusableWebhookKey, C as resolveThreadBindingMaxAgeExpiresAt, D as shouldDefaultPersist, E as setBindingRecord, S as resolveThreadBindingInactivityExpiresAt, T as saveBindingsToDisk, _ as rememberThreadBindingToken, b as resolveBindingRecordKey, c as ensureBindingsLoaded, f as normalizeTargetKind, g as rememberReusableWebhook, h as refreshUnboundThreadWebhookIdentity, i as REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL, l as forgetThreadBindingToken, m as normalizeThreadId, n as MANAGERS_BY_ACCOUNT_ID, p as normalizeThreadBindingDurationMs, r as PERSIST_BY_ACCOUNT_ID, s as THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS, t as BINDINGS_BY_THREAD_ID, u as getThreadBindingToken, v as removeBindingRecord, w as resolveThreadBindingMaxAgeMs$1, x as resolveThreadBindingIdleTimeoutMs$1, y as resolveBindingIdsForSession } from "./thread-bindings.state-aeV8HNgV.js";
+import { en as __exportAll, ft as createChannelWebhook, wt as getChannel } from "./retry-DNsVTeTo.js";
+import { A as resolveDiscordChannelId } from "./accounts-DNl-oCEw.js";
+import { F as createDiscordRestClient } from "./send.shared-B3fpaLWJ.js";
+import { t as sendMessageDiscord } from "./send.outbound-HIkgji_7.js";
+import { i as sendWebhookMessageDiscord, o as createThreadDiscord } from "./send-rQIffSYu.js";
+import { A as toReusableWebhookKey, C as resolveThreadBindingMaxAgeExpiresAt, D as shouldDefaultPersist, E as setBindingRecord, S as resolveThreadBindingInactivityExpiresAt, T as saveBindingsToDisk, _ as rememberThreadBindingToken, b as resolveBindingRecordKey, c as ensureBindingsLoaded, f as normalizeTargetKind, g as rememberReusableWebhook, h as refreshUnboundThreadWebhookIdentity, i as REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL, l as forgetThreadBindingToken, m as normalizeThreadId, n as MANAGERS_BY_ACCOUNT_ID, p as normalizeThreadBindingDurationMs, r as PERSIST_BY_ACCOUNT_ID, s as THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS, t as BINDINGS_BY_THREAD_ID, u as getThreadBindingToken, v as removeBindingRecord, w as resolveThreadBindingMaxAgeMs$1, x as resolveThreadBindingIdleTimeoutMs$1, y as resolveBindingIdsForSession } from "./thread-bindings.state-D8OMdk4O.js";
+import { ChannelType } from "discord-api-types/v10";
+import { parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
 import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { getRuntimeConfigSnapshot } from "openclaw/plugin-sdk/runtime-config-snapshot";
-import { ChannelType } from "discord-api-types/v10";
-import { parseStrictNonNegativeInteger as parseStrictNonNegativeInteger$1 } from "openclaw/plugin-sdk/number-runtime";
 import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { SYSTEM_MARK } from "openclaw/plugin-sdk/text-chunking";
@@ -125,7 +126,7 @@ function summarizeDiscordError(err) {
 	return "error";
 }
 function extractNumericDiscordErrorValue(value) {
-	return parseStrictNonNegativeInteger$1(value);
+	return parseStrictNonNegativeInteger(value);
 }
 function extractDiscordErrorStatus(err) {
 	if (!err || typeof err !== "object") return;

package/dist/{thread-bindings.session-updates-bJ2KQFY6.js → thread-bindings.session-updates-CJb-BpPL.js}

@@ -1,4 +1,4 @@
-import { E as setBindingRecord, O as shouldPersistBindingMutations, T as saveBindingsToDisk, c as ensureBindingsLoaded, t as BINDINGS_BY_THREAD_ID, y as resolveBindingIdsForSession } from "./thread-bindings.state-aeV8HNgV.js";
+import { E as setBindingRecord, O as shouldPersistBindingMutations, T as saveBindingsToDisk, c as ensureBindingsLoaded, t as BINDINGS_BY_THREAD_ID, y as resolveBindingIdsForSession } from "./thread-bindings.state-D8OMdk4O.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
 //#region extensions/discord/src/monitor/thread-bindings.session-shared.ts
 function normalizeNonNegativeMs(raw) {

package/dist/{thread-bindings.state-aeV8HNgV.js → thread-bindings.state-D8OMdk4O.js}

@@ -223,7 +223,7 @@ function shouldPersistBindingMutations() {
 function toPersistedBindingRecord(record) {
 	const serialized = JSON.stringify(record);
 	if (!serialized) return { ...record };
-	return JSON.parse(serialized);
+	return normalizePersistedBinding(record.threadId, JSON.parse(serialized)) ?? { ...record };
 }
 function saveBindingsToDisk(params = {}) {
 	if (!params.force && !shouldPersistAnyBindingState()) return;