@openclaw/discord 2026.7.2-beta.3 → 2026.7.2-beta.5

package/dist/{config-schema-BxrgfSMD.js → config-schema-D-YrV-5E.js}

@@ -1,19 +1,17 @@
-import { n as buildChannelConfigSchema, t as DiscordConfigSchema } from "./config-api-B18fR8M5.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { buildSecretInputSchema, registerSensitiveConfigSchema } from "openclaw/plugin-sdk/secret-input";
+import { ChannelBotLoopProtectionSchema, ChannelDangerouslyAllowNameMatchingSchema, ChannelPreviewStreamingConfigSchema, ChannelStreamingProgressSchema, ProviderCommandsSchema, TtsConfigSchema, buildChannelAllowBotsSchema, buildChannelConfigSchema, buildChannelExecApprovalsSchema, buildChannelReactionShape, buildCommonChannelAccountShape, buildGroupEntrySchema, requireAllowlistAllowFrom, requireOpenAllowFrom } from "openclaw/plugin-sdk/channel-config-schema";
+import { z } from "zod";
 import { createChannelConfigUiHints } from "openclaw/plugin-sdk/channel-core";
-//#endregion
-//#region extensions/discord/src/config-schema.ts
-const DiscordChannelConfigSchema = buildChannelConfigSchema(DiscordConfigSchema, { uiHints: {
+//#region extensions/discord/src/config-ui-hints.ts
+const discordChannelConfigUiHints = {
 	"": {
 		label: "Discord",
 		help: "Discord channel provider configuration for bot auth, retry policy, streaming, thread bindings, and optional voice capabilities. Keep privileged intents and advanced features disabled unless needed."
 	},
 	...createChannelConfigUiHints({
 		channelLabel: "Discord",
-		dmPolicy: {
-			channelKey: "discord",
-			includeLegacyNestedPolicy: true,
-			legacyNestedPolicyOrder: "after"
-		},
+		dmPolicy: { channelKey: "discord" },
 		configWrites: true,
 		mentionPatterns: {
 			targetDescription: "Discord channel IDs",
@@ -71,8 +69,7 @@ const DiscordChannelConfigSchema = buildChannelConfigSchema(DiscordConfigSchema,
 	},
 	...createChannelConfigUiHints({
 		channelLabel: "Discord",
-		progress: { includeCommentary: true },
-		retry: true
+		progress: { includeCommentary: true }
 	}),
 	maxLinesPerMessage: {
 		label: "Discord Max Lines Per Message",
@@ -86,18 +83,6 @@ const DiscordChannelConfigSchema = buildChannelConfigSchema(DiscordConfigSchema,
 		label: "Discord Thread Parent Inheritance",
 		help: "If true, Discord thread sessions inherit the parent channel transcript (default: false)."
 	},
-	"eventQueue.listenerTimeout": {
-		label: "Discord EventQueue Listener Timeout (ms)",
-		help: "Canonical Discord listener timeout control in ms for gateway normalization/enqueue handlers. Default is 120000 in OpenClaw; set per account via channels.discord.accounts.<id>.eventQueue.listenerTimeout."
-	},
-	"eventQueue.maxQueueSize": {
-		label: "Discord EventQueue Max Queue Size",
-		help: "Optional Discord EventQueue capacity override (max queued events before backpressure). Set per account via channels.discord.accounts.<id>.eventQueue.maxQueueSize."
-	},
-	"eventQueue.maxConcurrency": {
-		label: "Discord EventQueue Max Concurrency",
-		help: "Optional Discord EventQueue concurrency override (max concurrent handler executions). Set per account via channels.discord.accounts.<id>.eventQueue.maxConcurrency."
-	},
 	"threadBindings.enabled": {
 		label: "Discord Thread Binding Enabled",
 		help: "Enable Discord thread binding features (/focus, bound-thread routing/delivery, and thread-bound subagent sessions). Overrides session.threadBindings.enabled when set."
@@ -118,14 +103,6 @@ const DiscordChannelConfigSchema = buildChannelConfigSchema(DiscordConfigSchema,
 		label: "Discord Thread Spawn Context",
 		help: "Default native subagent context for thread-bound spawns. \"fork\" starts from the requester transcript; \"isolated\" starts clean. Default: \"fork\"."
 	},
-	subagentProgress: {
-		label: "Discord Subagent Progress",
-		help: "Show active subagent count reactions and typing on the source message. Default: false."
-	},
-	"ui.components.accentColor": {
-		label: "Discord Component Accent Color",
-		help: "Accent color for Discord component containers (hex). Set per account via channels.discord.accounts.<id>.ui.components.accentColor."
-	},
 	"agentComponents.ttlMs": {
 		label: "Discord Component TTL (ms)",
 		help: "How long sent Discord component callbacks remain registered. Default is 1800000 (30 minutes); maximum is 86400000 (24 hours)."
@@ -142,18 +119,6 @@ const DiscordChannelConfigSchema = buildChannelConfigSchema(DiscordConfigSchema,
 		label: "Discord Voice States Intent",
 		help: "Enable the Guild Voice States intent. Defaults to the effective Discord voice setting; set true only for Discord voice channel conversations."
 	},
-	gatewayInfoTimeoutMs: {
-		label: "Discord Gateway Metadata Timeout (ms)",
-		help: "Timeout for Discord /gateway/bot metadata lookup before falling back to the default gateway URL. Default is 30000; OPENCLAW_DISCORD_GATEWAY_INFO_TIMEOUT_MS can override when config is unset."
-	},
-	gatewayReadyTimeoutMs: {
-		label: "Discord Gateway READY Timeout (ms)",
-		help: "Startup wait for the Discord gateway READY event before restarting the socket. Default is 15000; OPENCLAW_DISCORD_READY_TIMEOUT_MS can override when config is unset."
-	},
-	gatewayRuntimeReadyTimeoutMs: {
-		label: "Discord Gateway Runtime READY Timeout (ms)",
-		help: "Runtime reconnect wait for the Discord gateway READY event before force-stopping the lifecycle. Default is 30000; OPENCLAW_DISCORD_RUNTIME_READY_TIMEOUT_MS can override when config is unset."
-	},
 	"voice.enabled": {
 		label: "Discord Voice Enabled",
 		help: "Enable Discord voice channel conversations. Text-only Discord configs leave voice off by default; set true to enable /vc commands and the Guild Voice States intent."
@@ -198,10 +163,6 @@ const DiscordChannelConfigSchema = buildChannelConfigSchema(DiscordConfigSchema,
 		label: "Discord Realtime Speaker Voice ID",
 		help: "Provider realtime output voice id."
 	},
-	"voice.realtime.voice": {
-		label: "Discord Realtime Voice",
-		help: "Deprecated provider realtime output voice. Use voice.realtime.speakerVoice."
-	},
 	"voice.realtime.toolPolicy": {
 		label: "Discord Realtime Tool Policy",
 		help: "Tool policy for the OpenClaw agent consult tool in realtime voice modes: safe-read-only, owner, or none. Default is owner for agent-proxy and safe-read-only for bidi."
@@ -265,7 +226,7 @@ const DiscordChannelConfigSchema = buildChannelConfigSchema(DiscordConfigSchema,
 	},
 	"voice.tts": {
 		label: "Discord Voice Text-to-Speech",
-		help: "Optional TTS overrides for Discord voice playback (merged with messages.tts)."
+		help: "Optional TTS overrides for Discord voice playback (merged with tts)."
 	},
 	"pluralkit.enabled": {
 		label: "Discord PluralKit Enabled",
@@ -295,18 +256,6 @@ const DiscordChannelConfigSchema = buildChannelConfigSchema(DiscordConfigSchema,
 		label: "Discord Auto Presence Min Update Interval (ms)",
 		help: "Minimum time between actual Discord presence update calls in milliseconds (default: 15000). Prevents status spam on noisy state changes."
 	},
-	"autoPresence.healthyText": {
-		label: "Discord Auto Presence Healthy Text",
-		help: "Optional custom status text while runtime is healthy (online). If omitted, falls back to static channels.discord.activity when set."
-	},
-	"autoPresence.degradedText": {
-		label: "Discord Auto Presence Degraded Text",
-		help: "Optional custom status text while runtime/model availability is degraded or unknown (idle)."
-	},
-	"autoPresence.exhaustedText": {
-		label: "Discord Auto Presence Exhausted Text",
-		help: "Optional custom status text while runtime detects exhausted/unavailable model quota (dnd). Supports {reason} template placeholder."
-	},
 	"guilds.*.presenceEvents": {
 		label: "Discord Online Presence Events",
 		help: "Route selected human offline-to-online transitions into the configured guild channel as agent system events. Requires the Guild Presences privileged intent and an enabled agent heartbeat."
@@ -393,6 +342,324 @@ const DiscordChannelConfigSchema = buildChannelConfigSchema(DiscordConfigSchema,
 		label: "Discord Activities Application ID",
 		help: "Optional Activity application ID. Defaults to the bot application ID learned at gateway startup."
 	}
-} });
+};
+//#endregion
+//#region extensions/discord/src/config-schema.ts
+const SecretInputSchema = buildSecretInputSchema();
+const DiscordPreviewStreamingConfigSchema = ChannelPreviewStreamingConfigSchema.extend({ progress: ChannelStreamingProgressSchema.optional() }).strict();
+const DiscordIdSchema = z.union([z.string(), z.number()]).transform((value, ctx) => {
+	if (typeof value === "number") {
+		if (!Number.isSafeInteger(value) || value < 0) {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				message: `Discord ID "${String(value)}" is not a valid non-negative safe integer. Wrap it in quotes in your config file.`
+			});
+			return z.NEVER;
+		}
+		return String(value);
+	}
+	return value;
+}).pipe(z.string());
+const DiscordIdListSchema = z.array(DiscordIdSchema);
+const DiscordSnowflakeStringSchema = z.string().regex(/^\d+$/, "Discord user ID must be numeric");
+const DiscordDmSchema = z.object({
+	enabled: z.boolean().optional(),
+	groupEnabled: z.boolean().optional(),
+	groupChannels: DiscordIdListSchema.optional()
+}).strict();
+const DiscordPresenceEventsSchema = z.object({
+	enabled: z.boolean().optional(),
+	channelId: DiscordSnowflakeStringSchema,
+	users: z.array(DiscordSnowflakeStringSchema).optional(),
+	reconnectSuppressSeconds: z.number().int().min(0).optional(),
+	burstLimit: z.number().int().positive().optional(),
+	burstWindowSeconds: z.number().int().positive().optional()
+}).strict();
+const DiscordThreadSchema = z.object({ inheritParent: z.boolean().optional() }).strict();
+const DiscordGuildChannelSchema = buildGroupEntrySchema({
+	ignoreOtherMentions: z.boolean().optional(),
+	users: DiscordIdListSchema.optional(),
+	roles: DiscordIdListSchema.optional(),
+	includeThreadStarter: z.boolean().optional(),
+	autoThread: z.boolean().optional(),
+	/** Naming strategy for auto-created threads. "message" uses message text; "generated" creates an LLM title after thread creation. */
+	autoThreadName: z.enum(["message", "generated"]).optional(),
+	/** Archive duration for auto-created threads in minutes. Discord supports 60, 1440 (1 day), 4320 (3 days), 10080 (1 week). Default: 60. */
+	autoArchiveDuration: z.union([
+		z.enum([
+			"60",
+			"1440",
+			"4320",
+			"10080"
+		]),
+		z.literal(60),
+		z.literal(1440),
+		z.literal(4320),
+		z.literal(10080)
+	]).optional()
+}, { omit: ["allowFrom"] });
+const DiscordGuildSchema = buildGroupEntrySchema({
+	slug: z.string().optional(),
+	ignoreOtherMentions: z.boolean().optional(),
+	...buildChannelReactionShape({ notificationModes: [
+		"off",
+		"own",
+		"all",
+		"allowlist"
+	] }),
+	users: DiscordIdListSchema.optional(),
+	roles: DiscordIdListSchema.optional(),
+	presenceEvents: DiscordPresenceEventsSchema.optional(),
+	channels: z.record(z.string(), DiscordGuildChannelSchema.optional()).optional()
+}, { omit: [
+	"enabled",
+	"skills",
+	"allowFrom",
+	"systemPrompt"
+] });
+const DiscordVoiceAutoJoinSchema = z.object({
+	guildId: z.string().min(1),
+	channelId: z.string().min(1)
+}).strict();
+const DiscordVoiceAllowedChannelSchema = z.object({
+	guildId: z.string().min(1),
+	channelId: z.string().min(1)
+}).strict();
+const DiscordVoiceRealtimeToolPolicySchema = z.enum([
+	"safe-read-only",
+	"owner",
+	"none"
+]);
+const DiscordVoiceRealtimeConsultPolicySchema = z.enum(["auto", "always"]);
+const DiscordVoiceRealtimeBootstrapContextFileSchema = z.enum([
+	"IDENTITY.md",
+	"USER.md",
+	"SOUL.md"
+]);
+const DiscordVoiceRealtimeWakeNameSchema = z.string().min(1).regex(/^\s*[^a-z0-9]*[a-z0-9]+(?:[^a-z0-9]+[a-z0-9]+)?[^a-z0-9]*\s*$/i, { message: "Discord realtime wake names must be one or two words." });
+const DiscordVoiceRealtimeSchema = z.object({
+	provider: z.string().min(1).optional(),
+	model: z.string().min(1).optional(),
+	speakerVoice: z.string().min(1).optional(),
+	speakerVoiceId: z.string().min(1).optional(),
+	instructions: z.string().min(1).optional(),
+	toolPolicy: DiscordVoiceRealtimeToolPolicySchema.optional(),
+	consultPolicy: DiscordVoiceRealtimeConsultPolicySchema.optional(),
+	requireWakeName: z.boolean().optional(),
+	wakeNames: z.array(DiscordVoiceRealtimeWakeNameSchema).min(1).optional(),
+	bootstrapContextFiles: z.array(DiscordVoiceRealtimeBootstrapContextFileSchema).optional(),
+	bargeIn: z.boolean().optional(),
+	minBargeInAudioEndMs: z.number().int().min(0).max(1e4).optional(),
+	debounceMs: z.number().int().positive().max(1e4).optional(),
+	providers: z.record(z.string(), z.record(z.string(), z.unknown()).optional()).optional()
+}).strict();
+const DiscordVoiceAgentSessionSchema = z.object({
+	mode: z.enum(["voice", "target"]).optional(),
+	target: z.string().min(1).optional()
+}).strict().superRefine((value, ctx) => {
+	if (value.mode === "target" && !value.target) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["target"],
+		message: "voice.agentSession.target is required when mode is \"target\""
+	});
+});
+const DiscordVoiceSchema = z.object({
+	enabled: z.boolean().optional(),
+	mode: z.enum([
+		"stt-tts",
+		"agent-proxy",
+		"bidi"
+	]).optional(),
+	agentSession: DiscordVoiceAgentSessionSchema.optional(),
+	model: z.string().min(1).optional(),
+	realtime: DiscordVoiceRealtimeSchema.optional(),
+	autoJoin: z.array(DiscordVoiceAutoJoinSchema).optional(),
+	followUsersEnabled: z.boolean().optional(),
+	followUsers: z.array(z.string().min(1)).optional(),
+	allowedChannels: z.array(DiscordVoiceAllowedChannelSchema).optional(),
+	daveEncryption: z.boolean().optional(),
+	decryptionFailureTolerance: z.number().int().min(0).optional(),
+	connectTimeoutMs: z.number().int().positive().max(12e4).optional(),
+	reconnectGraceMs: z.number().int().positive().max(12e4).optional(),
+	captureSilenceGraceMs: z.number().int().positive().max(3e4).optional(),
+	tts: TtsConfigSchema.optional()
+}).strict().optional();
+const DiscordAccountSchema = z.object({
+	...buildCommonChannelAccountShape({
+		omit: ["groupAllowFrom"],
+		groupPolicyDefault: true,
+		allowFrom: DiscordIdListSchema.optional(),
+		streaming: DiscordPreviewStreamingConfigSchema.optional()
+	}),
+	commands: ProviderCommandsSchema,
+	token: registerSensitiveConfigSchema(SecretInputSchema.optional()),
+	applicationId: DiscordIdSchema.optional(),
+	activities: z.object({
+		clientSecret: registerSensitiveConfigSchema(z.string().min(1).optional()),
+		applicationId: DiscordSnowflakeStringSchema.optional()
+	}).strict().optional(),
+	proxy: z.string().optional(),
+	allowBots: buildChannelAllowBotsSchema({ allowMentions: true }),
+	botLoopProtection: ChannelBotLoopProtectionSchema.optional(),
+	dangerouslyAllowNameMatching: ChannelDangerouslyAllowNameMatchingSchema,
+	mentionAliases: z.record(z.string(), DiscordSnowflakeStringSchema).optional(),
+	suppressEmbeds: z.boolean().optional(),
+	maxLinesPerMessage: z.number().int().positive().optional(),
+	actions: z.object({
+		reactions: z.boolean().optional(),
+		stickers: z.boolean().optional(),
+		emojiUploads: z.boolean().optional(),
+		stickerUploads: z.boolean().optional(),
+		polls: z.boolean().optional(),
+		permissions: z.boolean().optional(),
+		messages: z.boolean().optional(),
+		threads: z.boolean().optional(),
+		pins: z.boolean().optional(),
+		search: z.boolean().optional(),
+		memberInfo: z.boolean().optional(),
+		roleInfo: z.boolean().optional(),
+		roles: z.boolean().optional(),
+		channelInfo: z.boolean().optional(),
+		voiceStatus: z.boolean().optional(),
+		events: z.boolean().optional(),
+		moderation: z.boolean().optional(),
+		channels: z.boolean().optional(),
+		presence: z.boolean().optional()
+	}).strict().optional(),
+	thread: DiscordThreadSchema.optional(),
+	dm: DiscordDmSchema.optional(),
+	guilds: z.record(z.string(), DiscordGuildSchema.optional()).optional(),
+	execApprovals: buildChannelExecApprovalsSchema(DiscordIdSchema, { cleanupAfterResolve: z.boolean().optional() }),
+	agentComponents: z.object({
+		enabled: z.boolean().optional(),
+		ttlMs: z.number().int().positive().max(1440 * 60 * 1e3).optional()
+	}).strict().optional(),
+	slashCommand: z.object({ ephemeral: z.boolean().optional() }).strict().optional(),
+	threadBindings: z.object({
+		enabled: z.boolean().optional(),
+		idleHours: z.number().nonnegative().optional(),
+		maxAgeHours: z.number().nonnegative().optional(),
+		spawnSessions: z.boolean().optional(),
+		defaultSpawnContext: z.enum(["isolated", "fork"]).optional()
+	}).strict().optional(),
+	intents: z.object({
+		presence: z.boolean().optional(),
+		guildMembers: z.boolean().optional(),
+		voiceStates: z.boolean().optional()
+	}).strict().optional(),
+	voice: DiscordVoiceSchema,
+	pluralkit: z.object({
+		enabled: z.boolean().optional(),
+		token: registerSensitiveConfigSchema(SecretInputSchema.optional())
+	}).strict().optional(),
+	...buildChannelReactionShape({ ackReaction: z.string().optional() }),
+	ackReactionScope: z.enum([
+		"group-mentions",
+		"group-all",
+		"direct",
+		"all",
+		"off",
+		"none"
+	]).optional(),
+	activity: z.string().optional(),
+	status: z.enum([
+		"online",
+		"dnd",
+		"idle",
+		"invisible"
+	]).optional(),
+	autoPresence: z.object({
+		enabled: z.boolean().optional(),
+		intervalMs: z.number().int().positive().optional(),
+		minUpdateIntervalMs: z.number().int().positive().optional()
+	}).strict().optional(),
+	activityType: z.union([
+		z.literal(0),
+		z.literal(1),
+		z.literal(2),
+		z.literal(3),
+		z.literal(4),
+		z.literal(5)
+	]).optional(),
+	activityUrl: z.string().url().optional(),
+	inboundWorker: z.object({ runTimeoutMs: z.number().int().nonnegative().optional() }).strict().optional()
+}).strict().superRefine((value, ctx) => {
+	const activityText = normalizeOptionalString(value.activity) ?? "";
+	const hasActivity = Boolean(activityText);
+	const hasActivityType = value.activityType !== void 0;
+	const activityUrl = normalizeOptionalString(value.activityUrl) ?? "";
+	const hasActivityUrl = Boolean(activityUrl);
+	if ((hasActivityType || hasActivityUrl) && !hasActivity) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "channels.discord.activity is required when activityType or activityUrl is set",
+		path: ["activity"]
+	});
+	if (value.activityType === 1 && !hasActivityUrl) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "channels.discord.activityUrl is required when activityType is 1 (Streaming)",
+		path: ["activityUrl"]
+	});
+	if (hasActivityUrl && value.activityType !== 1) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "channels.discord.activityType must be 1 (Streaming) when activityUrl is set",
+		path: ["activityType"]
+	});
+	const autoPresenceInterval = value.autoPresence?.intervalMs;
+	const autoPresenceMinUpdate = value.autoPresence?.minUpdateIntervalMs;
+	if (typeof autoPresenceInterval === "number" && typeof autoPresenceMinUpdate === "number" && autoPresenceMinUpdate > autoPresenceInterval) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "channels.discord.autoPresence.minUpdateIntervalMs must be less than or equal to channels.discord.autoPresence.intervalMs",
+		path: ["autoPresence", "minUpdateIntervalMs"]
+	});
+});
+const DiscordChannelConfigSchema = buildChannelConfigSchema(DiscordAccountSchema.extend({
+	accounts: z.record(z.string(), DiscordAccountSchema.optional()).optional(),
+	defaultAccount: z.string().optional()
+}).superRefine((value, ctx) => {
+	const dmPolicy = value.dmPolicy ?? "pairing";
+	const allowFrom = value.allowFrom;
+	requireOpenAllowFrom({
+		policy: dmPolicy,
+		allowFrom,
+		ctx,
+		path: ["allowFrom"],
+		message: "channels.discord.dmPolicy=\"open\" requires channels.discord.allowFrom to include \"*\""
+	});
+	requireAllowlistAllowFrom({
+		policy: dmPolicy,
+		allowFrom,
+		ctx,
+		path: ["allowFrom"],
+		message: "channels.discord.dmPolicy=\"allowlist\" requires channels.discord.allowFrom to contain at least one sender ID"
+	});
+	if (!value.accounts) return;
+	for (const [accountId, account] of Object.entries(value.accounts)) {
+		if (!account) continue;
+		const effectivePolicy = account.dmPolicy ?? value.dmPolicy ?? "pairing";
+		const effectiveAllowFrom = account.allowFrom ?? value.allowFrom;
+		requireOpenAllowFrom({
+			policy: effectivePolicy,
+			allowFrom: effectiveAllowFrom,
+			ctx,
+			path: [
+				"accounts",
+				accountId,
+				"allowFrom"
+			],
+			message: "channels.discord.accounts.*.dmPolicy=\"open\" requires channels.discord.accounts.*.allowFrom (or channels.discord.allowFrom) to include \"*\""
+		});
+		requireAllowlistAllowFrom({
+			policy: effectivePolicy,
+			allowFrom: effectiveAllowFrom,
+			ctx,
+			path: [
+				"accounts",
+				accountId,
+				"allowFrom"
+			],
+			message: "channels.discord.accounts.*.dmPolicy=\"allowlist\" requires channels.discord.accounts.*.allowFrom (or channels.discord.allowFrom) to contain at least one sender ID"
+		});
+	}
+}), { uiHints: discordChannelConfigUiHints });
 //#endregion
 export { DiscordChannelConfigSchema as t };

package/dist/{directory-config-CmukHSms.js → directory-config-677F_rhf.js}

@@ -1,5 +1,5 @@
-import { Yt as __exportAll } from "./chunk-CWzmeWf_.js";
-import { a as mergeDiscordAccountConfig, c as resolveDiscordAccountAllowFrom, o as resolveDefaultDiscordAccountId } from "./accounts-CMd4nzLB.js";
+import { Yt as __exportAll } from "./chunk-CMVEczdm.js";
+import { a as mergeDiscordAccountConfig, c as resolveDiscordAccountAllowFrom, o as resolveDefaultDiscordAccountId } from "./accounts-DJTf1LtA.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 import { createResolvedDirectoryEntriesLister } from "openclaw/plugin-sdk/directory-config-runtime";
 //#region extensions/discord/src/directory-config.ts

package/dist/directory-contract-api.js

@@ -1,4 +1,4 @@
-import { n as listDiscordDirectoryGroupsFromConfig, r as listDiscordDirectoryPeersFromConfig } from "./directory-config-CmukHSms.js";
+import { n as listDiscordDirectoryGroupsFromConfig, r as listDiscordDirectoryPeersFromConfig } from "./directory-config-677F_rhf.js";
 //#region extensions/discord/directory-contract-api.ts
 const discordDirectoryContractPlugin = {
 	id: "discord",

package/dist/{directory-live-BYlCRO__.js → directory-live-BQk4bBOC.js}

@@ -1,5 +1,5 @@
-import { Yt as __exportAll } from "./chunk-CWzmeWf_.js";
-import { p as normalizeDiscordToken, s as resolveDiscordAccount } from "./accounts-CMd4nzLB.js";
+import { Yt as __exportAll } from "./chunk-CMVEczdm.js";
+import { p as normalizeDiscordToken, s as resolveDiscordAccount } from "./accounts-DJTf1LtA.js";
 import { r as fetchDiscord, t as DISCORD_DIRECTORY_LOOKUP_TIMEOUT_MS } from "./api-C43z8vUm.js";
 import { a as normalizeDiscordSlug } from "./allow-list-DzKrtfah.js";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/routing";
@@ -18,7 +18,7 @@ function normalizeSnowflake(value) {
 	if (!/^\d+$/.test(text)) return null;
 	return text;
 }
-function normalizeHandleKey(raw) {
+function normalizeDiscordHandleKey(raw) {
 	let handle = normalizeOptionalString(raw) ?? "";
 	if (!handle) return null;
 	if (handle.startsWith("@")) handle = normalizeOptionalString(handle.slice(1)) ?? "";
@@ -46,7 +46,7 @@ function rememberDiscordDirectoryUser(params) {
 	const cache = ensureAccountCache(params.accountId);
 	for (const candidate of params.handles) {
 		if (typeof candidate !== "string") continue;
-		const handle = normalizeHandleKey(candidate);
+		const handle = normalizeDiscordHandleKey(candidate);
 		if (!handle) continue;
 		setCacheEntry(cache, handle, userId);
 		const withoutDiscriminator = handle.replace(DISCORD_DISCRIMINATOR_SUFFIX, "");
@@ -56,7 +56,7 @@ function rememberDiscordDirectoryUser(params) {
 function resolveDiscordDirectoryUserId(params) {
 	const cache = discordDirectoryCacheState.handlesByAccount.get(normalizeAccountCacheKey(params.accountId));
 	if (!cache) return;
-	const handle = normalizeHandleKey(params.handle);
+	const handle = normalizeDiscordHandleKey(params.handle);
 	if (!handle) return;
 	const direct = cache.get(handle);
 	if (direct) return direct;
@@ -158,4 +158,4 @@ async function listDiscordDirectoryPeersLive(params) {
 	return rows;
 }
 //#endregion
-export { resolveDiscordDirectoryUserId as a, rememberDiscordDirectoryUser as i, listDiscordDirectoryGroupsLive as n, listDiscordDirectoryPeersLive as r, directory_live_exports as t };
+export { rememberDiscordDirectoryUser as a, normalizeDiscordHandleKey as i, listDiscordDirectoryGroupsLive as n, resolveDiscordDirectoryUserId as o, listDiscordDirectoryPeersLive as r, directory_live_exports as t };

package/dist/{doctor-Ci7USQAW.js → doctor-DIcs6IDL.js}

@@ -1,7 +1,7 @@
-import { o as resolveDefaultDiscordAccountId } from "./accounts-CMd4nzLB.js";
-import { t as inspectDiscordAccount } from "./account-inspect-dFV0JrnR.js";
-import { r as DISCORD_LEGACY_CONFIG_RULES } from "./shared-BEhmAdMY.js";
-import { n as normalizeCompatibilityConfig } from "./doctor-contract-wId6pV41.js";
+import { o as resolveDefaultDiscordAccountId } from "./accounts-DJTf1LtA.js";
+import { t as inspectDiscordAccount } from "./account-inspect-SXiCBCgP.js";
+import { r as DISCORD_LEGACY_CONFIG_RULES } from "./shared--6-q1Zhl.js";
+import { n as normalizeCompatibilityConfig } from "./doctor-contract-CCFMIDk9.js";
 import { t as isDiscordMutableAllowEntry } from "./security-doctor-nGgPm65L.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";