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

package/dist/{account-inspect-SXiCBCgP.js → account-inspect-D5xmUpnj.js}

@@ -1,4 +1,4 @@
-import { a as mergeDiscordAccountConfig, l as resolveDiscordAccountConfig, o as resolveDefaultDiscordAccountId } from "./accounts-DJTf1LtA.js";
+import { o as mergeDiscordAccountConfig, s as resolveDefaultDiscordAccountId, u as resolveDiscordAccountConfig } from "./accounts-DNl-oCEw.js";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { hasConfiguredSecretInput, normalizeSecretInputString } from "openclaw/plugin-sdk/secret-input";
@@ -17,67 +17,73 @@ function inspectDiscordConfiguredToken(value) {
 	};
 	return null;
 }
-//#endregion
-//#region extensions/discord/src/account-inspect.ts
-function inspectDiscordAccount(params) {
-	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
-	const merged = mergeDiscordAccountConfig(params.cfg, accountId);
-	const enabled = params.cfg.channels?.discord?.enabled !== false && merged.enabled !== false;
-	const accountConfig = resolveDiscordAccountConfig(params.cfg, accountId);
-	const hasAccountToken = Boolean(accountConfig && Object.hasOwn(accountConfig, "token"));
-	const accountToken = inspectDiscordConfiguredToken(accountConfig?.token);
+function inspectDiscordAccountTokenState(params) {
+	const accountToken = inspectDiscordConfiguredToken(params.accountToken);
 	if (accountToken) return {
-		accountId,
-		enabled,
-		name: normalizeOptionalString(merged.name),
-		token: accountToken.token,
-		tokenSource: accountToken.tokenSource,
-		tokenStatus: accountToken.tokenStatus,
+		...params.base,
+		...accountToken,
 		configured: true,
-		config: merged
+		config: params.config
 	};
-	if (hasAccountToken) return {
-		accountId,
-		enabled,
-		name: normalizeOptionalString(merged.name),
+	if (params.hasAccountToken) return {
+		...params.base,
 		token: "",
 		tokenSource: "none",
 		tokenStatus: "missing",
 		configured: false,
-		config: merged
+		config: params.config
 	};
-	const channelToken = inspectDiscordConfiguredToken(params.cfg.channels?.discord?.token);
+	const channelToken = inspectDiscordConfiguredToken(params.channelToken);
 	if (channelToken) return {
-		accountId,
-		enabled,
-		name: normalizeOptionalString(merged.name),
-		token: channelToken.token,
-		tokenSource: channelToken.tokenSource,
-		tokenStatus: channelToken.tokenStatus,
+		...params.base,
+		...channelToken,
 		configured: true,
-		config: merged
+		config: params.config
 	};
-	const envToken = accountId === DEFAULT_ACCOUNT_ID ? normalizeSecretInputString(params.envToken ?? process.env.DISCORD_BOT_TOKEN) : void 0;
-	if (envToken) return {
-		accountId,
-		enabled,
-		name: normalizeOptionalString(merged.name),
-		token: envToken.replace(/^Bot\s+/i, ""),
-		tokenSource: "env",
+	const fallback = params.resolveFallbackToken();
+	if (fallback.token) return {
+		...params.base,
+		token: fallback.token,
+		tokenSource: fallback.source,
 		tokenStatus: "available",
 		configured: true,
-		config: merged
+		config: params.config
 	};
 	return {
-		accountId,
-		enabled,
-		name: normalizeOptionalString(merged.name),
+		...params.base,
 		token: "",
 		tokenSource: "none",
 		tokenStatus: "missing",
 		configured: false,
-		config: merged
+		config: params.config
 	};
 }
 //#endregion
-export { inspectDiscordConfiguredToken as n, inspectDiscordAccount as t };
+//#region extensions/discord/src/account-inspect.ts
+function inspectDiscordAccount(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
+	const merged = mergeDiscordAccountConfig(params.cfg, accountId);
+	const enabled = params.cfg.channels?.discord?.enabled !== false && merged.enabled !== false;
+	const accountConfig = resolveDiscordAccountConfig(params.cfg, accountId);
+	const hasAccountToken = Boolean(accountConfig && Object.hasOwn(accountConfig, "token"));
+	return inspectDiscordAccountTokenState({
+		base: {
+			accountId,
+			enabled,
+			name: normalizeOptionalString(merged.name)
+		},
+		config: merged,
+		accountToken: accountConfig?.token,
+		hasAccountToken,
+		channelToken: params.cfg.channels?.discord?.token,
+		resolveFallbackToken: () => {
+			const envToken = accountId === DEFAULT_ACCOUNT_ID ? normalizeSecretInputString(params.envToken ?? process.env.DISCORD_BOT_TOKEN) : void 0;
+			return {
+				token: envToken?.replace(/^Bot\s+/i, "") ?? "",
+				source: envToken ? "env" : "none"
+			};
+		}
+	});
+}
+//#endregion
+export { inspectDiscordAccountTokenState as n, inspectDiscordAccount as t };

package/dist/account-inspect-api.js

@@ -1,4 +1,4 @@
-import { t as inspectDiscordAccount } from "./account-inspect-SXiCBCgP.js";
+import { t as inspectDiscordAccount } from "./account-inspect-D5xmUpnj.js";
 //#region extensions/discord/account-inspect-api.ts
 function inspectDiscordReadOnlyAccount(cfg, accountId) {
 	return inspectDiscordAccount({

package/dist/accounts-DNl-oCEw.js

@@ -0,0 +1,371 @@
+import "./config-schema-DC5kDtQ5.js";
+import { createAccountActionGate, createAccountListHelpers } from "openclaw/plugin-sdk/account-helpers";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$2, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { mapAllowFromEntries, normalizeChannelDmPolicy } from "openclaw/plugin-sdk/channel-config-helpers";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, buildOutboundBaseSessionKey, normalizeAccountId as normalizeAccountId$1, resolveAccountEntry } from "openclaw/plugin-sdk/routing";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { PAIRING_APPROVED_MESSAGE as PAIRING_APPROVED_MESSAGE$1, buildTokenChannelStatusSummary as buildTokenChannelStatusSummary$1, projectCredentialSnapshotFields as projectCredentialSnapshotFields$1, resolveConfiguredFromCredentialStatuses, resolveConfiguredFromCredentialStatuses as resolveConfiguredFromCredentialStatuses$1 } from "openclaw/plugin-sdk/channel-status";
+import "openclaw/plugin-sdk/channel-config-schema";
+import { normalizeResolvedSecretInputString, resolveSecretInputString } from "openclaw/plugin-sdk/secret-input";
+import { buildThreadAwareOutboundSessionRoute } from "openclaw/plugin-sdk/channel-core";
+import { assertMediaNotDataUrl, jsonResult, parseAvailableTags, readNonNegativeIntegerParam, readPositiveIntegerParam, readReactionParams, readStringArrayParam, readStringParam, withNormalizedTimestamp } from "openclaw/plugin-sdk/channel-actions";
+import { readBooleanParam as readBooleanParam$1 } from "openclaw/plugin-sdk/boolean-param";
+import "openclaw/plugin-sdk/channel-plugin-common";
+import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/outbound-media";
+import { buildMessagingTarget, parseMentionPrefixOrAtUserTarget, requireTargetKind } from "openclaw/plugin-sdk/channel-targets";
+import { getRuntimeConfigSnapshot, getRuntimeConfigSourceSnapshot, selectApplicableRuntimeConfig } from "openclaw/plugin-sdk/runtime-config-snapshot";
+//#region extensions/discord/src/channel-api.ts
+const DISCORD_CHANNEL_META = {
+	id: "discord",
+	label: "Discord",
+	selectionLabel: "Discord (Bot API)",
+	detailLabel: "Discord Bot",
+	docsPath: "/channels/discord",
+	docsLabel: "discord",
+	blurb: "very well supported right now.",
+	systemImage: "bubble.left.and.bubble.right",
+	markdownCapable: true,
+	preferSessionLookupForAnnounceTarget: true
+};
+function getChatChannelMeta(id) {
+	if (id !== DISCORD_CHANNEL_META.id) throw new Error(`Unsupported Discord channel meta lookup: ${id}`);
+	return DISCORD_CHANNEL_META;
+}
+//#endregion
+//#region extensions/discord/src/target-parsing.ts
+function parseDiscordTarget(raw, options = {}) {
+	const trimmed = raw.trim();
+	if (!trimmed) return;
+	const providerPrefixedTarget = parseDiscordProviderPrefixedTarget(trimmed);
+	if (providerPrefixedTarget) return providerPrefixedTarget;
+	const userTarget = parseMentionPrefixOrAtUserTarget({
+		raw: trimmed,
+		mentionPattern: /^<@!?(\d+)>$/,
+		prefixes: [
+			{
+				prefix: "user:",
+				kind: "user"
+			},
+			{
+				prefix: "channel:",
+				kind: "channel"
+			},
+			{
+				prefix: "discord:",
+				kind: "user"
+			}
+		],
+		atUserPattern: /^\d+$/,
+		atUserErrorMessage: "Discord DMs require a user id (use user:<id> or a <@id> mention)"
+	});
+	if (userTarget) return userTarget;
+	if (/^\d+$/.test(trimmed)) {
+		if (options.defaultKind) return buildMessagingTarget(options.defaultKind, trimmed, trimmed);
+		throw new Error(options.ambiguousMessage ?? `Ambiguous Discord recipient "${trimmed}". For DMs use "user:${trimmed}" or "<@${trimmed}>"; for channels use "channel:${trimmed}".`);
+	}
+	return buildMessagingTarget("channel", trimmed, trimmed);
+}
+function parseDiscordProviderPrefixedTarget(raw) {
+	const match = /^discord:(channel|user):(.+)$/i.exec(raw);
+	if (!match) return;
+	const kind = match[1]?.toLowerCase();
+	const id = match[2]?.trim();
+	if (!kind || !id) return;
+	return buildMessagingTarget(kind, id, `${kind}:${id}`);
+}
+function resolveDiscordChannelId(raw) {
+	return requireTargetKind({
+		platform: "Discord",
+		target: parseDiscordTarget(raw, { defaultKind: "channel" }),
+		kind: "channel"
+	});
+}
+//#endregion
+//#region extensions/discord/src/outbound-session-route.ts
+function resolveDiscordOutboundSessionRoute(params) {
+	const parsed = parseDiscordTarget(params.target, { defaultKind: resolveDiscordOutboundTargetKindHint(params) });
+	if (!parsed) return null;
+	const explicitThreadId = params.threadId == null ? void 0 : String(params.threadId).trim();
+	const peerId = explicitThreadId || parsed.id;
+	const isDm = parsed.kind === "user" && !explicitThreadId;
+	const recipientSessionExact = /^\d+$/.test(peerId);
+	const peer = {
+		kind: isDm ? "direct" : "channel",
+		id: peerId
+	};
+	const baseSessionKey = buildOutboundBaseSessionKey({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		channel: "discord",
+		accountId: params.accountId,
+		peer
+	});
+	return buildThreadAwareOutboundSessionRoute({
+		route: {
+			sessionKey: baseSessionKey,
+			baseSessionKey,
+			recipientSessionExact,
+			peer,
+			chatType: isDm ? "direct" : "channel",
+			from: isDm ? `discord:${peerId}` : `discord:channel:${peerId}`,
+			to: isDm ? `user:${peerId}` : `channel:${peerId}`
+		},
+		threadId: params.threadId,
+		precedence: ["threadId"],
+		useSuffix: false
+	});
+}
+function resolveDiscordOutboundTargetKindHint(params) {
+	const resolvedKind = params.resolvedTarget?.kind;
+	if (resolvedKind === "user") return "user";
+	if (resolvedKind === "group" || resolvedKind === "channel") return "channel";
+	const target = params.target.trim();
+	if (/^channel:/i.test(target)) return "channel";
+	if (/^(user:|discord:|@|<@!?)/i.test(target)) return "user";
+	return "channel";
+}
+//#endregion
+//#region extensions/discord/src/runtime-config.ts
+function selectDiscordRuntimeConfig(inputConfig) {
+	return selectApplicableRuntimeConfig({
+		inputConfig,
+		runtimeConfig: getRuntimeConfigSnapshot(),
+		runtimeSourceConfig: getRuntimeConfigSourceSnapshot()
+	}) ?? inputConfig;
+}
+function withSourceActivities(runtimeAccount, sourceAccount) {
+	const { activities: _runtimeActivities, ...runtimeRest } = runtimeAccount ?? {};
+	return {
+		...runtimeRest,
+		...sourceAccount?.activities ? { activities: sourceAccount.activities } : {}
+	};
+}
+/** Restores plugin-owned sensitive Activity config onto the resolved runtime shape. */
+function selectDiscordActivitiesRuntimeConfig(inputConfig) {
+	const runtimeConfig = selectDiscordRuntimeConfig(inputConfig);
+	const sourceDiscord = getRuntimeConfigSourceSnapshot()?.channels?.discord;
+	if (!sourceDiscord) return runtimeConfig;
+	const runtimeDiscord = runtimeConfig.channels?.discord;
+	const accountIds = /* @__PURE__ */ new Set([...Object.keys(runtimeDiscord?.accounts ?? {}), ...Object.keys(sourceDiscord.accounts ?? {})]);
+	const accounts = Object.fromEntries([...accountIds].map((accountId) => [accountId, withSourceActivities(runtimeDiscord?.accounts?.[accountId], sourceDiscord.accounts?.[accountId])]));
+	return {
+		...runtimeConfig,
+		channels: {
+			...runtimeConfig.channels,
+			discord: {
+				...withSourceActivities(runtimeDiscord, sourceDiscord),
+				...accountIds.size > 0 ? { accounts } : {}
+			}
+		}
+	};
+}
+//#endregion
+//#region extensions/discord/src/token.ts
+function stripDiscordBotPrefix(token) {
+	return token.replace(/^Bot\s+/i, "");
+}
+function normalizeDiscordToken(raw, path) {
+	const trimmed = normalizeResolvedSecretInputString({
+		value: raw,
+		path
+	});
+	if (!trimmed) return;
+	return stripDiscordBotPrefix(trimmed);
+}
+function resolveDiscordTokenValue(params) {
+	const resolved = resolveSecretInputString({
+		value: params.value,
+		path: params.path,
+		defaults: params.cfg.secrets?.defaults,
+		mode: "inspect"
+	});
+	if (resolved.status === "available") return {
+		status: "available",
+		value: stripDiscordBotPrefix(resolved.value)
+	};
+	if (resolved.status === "configured_unavailable") return { status: "configured_unavailable" };
+	return { status: "missing" };
+}
+function resolveDiscordToken(cfg, opts = {}) {
+	const selectedCfg = selectDiscordRuntimeConfig(cfg);
+	const accountId = normalizeAccountId$1(opts.accountId);
+	const discordCfg = selectedCfg?.channels?.discord;
+	const accountCfg = resolveAccountEntry(discordCfg?.accounts, accountId);
+	const hasAccountToken = Boolean(accountCfg && Object.hasOwn(accountCfg, "token"));
+	const accountToken = resolveDiscordTokenValue({
+		cfg: selectedCfg,
+		value: accountCfg?.token,
+		path: `channels.discord.accounts.${accountId}.token`
+	});
+	if (accountToken.status === "available" && accountToken.value) return {
+		token: accountToken.value,
+		source: "config",
+		tokenStatus: "available"
+	};
+	if (accountToken.status === "configured_unavailable") return {
+		token: "",
+		source: "config",
+		tokenStatus: "configured_unavailable"
+	};
+	if (hasAccountToken) return {
+		token: "",
+		source: "none",
+		tokenStatus: "missing"
+	};
+	const configToken = resolveDiscordTokenValue({
+		cfg: selectedCfg,
+		value: discordCfg?.token,
+		path: "channels.discord.token"
+	});
+	if (configToken.status === "available" && configToken.value) return {
+		token: configToken.value,
+		source: "config",
+		tokenStatus: "available"
+	};
+	if (configToken.status === "configured_unavailable") return {
+		token: "",
+		source: "config",
+		tokenStatus: "configured_unavailable"
+	};
+	const envToken = accountId === DEFAULT_ACCOUNT_ID$1 ? normalizeDiscordToken(opts.envToken ?? process.env.DISCORD_BOT_TOKEN, "DISCORD_BOT_TOKEN") : void 0;
+	if (envToken) return {
+		token: envToken,
+		source: "env",
+		tokenStatus: "available"
+	};
+	return {
+		token: "",
+		source: "none",
+		tokenStatus: "missing"
+	};
+}
+//#endregion
+//#region extensions/discord/src/accounts.ts
+const { listAccountIds, resolveDefaultAccountId, resolveAccountConfig: resolveMergedDiscordAccountConfig } = createAccountListHelpers("discord", {
+	implicitDefaultAccount: {
+		channelKeys: ["token"],
+		envVars: ["DISCORD_BOT_TOKEN"]
+	},
+	nestedObjectKeys: [
+		"activities",
+		"agentComponents",
+		"botLoopProtection"
+	]
+});
+const listDiscordAccountIds = listAccountIds;
+const resolveDefaultDiscordAccountId = resolveDefaultAccountId;
+function resolveDiscordAccountConfig(cfg, accountId) {
+	return resolveAccountEntry(cfg.channels?.discord?.accounts, accountId);
+}
+function mergeDiscordAccountConfig(cfg, accountId) {
+	return resolveMergedDiscordAccountConfig(cfg, accountId);
+}
+function resolveDiscordAccountAllowFrom(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
+	const accountConfig = resolveDiscordAccountConfig(params.cfg, accountId);
+	const rootConfig = params.cfg.channels?.discord;
+	const allowFrom = accountConfig?.allowFrom ?? rootConfig?.allowFrom;
+	return allowFrom ? mapAllowFromEntries(allowFrom) : void 0;
+}
+function resolveDiscordAccountDmPolicy(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
+	const accountConfig = resolveDiscordAccountConfig(params.cfg, accountId);
+	const rootConfig = params.cfg.channels?.discord;
+	return normalizeChannelDmPolicy(accountConfig?.dmPolicy ?? rootConfig?.dmPolicy ?? "pairing");
+}
+function createDiscordActionGate(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
+	return createAccountActionGate({
+		baseActions: params.cfg.channels?.discord?.actions,
+		accountActions: resolveDiscordAccountConfig(params.cfg, accountId)?.actions
+	});
+}
+function resolveDiscordAccount(params) {
+	const cfg = selectDiscordRuntimeConfig(params.cfg);
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(cfg));
+	const baseEnabled = cfg.channels?.discord?.enabled !== false;
+	const merged = mergeDiscordAccountConfig(cfg, accountId);
+	const accountEnabled = merged.enabled !== false;
+	const enabled = baseEnabled && accountEnabled;
+	const tokenResolution = resolveDiscordToken(cfg, { accountId });
+	return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: tokenResolution.token,
+		tokenSource: tokenResolution.source,
+		tokenStatus: tokenResolution.tokenStatus,
+		config: merged
+	};
+}
+function resolveDiscordMaxLinesPerMessage(params) {
+	if (typeof params.discordConfig?.maxLinesPerMessage === "number") return params.discordConfig.maxLinesPerMessage;
+	return resolveDiscordAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}).config.maxLinesPerMessage;
+}
+function resolveDiscordAccountTokenOwner(params) {
+	const token = params.token.trim();
+	if (!token) return;
+	let owner;
+	const accountIds = listDiscordAccountIds(params.cfg);
+	for (const [index, accountId] of accountIds.entries()) {
+		const account = resolveDiscordAccount({
+			cfg: params.cfg,
+			accountId
+		});
+		const accountToken = account.token.trim();
+		if (!account.enabled || accountToken !== token) continue;
+		const priority = account.tokenSource === "config" ? 2 : account.tokenSource === "env" ? 1 : 0;
+		if (!owner || priority > owner.priority) {
+			owner = {
+				accountId: account.accountId,
+				priority,
+				index
+			};
+			continue;
+		}
+		if (priority === owner.priority && index < owner.index) owner = {
+			accountId: account.accountId,
+			priority,
+			index
+		};
+	}
+	return owner?.accountId;
+}
+function resolveDiscordDuplicateTokenOwner(params) {
+	const owner = resolveDiscordAccountTokenOwner({
+		cfg: params.cfg,
+		token: params.account.token
+	});
+	return owner && owner !== params.account.accountId ? owner : void 0;
+}
+function isDiscordAccountEnabledForRuntime(account, cfg) {
+	return account.enabled && !resolveDiscordDuplicateTokenOwner({
+		cfg,
+		account
+	});
+}
+function resolveDiscordAccountDisabledReason(account, cfg) {
+	if (!account.enabled) return "disabled";
+	const owner = resolveDiscordDuplicateTokenOwner({
+		cfg,
+		account
+	});
+	return owner ? `duplicate bot token; using account "${owner}"` : "disabled";
+}
+function listEnabledDiscordAccounts(cfg) {
+	return listDiscordAccountIds(cfg).map((accountId) => resolveDiscordAccount({
+		cfg,
+		accountId
+	})).filter((account) => isDiscordAccountEnabledForRuntime(account, cfg));
+}
+function listDiscordStartupAccountIds(cfg) {
+	const startupAccountIds = listEnabledDiscordAccounts(cfg).filter((candidate) => resolveConfiguredFromCredentialStatuses(candidate) ?? Boolean(normalizeOptionalString(candidate.token))).map((candidate) => candidate.accountId);
+	const defaultAccountId = resolveDefaultDiscordAccountId(cfg);
+	if (!startupAccountIds.includes(defaultAccountId)) return startupAccountIds;
+	return [defaultAccountId, ...startupAccountIds.filter((candidateId) => candidateId !== defaultAccountId)];
+}
+//#endregion
+export { resolveDiscordChannelId as A, readPositiveIntegerParam as C, withNormalizedTimestamp as D, readStringParam as E, projectCredentialSnapshotFields$1 as F, resolveConfiguredFromCredentialStatuses$1 as I, PAIRING_APPROVED_MESSAGE$1 as M, buildTokenChannelStatusSummary$1 as N, resolveDiscordOutboundSessionRoute as O, getChatChannelMeta as P, readNonNegativeIntegerParam as S, readStringArrayParam as T, assertMediaNotDataUrl as _, listEnabledDiscordAccounts as a, parseAvailableTags as b, resolveDiscordAccount as c, resolveDiscordAccountDisabledReason as d, resolveDiscordAccountDmPolicy as f, selectDiscordActivitiesRuntimeConfig as g, resolveDiscordToken as h, listDiscordStartupAccountIds as i, DEFAULT_ACCOUNT_ID$2 as j, parseDiscordTarget as k, resolveDiscordAccountAllowFrom as l, normalizeDiscordToken as m, isDiscordAccountEnabledForRuntime as n, mergeDiscordAccountConfig as o, resolveDiscordMaxLinesPerMessage as p, listDiscordAccountIds as r, resolveDefaultDiscordAccountId as s, createDiscordActionGate as t, resolveDiscordAccountConfig as u, jsonResult as v, readReactionParams as w, readBooleanParam$1 as x, loadOutboundMediaFromUrl as y };

package/dist/action-runtime-api.js

@@ -1,2 +1,2 @@
-import { t as handleDiscordAction } from "./runtime-_aRC6V2s.js";
+import { t as handleDiscordAction } from "./runtime-D71_VFLr.js";
 export { handleDiscordAction };

package/dist/{active-turn-thread-route-MlKWp8RD.js → active-turn-thread-route-fmHl1HNd.js}

@@ -1,10 +1,8 @@
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/discord/src/active-turn-thread-route.ts
 const activeRoutes = /* @__PURE__ */ new Map();
-function normalizeId(value) {
-	return value?.trim() || void 0;
-}
 function beginDiscordActiveTurnThreadRoute(sessionKey, route) {
-	const key = normalizeId(sessionKey);
+	const key = normalizeOptionalString(sessionKey);
 	if (!key) return () => {};
 	const routes = activeRoutes.get(key) ?? /* @__PURE__ */ new Set();
 	routes.add(route);
@@ -15,10 +13,10 @@ function beginDiscordActiveTurnThreadRoute(sessionKey, route) {
 	};
 }
 async function notifyDiscordActiveTurnThreadCreated(params) {
-	const key = normalizeId(params.sessionKey ?? void 0);
-	const threadId = normalizeId(params.threadId);
-	const sourceChannelId = normalizeId(params.sourceChannelId);
-	const sourceMessageId = normalizeId(params.sourceMessageId);
+	const key = normalizeOptionalString(params.sessionKey ?? void 0);
+	const threadId = normalizeOptionalString(params.threadId);
+	const sourceChannelId = normalizeOptionalString(params.sourceChannelId);
+	const sourceMessageId = normalizeOptionalString(params.sourceMessageId);
 	const route = key ? Array.from(activeRoutes.get(key) ?? []).find((candidate) => sourceChannelId === candidate.sourceChannelId && sourceMessageId === candidate.sourceMessageId && (!candidate.accountId || !params.accountId || candidate.accountId === params.accountId)) : void 0;
 	if (!route || !threadId) return false;
 	route.adoptedThreadId = threadId;
@@ -31,14 +29,14 @@ async function notifyDiscordActiveTurnThreadCreated(params) {
 }
 function notifyDiscordActiveTurnThreadReplyDelivered(params) {
 	const route = findDiscordActiveTurnThreadReplyRoute(params);
-	const threadId = normalizeId(params.threadId ?? void 0);
+	const threadId = normalizeOptionalString(params.threadId ?? void 0);
 	if (!route || !threadId) return false;
 	route.onThreadReplyDelivered?.(threadId);
 	return true;
 }
 function findDiscordActiveTurnThreadReplyRoute(params) {
-	const key = normalizeId(params.sessionKey ?? void 0);
-	const threadId = normalizeId(params.threadId);
+	const key = normalizeOptionalString(params.sessionKey ?? void 0);
+	const threadId = normalizeOptionalString(params.threadId);
 	if (!key || !threadId) return;
 	return Array.from(activeRoutes.get(key) ?? []).find((route) => Boolean(route.adoptedThreadId) && route.adoptedThreadId === threadId && (!route.accountId || !params.accountId || route.accountId === params.accountId));
 }