@openclaw/discord 2026.9.4 → 2026.9.6

package/dist/{send.outbound-BVTWrl_4.js → .setup/send.outbound-QTyuFupn.mjs}

@@ -1,7 +1,7 @@
-import { ot as createChannelMessage, st as createThread } from "./discord-CmL3ati-.js";
-import { i as normalizeDiscordHandleKey, o as resolveDiscordDirectoryUserId } from "./directory-live-C5o1uKlw.js";
-import { c as createDiscordSendReceiptFromResults, d as createReusableDiscordReplyReference, l as createDiscordSendResult } from "./retry-DKeoT7UO.js";
-import { A as resolveDiscordSendComponents, D as buildDiscordMessageRequest, K as parseAndResolveChannelRecipient, M as resolveDiscordSuppressEmbeds, N as createDiscordClient, O as createDiscordMessageNonce, a as normalizeDiscordPollInput, c as normalizeStickerIds, f as sendDiscordMedia, j as resolveDiscordSendEmbeds, k as resolveDiscordMessageFlags, l as resolveChannelId, n as buildDiscordTextChunks, p as sendDiscordText, t as buildDiscordSendError, u as resolveDiscordChannel } from "./send.shared-BHPM3CSl.js";
+import { C as withDiscordRequestAuthority, ct as createThread, st as createChannelMessage } from "./discord-BXpHW-cu.mjs";
+import { i as normalizeDiscordHandleKey, o as resolveDiscordDirectoryUserId } from "./directory-live--EGTH0DC.mjs";
+import { c as createDiscordSendReceiptFromResults, d as createReusableDiscordReplyReference, l as createDiscordSendResult } from "./retry-BEYkDy0P.mjs";
+import { A as resolveDiscordSendComponents, D as buildDiscordMessageRequest, K as parseAndResolveChannelRecipient, M as resolveDiscordSuppressEmbeds, N as createDiscordClient, O as createDiscordMessageNonce, a as normalizeDiscordPollInput, c as normalizeStickerIds, f as sendDiscordMedia, j as resolveDiscordSendEmbeds, k as resolveDiscordMessageFlags, l as resolveChannelId, n as buildDiscordTextChunks, p as sendDiscordText, t as buildDiscordSendError, u as resolveDiscordChannel } from "./send.shared-VNvWfX2T.mjs";
 import { ChannelType } from "discord-api-types/v10";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
@@ -324,6 +324,15 @@ function normalizeDiscordBold(markdown) {
 		if (spanEdits) spanEdits.push(edit);
 		else editsBySpan.set(edit.spanId, [edit]);
 	}
+	const renderEdits = (selectedEdits, start = 0, end = markdown.length) => {
+		let cursor = start;
+		let rendered = "";
+		for (const edit of selectedEdits) {
+			rendered += `${markdown.slice(cursor, edit.start)}${edit.marker}`;
+			cursor = edit.start + edit.consume;
+		}
+		return rendered + markdown.slice(cursor, end);
+	};
 	const protectedSpanIds = /* @__PURE__ */ new Set();
 	const protectedEditKeys = /* @__PURE__ */ new Set();
 	const spansWithProtectedContent = /* @__PURE__ */ new Set();
@@ -342,30 +351,20 @@ function normalizeDiscordBold(markdown) {
 	for (const spanId of spansWithProtectedContent) {
 		const span = spans[spanId];
 		if (!span) continue;
-		let localCursor = span.start;
-		const localRendered = (editsBySpan.get(spanId) ?? []).filter((edit) => {
+		const localRendered = renderEdits((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);
+		}), span.start, 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 rendered = renderEdits(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) {
@@ -382,6 +381,7 @@ function prepareDiscordOutboundText(text, params) {
 	}));
 	return {
 		renderedText,
+		textLimit: typeof params.textLimit === "number" && Number.isFinite(params.textLimit) ? Math.max(1, Math.min(Math.floor(params.textLimit), 2e3)) : void 0,
 		textWithMentions: rewriteDiscordKnownMentions(renderedText, {
 			accountId: account.accountId,
 			mentionAliases: account.config.mentionAliases
@@ -447,6 +447,9 @@ async function resolveDiscordSendTarget(to, opts) {
 	};
 }
 async function sendMessageDiscord(to, text, opts) {
+	return await withDiscordRequestAuthority(opts.assertPlatformSendAuthorized, () => sendMessageDiscordInternal(to, text, opts));
+}
+async function sendMessageDiscordInternal(to, text, opts) {
 	const cfg = requireRuntimeConfig(opts.cfg, "Discord send");
 	const { token, rest, request, account: accountInfo } = createDiscordClient({
 		...opts,
@@ -458,12 +461,12 @@ async function sendMessageDiscord(to, text, opts) {
 		configured: accountInfo.config.suppressEmbeds,
 		override: opts.suppressEmbeds
 	});
-	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 { renderedText, textWithMentions } = prepareDiscordOutboundText(text ?? "", {
+	const { renderedText, textWithMentions, textLimit } = prepareDiscordOutboundText(text ?? "", {
 		cfg,
 		account: accountInfo,
-		tableMode: opts.tableMode
+		tableMode: opts.tableMode,
+		textLimit: opts.textLimit
 	});
 	const recipient = await parseAndResolveChannelRecipient(to, cfg, accountInfo.accountId);
 	const { channelId } = await resolveChannelId(rest, recipient, request);
@@ -683,6 +686,9 @@ async function sendMessageDiscord(to, text, opts) {
 	};
 }
 async function sendStickerDiscord(to, stickerIds, opts) {
+	return await withDiscordRequestAuthority(opts.assertPlatformSendAuthorized, () => sendStickerDiscordInternal(to, stickerIds, opts));
+}
+async function sendStickerDiscordInternal(to, stickerIds, opts) {
 	const context = await resolveDiscordStructuredSendContext(to, opts);
 	const { rewrittenContent, suppressEmbeds } = context;
 	const stickers = normalizeStickerIds(stickerIds);
@@ -700,6 +706,9 @@ async function sendStickerDiscord(to, stickerIds, opts) {
 	return context.send("sticker", body);
 }
 async function sendPollDiscord(to, poll, opts) {
+	return await withDiscordRequestAuthority(opts.assertPlatformSendAuthorized, () => sendPollDiscordInternal(to, poll, opts));
+}
+async function sendPollDiscordInternal(to, poll, opts) {
 	const context = await resolveDiscordStructuredSendContext(to, opts);
 	const { rewrittenContent, suppressEmbeds } = context;
 	if (poll.durationSeconds !== void 0) throw new Error("Discord polls do not support durationSeconds; use durationHours");

package/dist/{send.shared-BHPM3CSl.js → .setup/send.shared-VNvWfX2T.mjs}

@@ -1,15 +1,15 @@
-import { A as Embed, At as getGuildMember, O as hasDiscordV2Components, ft as getChannel, g as RequestClient, k as serializePayload, kt as getGuild, mt as getThreadMember, nt as getCurrentUser, ot as createChannelMessage, tt as createUserDmChannel } from "./discord-CmL3ati-.js";
-import { c as resolveDiscordAccount, m as normalizeDiscordToken, o as mergeDiscordAccountConfig } from "./accounts-CwJQoLjM.js";
-import { f as resolveDiscordReplyMessageId, o as chunkDiscordTextWithMode, r as createDiscordRetryRunner } from "./retry-DKeoT7UO.js";
-import { t as parseAndResolveDiscordTarget } from "./target-resolver-CoFQ7iSX.js";
-import { t as isDiscordThreadChannelType } from "./channel-type-CVLZyGYS.js";
+import { A as serializePayload, At as getGuild, g as RequestClient, ht as getThreadMember, j as Embed, jt as getGuildMember, k as hasDiscordV2Components, nt as createUserDmChannel, pt as getChannel, rt as getCurrentUser, st as createChannelMessage } from "./discord-BXpHW-cu.mjs";
+import { t as isDiscordThreadChannelType } from "./channel-type-DKnjV1XW.mjs";
+import { c as resolveDiscordAccount, m as normalizeDiscordToken, o as mergeDiscordAccountConfig } from "./accounts-CwJQoLjM.mjs";
+import { f as resolveDiscordReplyMessageId, o as chunkDiscordTextWithMode, r as createDiscordRetryRunner } from "./retry-BEYkDy0P.mjs";
+import { t as parseAndResolveDiscordTarget } from "./target-resolver-BXpy6VT8.mjs";
 import { ChannelType, MessageFlags, PermissionFlagsBits } from "discord-api-types/v10";
 import { randomBytes } from "node:crypto";
+import { makeProxyFetch } from "openclaw/plugin-sdk/fetch-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 { resolveTextChunksWithFallback } from "openclaw/plugin-sdk/reply-payload";
-import { makeProxyFetch } from "openclaw/plugin-sdk/fetch-runtime";
 import { danger } from "openclaw/plugin-sdk/runtime-env";
 import { PollLayoutType } from "discord-api-types/payloads/v10";
 import { buildOutboundMediaLoadOptions, extensionForMime, normalizePollDurationHours, normalizePollInput } from "openclaw/plugin-sdk/media-runtime";
@@ -474,7 +474,9 @@ async function fetchChannelPermissionsDiscord(channelId, opts) {
 	const channel = await getChannel(rest, channelId);
 	opts.signal?.throwIfAborted();
 	const channelType = "type" in channel ? channel.type : void 0;
-	const guildId = "guild_id" in channel ? channel.guild_id : void 0;
+	const permissionChannel = await resolveChannelPermissionSubject(rest, channel);
+	opts.signal?.throwIfAborted();
+	const guildId = "guild_id" in permissionChannel ? permissionChannel.guild_id : void 0;
 	if (!guildId) return {
 		channelId,
 		permissions: [],
@@ -491,7 +493,7 @@ async function fetchChannelPermissionsDiscord(channelId, opts) {
 		userId: botId,
 		guild,
 		member,
-		channel
+		channel: permissionChannel
 	});
 	return {
 		channelId,
@@ -528,6 +530,9 @@ const DISCORD_CANNOT_DM = 50007;
 const DISCORD_UPLOAD_TOO_LARGE = 40005;
 const DISCORD_UPLOAD_TOO_LARGE_STATUS = 413;
 const DISCORD_UPLOAD_TOO_LARGE_NOTICE = "Attachment skipped: Discord rejected the file as too large.";
+function resolveRequiredDiscordSendPermissions(channelType) {
+	return isDiscordThreadChannelType(channelType) ? ["ViewChannel", "SendMessagesInThreads"] : ["ViewChannel", "SendMessages"];
+}
 function normalizeReactionEmoji(raw) {
 	const trimmed = raw.trim();
 	if (!trimmed) throw new Error("emoji required");
@@ -597,15 +602,13 @@ async function buildDiscordSendError(err, ctx) {
 		});
 		probedChannelType = permissions.channelType;
 		const current = new Set(permissions.permissions);
-		const required = ["ViewChannel", "SendMessages"];
-		if (isDiscordThreadChannelType(probedChannelType)) required.push("SendMessagesInThreads");
+		const required = resolveRequiredDiscordSendPermissions(probedChannelType);
 		if (ctx.hasMedia) required.push("AttachFiles");
 		missing = required.filter((permission) => !current.has(permission));
 	} catch {}
 	const status = getDiscordErrorStatus(err);
 	const apiDetails = [`code=${code}`, status != null ? `status=${status}` : void 0].filter(Boolean).join(" ");
-	const probedPermissions = ["ViewChannel", "SendMessages"];
-	if (isDiscordThreadChannelType(probedChannelType)) probedPermissions.push("SendMessagesInThreads");
+	const probedPermissions = resolveRequiredDiscordSendPermissions(probedChannelType);
 	if (ctx.hasMedia) probedPermissions.push("AttachFiles");
 	const probeSummary = probedPermissions.join("/");
 	return new DiscordSendError(`${missing.length ? `discord missing permissions in channel ${ctx.channelId}: ${missing.join(", ")}` : `discord missing permissions in channel ${ctx.channelId}; permission probe did not identify missing ${probeSummary}`} (${apiDetails}). bot might be blocked by channel/thread overrides, archived thread state, reply target visibility, or app-role position`, {

package/dist/{sender-identity-f3l5OYgV.js → .setup/sender-identity-0Ymgvmaj.mjs}

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

package/dist/.setup/setup-plugin-api-Dvr41dyx.mjs

@@ -0,0 +1,3 @@
+import { t as discordSetupPlugin } from "./channel.setup-0NX6FFwi.mjs";
+import "../setup-plugin-api.js";
+export { discordSetupPlugin };

package/dist/{shared-CPPR0Xo4.js → .setup/shared-DHPDaMSx.mjs}

@@ -1,11 +1,11 @@
-import { 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-CwJQoLjM.js";
-import { t as inspectDiscordAccount } from "./account-inspect-BY-ve3yH.js";
-import { n as discordIngressIdentity, t as selectDiscordLivePolicyConfig } from "./live-policy-config-BblutQAq.js";
-import { t as DiscordChannelConfigSchema } from "./config-schema-r38UkM_J.js";
-import { n as normalizeCompatibilityConfig } from "./doctor-contract-Co5vRCZ6.js";
-import { r as secretTargetRegistryEntries, t as collectRuntimeConfigAssignments } from "./secret-config-contract-DFu9hfU8.js";
-import { n as unsupportedSecretRefSurfacePatterns, t as collectUnsupportedSecretRefConfigCandidates } from "./security-contract-DSHk7I2w.js";
-import { t as deriveLegacySessionChatType } from "./session-contract-BO5tlIdl.js";
+import { 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-CwJQoLjM.mjs";
+import { t as inspectDiscordAccount } from "./account-inspect-BwQj24ht.mjs";
+import { n as discordIngressIdentity, t as selectDiscordLivePolicyConfig } from "./live-policy-config-eKQ-PLdy.mjs";
+import { t as DiscordChannelConfigSchema } from "./config-schema-CiZz-mtA.mjs";
+import { n as normalizeCompatibilityConfig } from "./doctor-contract-Co5vRCZ6.mjs";
+import { r as secretTargetRegistryEntries, t as collectRuntimeConfigAssignments } from "./secret-config-contract-DFu9hfU8.mjs";
+import { n as unsupportedSecretRefSurfacePatterns, t as collectUnsupportedSecretRefConfigCandidates } from "./security-contract-DSHk7I2w.mjs";
+import { t as deriveLegacySessionChatType } from "./session-contract-BO5tlIdl.mjs";
 import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
 import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter, createScopedDmSecurityResolver } from "openclaw/plugin-sdk/channel-config-helpers";
@@ -72,10 +72,10 @@ const collectDiscordSecurityWarnings = createOpenProviderConfiguredRouteWarningC
 const collectDiscordSecurityFindings = createConditionalWarningCollector.findings({
 	collectWarnings: collectDiscordSecurityWarnings,
 	checkId: "channels.discord.groups.open",
-	severity: "critical",
+	severity: "warn",
 	title: "Discord security warning"
 });
-const loadDiscordSecurityAuditModule = createLazyRuntimeModule(() => import("./security-audit.runtime-sKZyKgpx.js"));
+const loadDiscordSecurityAuditModule = createLazyRuntimeModule(() => import("./security-audit.runtime-DHtYenx9.mjs"));
 const discordSecurityAdapter = {
 	resolveDmPolicy: resolveDiscordDmPolicy,
 	collectWarnings: collectDiscordSecurityFindings,
@@ -119,7 +119,7 @@ const DISCORD_LEGACY_CONFIG_RULES = [];
 //#region extensions/discord/src/shared.ts
 const DISCORD_CHANNEL = "discord";
 const livePolicyConfigPrefixes = Object.keys(selectDiscordLivePolicyConfig({})).flatMap((key) => [`channels.discord.${key}`, `channels.discord.accounts.*.${key}`]);
-const loadDiscordDoctorModule = createLazyRuntimeModule(() => import("./doctor-DgKMH6N7.js"));
+const loadDiscordDoctorModule = createLazyRuntimeModule(() => import("./doctor-D1R-uFIu.mjs"));
 const discordDoctor = {
 	dmAllowFromMode: "topOnly",
 	groupModel: "route",

package/dist/{subagent-hooks-DfsiwCec.js → .setup/subagent-hooks-CjW7r8Pe.mjs}

@@ -1,9 +1,12 @@
-import { Ht as __exportAll } from "./discord-CmL3ati-.js";
-import { o as unbindThreadBindingsBySessionKey, r as listThreadBindingsBySessionKey } from "./thread-bindings-uudC_0TY.js";
+import { Ut as __exportAll } from "./discord-BXpHW-cu.mjs";
+import { s as ensureBindingsLoadedAsync } from "./thread-bindings.state-BThFQEga.mjs";
+import { o as unbindThreadBindingsBySessionKey, r as listThreadBindingsBySessionKey } from "./thread-bindings-CEh2dhqP.mjs";
 import { normalizeOptionalLowercaseString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/discord/src/subagent-hooks.ts
 var subagent_hooks_exports = /* @__PURE__ */ __exportAll({
+	ensureBindingsLoadedAsync: () => ensureBindingsLoadedAsync,
 	handleDiscordSubagentDeliveryTarget: () => handleDiscordSubagentDeliveryTarget,
+	handleDiscordSubagentDeliveryTargetAsync: () => handleDiscordSubagentDeliveryTargetAsync,
 	handleDiscordSubagentEnded: () => handleDiscordSubagentEnded
 });
 function normalizeThreadBindingTargetKind(raw) {
@@ -19,9 +22,18 @@ function handleDiscordSubagentEnded(event) {
 		sendFarewell: event.sendFarewell
 	});
 }
+function shouldResolveDiscordDeliveryTarget(event) {
+	return Boolean(event.expectsCompletionMessage && normalizeOptionalLowercaseString(event.requesterOrigin?.channel) === "discord");
+}
 function handleDiscordSubagentDeliveryTarget(event) {
-	if (!event.expectsCompletionMessage) return;
-	if (normalizeOptionalLowercaseString(event.requesterOrigin?.channel) !== "discord") return;
+	return shouldResolveDiscordDeliveryTarget(event) ? resolveDiscordDeliveryTarget(event) : void 0;
+}
+async function handleDiscordSubagentDeliveryTargetAsync(event) {
+	if (!shouldResolveDiscordDeliveryTarget(event)) return;
+	await ensureBindingsLoadedAsync();
+	return resolveDiscordDeliveryTarget(event);
+}
+function resolveDiscordDeliveryTarget(event) {
 	const requesterAccountId = event.requesterOrigin?.accountId?.trim();
 	const requesterThreadId = event.requesterOrigin?.threadId != null && event.requesterOrigin.threadId !== "" ? normalizeOptionalStringifiedId(event.requesterOrigin.threadId) ?? "" : "";
 	const bindings = listThreadBindingsBySessionKey({

package/dist/{system-events-B6HkUhF_.js → .setup/system-events-B2YEEMbS.mjs}

@@ -1,5 +1,5 @@
-import { t as discord_exports } from "./discord-CmL3ati-.js";
-import { b as formatDiscordUserTag } from "./allow-list-DWEio925.js";
+import { t as discord_exports } from "./discord-BXpHW-cu.mjs";
+import { x as formatDiscordUserTag } from "./channel-type-DKnjV1XW.mjs";
 //#region extensions/discord/src/monitor/system-events.ts
 function resolveDiscordSystemEvent(message, location) {
 	switch (message.type) {

package/dist/{target-resolver-CoFQ7iSX.js → .setup/target-resolver-BXpy6VT8.mjs}

@@ -1,7 +1,7 @@
-import { Ht as __exportAll } from "./discord-CmL3ati-.js";
-import { c as resolveDiscordAccount, l as resolveDiscordAccountAllowFrom } from "./accounts-CwJQoLjM.js";
-import { a as rememberDiscordDirectoryUser, r as listDiscordDirectoryPeersLive } from "./directory-live-C5o1uKlw.js";
-import { m as allowFromContainsDiscordUserId, v as parseDiscordTarget } from "./retry-DKeoT7UO.js";
+import { Ut as __exportAll } from "./discord-BXpHW-cu.mjs";
+import { c as resolveDiscordAccount, l as resolveDiscordAccountAllowFrom } from "./accounts-CwJQoLjM.mjs";
+import { a as rememberDiscordDirectoryUser, r as listDiscordDirectoryPeersLive } from "./directory-live--EGTH0DC.mjs";
+import { m as allowFromContainsDiscordUserId, y as parseDiscordTarget } from "./retry-BEYkDy0P.mjs";
 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/.setup/targets-CvemhN3i.mjs

@@ -0,0 +1,3 @@
+import "./retry-BEYkDy0P.mjs";
+import "./target-resolver-BXpy6VT8.mjs";
+export {};

package/dist/{thread-bindings-uudC_0TY.js → .setup/thread-bindings-CEh2dhqP.mjs}

@@ -1,9 +1,9 @@
-import { Ht as __exportAll } from "./discord-CmL3ati-.js";
-import { v as parseDiscordTarget } from "./retry-DKeoT7UO.js";
-import "./targets-Cm6aV9nJ.js";
-import { C as saveBindingsToDisk, E as shouldPersistBindingMutations, S as resolveThreadBindingMaxAgeMs$1, b as resolveThreadBindingInactivityExpiresAt, c as getThreadBindingToken, d as normalizeThreadId, f as refreshUnboundThreadWebhookIdentity, h as removeBindingRecord, n as MANAGERS_BY_ACCOUNT_ID, t as BINDINGS_BY_THREAD_ID, x as resolveThreadBindingMaxAgeExpiresAt, y as resolveThreadBindingIdleTimeoutMs$1 } from "./thread-bindings.state-dDn-dwBw.js";
-import { n as setThreadBindingMaxAgeBySessionKey, r as resolveBindingIdsForTargetSession, t as setThreadBindingIdleTimeoutBySessionKey } from "./thread-bindings.session-updates-BwkXpcy0.js";
-import { c as resolveThreadBindingPersonaFromRecord, d as resolveThreadBindingThreadName, l as formatThreadBindingDurationLabel, n as createThreadBindingManager, o as resolveChannelIdForBinding, r as getThreadBindingManager, s as resolveThreadBindingPersona, t as createNoopThreadBindingManager, u as resolveThreadBindingIntroText } from "./thread-bindings.manager-BeUxc8nr.js";
+import { Ut as __exportAll } from "./discord-BXpHW-cu.mjs";
+import { y as parseDiscordTarget } from "./retry-BEYkDy0P.mjs";
+import "./targets-CvemhN3i.mjs";
+import { C as resolveThreadBindingMaxAgeMs$1, D as shouldPersistBindingMutations, S as resolveThreadBindingMaxAgeExpiresAt, b as resolveThreadBindingIdleTimeoutMs$1, f as normalizeThreadId, g as removeBindingRecord, l as getThreadBindingToken, n as MANAGERS_BY_ACCOUNT_ID, p as refreshUnboundThreadWebhookIdentity, t as BINDINGS_BY_THREAD_ID, w as saveBindingsToDisk, x as resolveThreadBindingInactivityExpiresAt } from "./thread-bindings.state-BThFQEga.mjs";
+import { n as setThreadBindingMaxAgeBySessionKey, r as resolveBindingIdsForTargetSession, t as setThreadBindingIdleTimeoutBySessionKey } from "./thread-bindings.session-updates-DCQq1WZ5.mjs";
+import { a as createNoopThreadBindingManager, c as resolveThreadBindingPersona, d as resolveThreadBindingIntroText, f as resolveThreadBindingThreadName, l as resolveThreadBindingPersonaFromRecord, r as getThreadBindingManager, s as resolveChannelIdForBinding, t as createThreadBindingManager, u as formatThreadBindingDurationLabel } from "./thread-bindings.manager-ve-i6oqt.mjs";
 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";

package/dist/{thread-bindings.manager-BeUxc8nr.js → .setup/thread-bindings.manager-ve-i6oqt.mjs}

@@ -1,11 +1,11 @@
-import { Ht as __exportAll, et as createChannelWebhook, ft as getChannel } from "./discord-CmL3ati-.js";
-import { t as canFallbackDiscordWebhookSend, y as resolveDiscordChannelId } from "./retry-DKeoT7UO.js";
-import { P as createDiscordRestClient } from "./send.shared-BHPM3CSl.js";
-import { t as sendMessageDiscord } from "./send.outbound-BVTWrl_4.js";
-import { t as isDiscordThreadChannelType } from "./channel-type-CVLZyGYS.js";
-import { n as resolveDiscordChannelInfoSafe, t as resolveDiscordChannelIdSafe } from "./channel-access-C12aDZ0p.js";
-import { c as sendWebhookMessageDiscord, u as createThreadDiscord } from "./send-CLpzfzJe.js";
-import { C as saveBindingsToDisk, O as toReusableWebhookKey, S as resolveThreadBindingMaxAgeMs$1, T as shouldDefaultPersist, _ as resolveBindingRecordKey, a as THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS, c as getThreadBindingToken, d as normalizeThreadId, f as refreshUnboundThreadWebhookIdentity, g as resolveBindingIdsForSession, h as removeBindingRecord, i as REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL, l as normalizeTargetKind, m as rememberThreadBindingToken, n as MANAGERS_BY_ACCOUNT_ID, o as ensureBindingsLoaded, p as rememberReusableWebhook, r as PERSIST_BY_ACCOUNT_ID, s as forgetThreadBindingToken, t as BINDINGS_BY_THREAD_ID, u as normalizeThreadBindingDurationMs, v as resolvePreparedThreadBindingLifecycle, w as setBindingRecord, y as resolveThreadBindingIdleTimeoutMs$1 } from "./thread-bindings.state-dDn-dwBw.js";
+import { C as withDiscordRequestAuthority, Ut as __exportAll, pt as getChannel, tt as createChannelWebhook } from "./discord-BXpHW-cu.mjs";
+import { t as isDiscordThreadChannelType } from "./channel-type-DKnjV1XW.mjs";
+import { b as resolveDiscordChannelId, t as canFallbackDiscordWebhookSend } from "./retry-BEYkDy0P.mjs";
+import { P as createDiscordRestClient } from "./send.shared-VNvWfX2T.mjs";
+import { t as sendMessageDiscord } from "./send.outbound-QTyuFupn.mjs";
+import { n as resolveDiscordChannelInfoSafe, t as resolveDiscordChannelIdSafe } from "./channel-access-C12aDZ0p.mjs";
+import { c as sendWebhookMessageDiscord, u as createThreadDiscord } from "./send-CIBzvXjS.mjs";
+import { C as resolveThreadBindingMaxAgeMs$1, E as shouldDefaultPersist, T as setBindingRecord, _ as resolveBindingIdsForSession, a as THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS, b as resolveThreadBindingIdleTimeoutMs$1, c as forgetThreadBindingToken, d as normalizeThreadBindingDurationMs, f as normalizeThreadId, g as removeBindingRecord, h as rememberThreadBindingToken, i as REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL, k as toReusableWebhookKey, l as getThreadBindingToken, m as rememberReusableWebhook, n as MANAGERS_BY_ACCOUNT_ID, o as ensureBindingsLoaded, p as refreshUnboundThreadWebhookIdentity, r as PERSIST_BY_ACCOUNT_ID, s as ensureBindingsLoadedAsync, t as BINDINGS_BY_THREAD_ID, u as normalizeTargetKind, v as resolveBindingRecordKey, w as saveBindingsToDisk, y as resolvePreparedThreadBindingLifecycle } from "./thread-bindings.state-BThFQEga.mjs";
 import { parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
 import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
@@ -83,17 +83,22 @@ function isDiscordThreadGoneError(err) {
 	return status === 404 || status === 403;
 }
 async function maybeSendBindingMessage(params) {
+	const assertCurrent = params.assertCurrent;
 	const text = params.text.trim();
 	if (!text) return;
 	const record = params.record;
-	if (params.preferWebhook !== false && record.webhookId && record.webhookToken) try {
-		await sendWebhookMessageDiscord(text, {
-			cfg: params.cfg,
-			webhookId: record.webhookId,
-			webhookToken: record.webhookToken,
-			accountId: record.accountId,
-			threadId: record.threadId,
-			username: resolveThreadBindingPersonaFromRecord(record)
+	const { webhookId, webhookToken } = record;
+	if (params.preferWebhook !== false && webhookId && webhookToken) try {
+		await withDiscordRequestAuthority(assertCurrent, () => {
+			assertCurrent?.();
+			return sendWebhookMessageDiscord(text, {
+				cfg: params.cfg,
+				webhookId,
+				webhookToken,
+				accountId: record.accountId,
+				threadId: record.threadId,
+				username: resolveThreadBindingPersonaFromRecord(record)
+			});
 		});
 		return;
 	} catch (err) {
@@ -105,22 +110,29 @@ async function maybeSendBindingMessage(params) {
 		if (!fallbackToBot) return;
 	}
 	try {
-		await sendMessageDiscord(buildThreadTarget(record.threadId), text, {
-			cfg: params.cfg,
-			accountId: record.accountId
+		await withDiscordRequestAuthority(assertCurrent, () => {
+			assertCurrent?.();
+			return sendMessageDiscord(buildThreadTarget(record.threadId), text, {
+				cfg: params.cfg,
+				accountId: record.accountId
+			});
 		});
 	} catch (err) {
 		logVerbose(`discord thread binding fallback send failed: ${summarizeDiscordError(err)}`);
 	}
 }
 async function createWebhookForChannel(params) {
+	const assertCreateAllowed = params.assertCreateAllowed;
 	try {
 		const rest = createDiscordRestClient({
 			cfg: params.cfg,
 			accountId: params.accountId,
 			token: params.token
 		}).rest;
-		const created = await createChannelWebhook(rest, params.channelId, { body: { name: "OpenClaw Agents" } });
+		const created = await withDiscordRequestAuthority(assertCreateAllowed, () => {
+			assertCreateAllowed?.();
+			return createChannelWebhook(rest, params.channelId, { body: { name: "OpenClaw Agents" } });
+		});
 		const webhookId = normalizeOptionalString(created?.id) ?? "";
 		const webhookToken = normalizeOptionalString(created?.token) ?? "";
 		if (!webhookId || !webhookToken) return {};
@@ -179,11 +191,13 @@ async function resolveChannelIdForBinding(params) {
 	}
 }
 async function createThreadForBinding(params) {
+	const assertCreateAllowed = params.assertCreateAllowed;
 	try {
 		const created = await createThreadDiscord(params.channelId, { name: params.threadName }, {
 			cfg: params.cfg,
 			accountId: params.accountId,
-			token: params.token
+			token: params.token,
+			...assertCreateAllowed ? { assertCreateAllowed } : {}
 		});
 		return (normalizeOptionalString(created?.id) ?? "") || null;
 	} catch (err) {
@@ -250,6 +264,7 @@ function createThreadBindingSessionAdapter(params) {
 		accountId: params.accountId,
 		capabilities: { placements: ["current", "child"] },
 		bind: async (input) => {
+			const assertCurrent = input.assertCurrent;
 			if (input.conversation.channel !== "discord") return null;
 			const targetSessionKey = input.targetSessionKey.trim();
 			if (!targetSessionKey) return null;
@@ -285,7 +300,8 @@ function createThreadBindingSessionAdapter(params) {
 				label,
 				boundBy,
 				introText,
-				metadata
+				metadata,
+				...assertCurrent ? { assertCurrent } : {}
 			});
 			return bound ? serializeBinding(bound) : null;
 		},
@@ -325,16 +341,23 @@ function createThreadBindingSessionAdapter(params) {
 		}
 	};
 }
-//#endregion
-//#region extensions/discord/src/monitor/thread-bindings.manager.ts
-var thread_bindings_manager_exports = /* @__PURE__ */ __exportAll({
-	createNoopThreadBindingManager: () => createNoopThreadBindingManager,
-	createThreadBindingManager: () => createThreadBindingManager,
-	getThreadBindingManager: () => getThreadBindingManager
-});
-function createNoopManager(accountIdRaw) {
+/** Disabled bindings have a live empty owner; retirement still makes that owner unavailable. */
+function createNoopThreadBindingManager(accountIdRaw) {
+	const accountId = normalizeAccountId(accountIdRaw);
+	const adapter = {
+		channel: "discord",
+		accountId,
+		capabilities: {
+			bindSupported: false,
+			unbindSupported: false,
+			placements: []
+		},
+		listBySession: () => [],
+		resolveByConversation: () => null
+	};
+	registerSessionBindingAdapter(adapter);
 	return {
-		accountId: normalizeAccountId(accountIdRaw),
+		accountId,
 		getIdleTimeoutMs: () => DEFAULT_THREAD_BINDING_IDLE_TIMEOUT_MS,
 		getMaxAgeMs: () => 0,
 		getByThreadId: () => void 0,
@@ -345,9 +368,20 @@ function createNoopManager(accountIdRaw) {
 		bindTarget: async () => null,
 		unbindThread: () => null,
 		unbindBySessionKey: () => [],
-		stop: () => {}
+		stop: () => unregisterSessionBindingAdapter({
+			channel: "discord",
+			accountId,
+			adapter
+		})
 	};
 }
+//#endregion
+//#region extensions/discord/src/monitor/thread-bindings.manager.ts
+var thread_bindings_manager_exports = /* @__PURE__ */ __exportAll({
+	createThreadBindingManager: () => createThreadBindingManager,
+	createThreadBindingManagerAsync: () => createThreadBindingManagerAsync,
+	getThreadBindingManager: () => getThreadBindingManager
+});
 function isDirectConversationBindingId(value) {
 	const trimmed = normalizeOptionalString(value);
 	return Boolean(trimmed && /^(user:|channel:)/i.test(trimmed));
@@ -482,13 +516,28 @@ function createThreadBindingManager(params) {
 			if (touchParams.persist ?? persist) saveBindingsToDisk({ minIntervalMs: THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS });
 			return nextRecord;
 		},
-		bindTarget: async (bindParams) => {
+		bindTarget: async (input) => {
+			const bindParams = {
+				...input,
+				metadata: input.metadata ? { ...input.metadata } : void 0
+			};
+			const assertCurrent = bindParams.assertCurrent;
+			assertCurrent?.();
 			const cfg = resolveCurrentCfg();
 			let threadId = normalizeThreadId(bindParams.threadId);
 			let channelId = normalizeOptionalString(bindParams.channelId) ?? "";
 			const directConversationBinding = isDirectConversationBindingId(threadId) || isDirectConversationBindingId(channelId);
+			let nativeBindingCreated = false;
+			const targetSessionKey = normalizeOptionalString(bindParams.targetSessionKey) ?? "";
+			if (!targetSessionKey) return null;
+			const targetKind = normalizeTargetKind(bindParams.targetKind, targetSessionKey);
+			let agentId = normalizeOptionalString(bindParams.agentId);
 			if (!threadId && bindParams.createThread) {
 				if (!channelId) return null;
+				agentId ??= resolveSessionAgentIdStrict({
+					config: cfg,
+					sessionKey: targetSessionKey
+				});
 				const threadName = resolveThreadBindingThreadName({
 					agentId: bindParams.agentId,
 					label: bindParams.label
@@ -498,8 +547,10 @@ function createThreadBindingManager(params) {
 					accountId,
 					token: resolveCurrentToken(),
 					channelId,
-					threadName: normalizeOptionalString(bindParams.threadName) ?? threadName
+					threadName: normalizeOptionalString(bindParams.threadName) ?? threadName,
+					...assertCurrent ? { assertCreateAllowed: assertCurrent } : {}
 				}) ?? void 0;
+				nativeBindingCreated = Boolean(threadId);
 			}
 			if (!threadId) return null;
 			if (!channelId && directConversationBinding) channelId = threadId;
@@ -512,10 +563,11 @@ function createThreadBindingManager(params) {
 			}) ?? "";
 			if (!channelId) return null;
 			const existingValue = manager.getByThreadId(threadId);
-			const targetSessionKey = normalizeOptionalString(bindParams.targetSessionKey) ?? "";
-			if (!targetSessionKey) return null;
-			const targetKind = normalizeTargetKind(bindParams.targetKind, targetSessionKey);
 			const previous = existingValue?.targetSessionKey === targetSessionKey && existingValue.targetKind === targetKind ? existingValue : void 0;
+			agentId ??= normalizeOptionalString(previous?.agentId) ?? resolveSessionAgentIdStrict({
+				config: cfg,
+				sessionKey: targetSessionKey
+			});
 			let webhookId = normalizeOptionalString(bindParams.webhookId) ?? normalizeOptionalString(existingValue?.webhookId) ?? "";
 			let webhookToken = normalizeOptionalString(bindParams.webhookToken) ?? normalizeOptionalString(existingValue?.webhookToken) ?? "";
 			if (!directConversationBinding && (!webhookId || !webhookToken)) {
@@ -531,10 +583,12 @@ function createThreadBindingManager(params) {
 					cfg,
 					accountId,
 					token: resolveCurrentToken(),
-					channelId
+					channelId,
+					...assertCurrent ? { assertCreateAllowed: assertCurrent } : {}
 				});
 				webhookId = createdWebhook.webhookId ?? "";
 				webhookToken = createdWebhook.webhookToken ?? "";
+				nativeBindingCreated ||= Boolean(webhookId && webhookToken);
 			}
 			const now = Date.now();
 			const record = {
@@ -543,10 +597,7 @@ function createThreadBindingManager(params) {
 				threadId,
 				targetKind,
 				targetSessionKey,
-				agentId: normalizeOptionalString(bindParams.agentId) ?? normalizeOptionalString(previous?.agentId) ?? resolveSessionAgentIdStrict({
-					config: cfg,
-					sessionKey: targetSessionKey
-				}),
+				agentId,
 				label: normalizeOptionalString(bindParams.label) ?? normalizeOptionalString(previous?.label),
 				webhookId: webhookId || void 0,
 				webhookToken: webhookToken || void 0,
@@ -560,13 +611,15 @@ function createThreadBindingManager(params) {
 					...bindParams.metadata
 				}
 			};
+			if (!nativeBindingCreated) assertCurrent?.();
 			setBindingRecord(record);
 			if (persist) saveBindingsToDisk();
 			const introText = bindParams.introText?.trim();
 			if (introText && cfg) maybeSendBindingMessage({
 				cfg,
 				record,
-				text: introText
+				text: introText,
+				...assertCurrent ? { assertCurrent } : {}
 			});
 			return record;
 		},
@@ -662,12 +715,13 @@ function createThreadBindingManager(params) {
 	MANAGERS_BY_ACCOUNT_ID.set(accountId, manager);
 	return manager;
 }
-function createNoopThreadBindingManager(accountId) {
-	return createNoopManager(accountId);
+async function createThreadBindingManagerAsync(params) {
+	await ensureBindingsLoadedAsync();
+	return createThreadBindingManager(params);
 }
 function getThreadBindingManager(accountId) {
 	const normalized = normalizeAccountId(accountId);
 	return MANAGERS_BY_ACCOUNT_ID.get(normalized) ?? null;
 }
 //#endregion
-export { isThreadArchived as a, resolveThreadBindingPersonaFromRecord as c, resolveThreadBindingThreadName as d, thread_bindings_manager_exports as i, formatThreadBindingDurationLabel as l, createThreadBindingManager as n, resolveChannelIdForBinding as o, getThreadBindingManager as r, resolveThreadBindingPersona as s, createNoopThreadBindingManager as t, resolveThreadBindingIntroText as u };
+export { createNoopThreadBindingManager as a, resolveThreadBindingPersona as c, resolveThreadBindingIntroText as d, resolveThreadBindingThreadName as f, thread_bindings_manager_exports as i, resolveThreadBindingPersonaFromRecord as l, createThreadBindingManagerAsync as n, isThreadArchived as o, getThreadBindingManager as r, resolveChannelIdForBinding as s, createThreadBindingManager as t, formatThreadBindingDurationLabel as u };

package/dist/{thread-bindings.session-updates-BwkXpcy0.js → .setup/thread-bindings.session-updates-DCQq1WZ5.mjs}

@@ -1,4 +1,4 @@
-import { C as saveBindingsToDisk, E as shouldPersistBindingMutations, g as resolveBindingIdsForSession, o as ensureBindingsLoaded, t as BINDINGS_BY_THREAD_ID, w as setBindingRecord } from "./thread-bindings.state-dDn-dwBw.js";
+import { D as shouldPersistBindingMutations, T as setBindingRecord, _ as resolveBindingIdsForSession, o as ensureBindingsLoaded, t as BINDINGS_BY_THREAD_ID, w as saveBindingsToDisk } from "./thread-bindings.state-BThFQEga.mjs";
 import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
 //#region extensions/discord/src/monitor/thread-bindings.session-shared.ts
 function normalizeNonNegativeMs(raw) {