@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

package/dist/config-api-CFZtoMaS.js

@@ -0,0 +1,2 @@
+import { DiscordConfigSchema, buildChannelConfigSchema } from "openclaw/plugin-sdk/bundled-channel-config-schema";
+export { buildChannelConfigSchema as n, DiscordConfigSchema as t };

package/dist/config-schema-DwFkL904.js

@@ -0,0 +1,252 @@
+import { n as buildChannelConfigSchema, t as DiscordConfigSchema } from "./config-api-CFZtoMaS.js";
+//#endregion
+//#region extensions/discord/src/config-schema.ts
+const DiscordChannelConfigSchema = buildChannelConfigSchema(DiscordConfigSchema, { uiHints: {
+	"": {
+		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."
+	},
+	dmPolicy: {
+		label: "Discord DM Policy",
+		help: "Direct message access control (\"pairing\" recommended). \"open\" requires channels.discord.allowFrom=[\"*\"]."
+	},
+	"dm.policy": {
+		label: "Discord DM Policy",
+		help: "Direct message access control (\"pairing\" recommended). \"open\" requires channels.discord.allowFrom=[\"*\"] (legacy: channels.discord.dm.allowFrom)."
+	},
+	configWrites: {
+		label: "Discord Config Writes",
+		help: "Allow Discord to write config in response to channel events/commands (default: true)."
+	},
+	proxy: {
+		label: "Discord Proxy URL",
+		help: "Proxy URL for Discord gateway + API requests (app-id lookup and allowlist resolution). Set per account via channels.discord.accounts.<id>.proxy."
+	},
+	"commands.native": {
+		label: "Discord Native Commands",
+		help: "Override native commands for Discord (bool or \"auto\")."
+	},
+	"commands.nativeSkills": {
+		label: "Discord Native Skill Commands",
+		help: "Override native skill commands for Discord (bool or \"auto\")."
+	},
+	streaming: {
+		label: "Discord Streaming Mode",
+		help: "Unified Discord stream preview mode: \"off\" | \"partial\" | \"block\" | \"progress\". \"progress\" maps to \"partial\" on Discord. Legacy boolean/streamMode keys are auto-mapped."
+	},
+	"streaming.mode": {
+		label: "Discord Streaming Mode",
+		help: "Canonical Discord preview mode: \"off\" | \"partial\" | \"block\" | \"progress\". \"progress\" maps to \"partial\" on Discord."
+	},
+	"streaming.chunkMode": {
+		label: "Discord Chunk Mode",
+		help: "Chunking mode for outbound Discord text delivery: \"length\" (default) or \"newline\"."
+	},
+	"streaming.block.enabled": {
+		label: "Discord Block Streaming Enabled",
+		help: "Enable chunked block-style Discord preview delivery when channels.discord.streaming.mode=\"block\"."
+	},
+	"streaming.block.coalesce": {
+		label: "Discord Block Streaming Coalesce",
+		help: "Merge streamed Discord block replies before final delivery."
+	},
+	"streaming.preview.chunk.minChars": {
+		label: "Discord Draft Chunk Min Chars",
+		help: "Minimum chars before emitting a Discord stream preview update when channels.discord.streaming.mode=\"block\" (default: 200)."
+	},
+	"streaming.preview.chunk.maxChars": {
+		label: "Discord Draft Chunk Max Chars",
+		help: "Target max size for a Discord stream preview chunk when channels.discord.streaming.mode=\"block\" (default: 800; clamped to channels.discord.textChunkLimit)."
+	},
+	"streaming.preview.chunk.breakPreference": {
+		label: "Discord Draft Chunk Break Preference",
+		help: "Preferred breakpoints for Discord draft chunks (paragraph | newline | sentence). Default: paragraph."
+	},
+	"streaming.preview.toolProgress": {
+		label: "Discord Draft Tool Progress",
+		help: "Show tool/progress activity in the live draft preview message (default: true). Set false to keep tool updates as separate messages."
+	},
+	"retry.attempts": {
+		label: "Discord Retry Attempts",
+		help: "Max retry attempts for outbound Discord API calls (default: 3)."
+	},
+	"retry.minDelayMs": {
+		label: "Discord Retry Min Delay (ms)",
+		help: "Minimum retry delay in ms for Discord outbound calls."
+	},
+	"retry.maxDelayMs": {
+		label: "Discord Retry Max Delay (ms)",
+		help: "Maximum retry delay cap in ms for Discord outbound calls."
+	},
+	"retry.jitter": {
+		label: "Discord Retry Jitter",
+		help: "Jitter factor (0-1) applied to Discord retry delays."
+	},
+	maxLinesPerMessage: {
+		label: "Discord Max Lines Per Message",
+		help: "Soft max line count per Discord message (default: 17)."
+	},
+	"thread.inheritParent": {
+		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."
+	},
+	"threadBindings.idleHours": {
+		label: "Discord Thread Binding Idle Timeout (hours)",
+		help: "Inactivity window in hours for Discord thread-bound sessions (/focus and spawned thread sessions). Set 0 to disable idle auto-unfocus (default: 24). Overrides session.threadBindings.idleHours when set."
+	},
+	"threadBindings.maxAgeHours": {
+		label: "Discord Thread Binding Max Age (hours)",
+		help: "Optional hard max age in hours for Discord thread-bound sessions. Set 0 to disable hard cap (default: 0). Overrides session.threadBindings.maxAgeHours when set."
+	},
+	"threadBindings.spawnSessions": {
+		label: "Discord Thread-Bound Session Spawn",
+		help: "Allow sessions_spawn(thread=true) and ACP thread spawns to auto-create and bind Discord threads (default: true). Set false to disable for this account/channel."
+	},
+	"threadBindings.defaultSpawnContext": {
+		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\"."
+	},
+	"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."
+	},
+	"intents.presence": {
+		label: "Discord Presence Intent",
+		help: "Enable the Guild Presences privileged intent. Must also be enabled in the Discord Developer Portal. Allows tracking user activities (e.g. Spotify). Default: false."
+	},
+	"intents.guildMembers": {
+		label: "Discord Guild Members Intent",
+		help: "Enable the Guild Members privileged intent. Must also be enabled in the Discord Developer Portal. Default: false."
+	},
+	"intents.voiceStates": {
+		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."
+	},
+	"voice.model": {
+		label: "Discord Voice Model",
+		help: "Optional LLM model override for Discord voice channel responses (for example openai/gpt-5.4-mini). Leave unset to inherit the routed agent model."
+	},
+	"voice.autoJoin": {
+		label: "Discord Voice Auto-Join",
+		help: "Voice channels to auto-join on startup (list of guildId/channelId entries)."
+	},
+	"voice.daveEncryption": {
+		label: "Discord Voice DAVE Encryption",
+		help: "Toggle DAVE end-to-end encryption for Discord voice joins (default: true in @discordjs/voice; Discord may require this)."
+	},
+	"voice.decryptionFailureTolerance": {
+		label: "Discord Voice Decrypt Failure Tolerance",
+		help: "Consecutive decrypt failures before DAVE attempts session recovery (passed to @discordjs/voice; default: 24)."
+	},
+	"voice.connectTimeoutMs": {
+		label: "Discord Voice Connect Timeout (ms)",
+		help: "Initial @discordjs/voice Ready wait before a join is treated as failed. Default: 30000."
+	},
+	"voice.reconnectGraceMs": {
+		label: "Discord Voice Reconnect Grace (ms)",
+		help: "Grace period for a disconnected Discord voice session to enter Signalling or Connecting before OpenClaw destroys it. Default: 15000."
+	},
+	"voice.tts": {
+		label: "Discord Voice Text-to-Speech",
+		help: "Optional TTS overrides for Discord voice playback (merged with messages.tts)."
+	},
+	"pluralkit.enabled": {
+		label: "Discord PluralKit Enabled",
+		help: "Resolve PluralKit proxied messages and treat system members as distinct senders."
+	},
+	"pluralkit.token": {
+		label: "Discord PluralKit Token",
+		help: "Optional PluralKit token for resolving private systems or members."
+	},
+	activity: {
+		label: "Discord Presence Activity",
+		help: "Discord presence activity text (defaults to custom status)."
+	},
+	status: {
+		label: "Discord Presence Status",
+		help: "Discord presence status (online, dnd, idle, invisible)."
+	},
+	"autoPresence.enabled": {
+		label: "Discord Auto Presence Enabled",
+		help: "Enable automatic Discord bot presence updates based on runtime/model availability signals. When enabled: healthy=>online, degraded/unknown=>idle, exhausted/unavailable=>dnd."
+	},
+	"autoPresence.intervalMs": {
+		label: "Discord Auto Presence Check Interval (ms)",
+		help: "How often to evaluate Discord auto-presence state in milliseconds (default: 30000)."
+	},
+	"autoPresence.minUpdateIntervalMs": {
+		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."
+	},
+	activityType: {
+		label: "Discord Presence Activity Type",
+		help: "Discord presence activity type (0=Playing,1=Streaming,2=Listening,3=Watching,4=Custom,5=Competing)."
+	},
+	activityUrl: {
+		label: "Discord Presence Activity URL",
+		help: "Discord presence streaming URL (required for activityType=1)."
+	},
+	allowBots: {
+		label: "Discord Allow Bot Messages",
+		help: "Allow bot-authored messages to trigger Discord replies (default: false). Set \"mentions\" to only accept bot messages that mention the bot."
+	},
+	mentionAliases: {
+		label: "Discord Mention Aliases",
+		help: "Map outbound @handle text to stable Discord user IDs before sending. Set per account via channels.discord.accounts.<id>.mentionAliases."
+	},
+	token: {
+		label: "Discord Bot Token",
+		help: "Discord bot token used for gateway and REST API authentication for this provider account. Keep this secret out of committed config and rotate immediately after any leak.",
+		sensitive: true
+	},
+	applicationId: {
+		label: "Discord Application ID",
+		help: "Optional Discord application/client ID. Set this when hosted environments cannot reach Discord's application lookup endpoint during startup."
+	}
+} });
+//#endregion
+export { DiscordChannelConfigSchema as t };

package/dist/configured-state.js

@@ -0,0 +1,6 @@
+//#region extensions/discord/configured-state.ts
+function hasDiscordConfiguredState(params) {
+	return typeof params.env?.DISCORD_BOT_TOKEN === "string" && params.env.DISCORD_BOT_TOKEN.trim().length > 0;
+}
+//#endregion
+export { hasDiscordConfiguredState };

package/dist/contract-api.js

@@ -0,0 +1,8 @@
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-D3pSutkb.js";
+import { n as secretTargetRegistryEntries, t as collectRuntimeConfigAssignments } from "./secret-config-contract-CoGryS5c.js";
+import { n as unsupportedSecretRefSurfacePatterns, t as collectUnsupportedSecretRefConfigCandidates } from "./security-contract-ei3Mz8Sa.js";
+import { t as deriveLegacySessionChatType } from "./session-contract-goJZckp2.js";
+import { r as createThreadBindingManager, t as __testing } from "./thread-bindings.manager-BaN0l4y8.js";
+import { n as listDiscordDirectoryGroupsFromConfig, r as listDiscordDirectoryPeersFromConfig } from "./directory-config-LyMP0sdv.js";
+import { t as collectDiscordSecurityAuditFindings } from "./security-audit-Cdz2iq3m.js";
+export { collectDiscordSecurityAuditFindings, collectRuntimeConfigAssignments, collectUnsupportedSecretRefConfigCandidates, createThreadBindingManager, deriveLegacySessionChatType, __testing as discordThreadBindingTesting, legacyConfigRules, listDiscordDirectoryGroupsFromConfig, listDiscordDirectoryPeersFromConfig, normalizeCompatibilityConfig, secretTargetRegistryEntries, unsupportedSecretRefSurfacePatterns };

package/dist/conversation-identity-BN9wSmxJ.js

@@ -0,0 +1,31 @@
+import { o as parseDiscordTarget } from "./normalize-B-ktw-T_.js";
+import { normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+//#region extensions/discord/src/conversation-identity.ts
+function normalizeDiscordTarget(raw, defaultKind) {
+	const trimmed = normalizeOptionalString(raw);
+	if (!trimmed) return;
+	return parseDiscordTarget(trimmed, { defaultKind })?.normalized;
+}
+function buildDiscordConversationIdentity(kind, rawId) {
+	const trimmed = normalizeOptionalString(rawId);
+	return trimmed ? `${kind}:${trimmed}` : void 0;
+}
+function resolveDiscordConversationIdentity(params) {
+	return params.isDirectMessage ? buildDiscordConversationIdentity("user", params.userId) : buildDiscordConversationIdentity("channel", params.channelId);
+}
+function resolveDiscordCurrentConversationIdentity(params) {
+	if (normalizeOptionalLowercaseString(params.chatType) === "direct") {
+		const senderTarget = normalizeDiscordTarget(params.from, "user");
+		if (senderTarget?.startsWith("user:")) return senderTarget;
+	}
+	for (const candidate of [
+		params.originatingTo,
+		params.commandTo,
+		params.fallbackTo
+	]) {
+		const target = normalizeDiscordTarget(candidate, "channel");
+		if (target) return target;
+	}
+}
+//#endregion
+export { resolveDiscordCurrentConversationIdentity as n, resolveDiscordConversationIdentity as t };

package/dist/directory-cache-D93eSrpB.js

@@ -0,0 +1,62 @@
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/text-runtime";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/routing";
+//#region extensions/discord/src/directory-cache.ts
+const DISCORD_DIRECTORY_CACHE_MAX_ENTRIES = 4e3;
+const DISCORD_DISCRIMINATOR_SUFFIX = /#\d{4}$/;
+const DIRECTORY_HANDLE_CACHE = /* @__PURE__ */ new Map();
+function normalizeAccountCacheKey(accountId) {
+	return normalizeAccountId(accountId ?? DEFAULT_ACCOUNT_ID) || DEFAULT_ACCOUNT_ID;
+}
+function normalizeSnowflake(value) {
+	const text = normalizeOptionalStringifiedId(value) ?? "";
+	if (!/^\d+$/.test(text)) return null;
+	return text;
+}
+function normalizeHandleKey(raw) {
+	let handle = normalizeOptionalString(raw) ?? "";
+	if (!handle) return null;
+	if (handle.startsWith("@")) handle = normalizeOptionalString(handle.slice(1)) ?? "";
+	if (!handle || /\s/.test(handle)) return null;
+	return normalizeLowercaseStringOrEmpty(handle);
+}
+function ensureAccountCache(accountId) {
+	const cacheKey = normalizeAccountCacheKey(accountId);
+	const existing = DIRECTORY_HANDLE_CACHE.get(cacheKey);
+	if (existing) return existing;
+	const created = /* @__PURE__ */ new Map();
+	DIRECTORY_HANDLE_CACHE.set(cacheKey, created);
+	return created;
+}
+function setCacheEntry(cache, key, userId) {
+	if (cache.has(key)) cache.delete(key);
+	cache.set(key, userId);
+	if (cache.size <= DISCORD_DIRECTORY_CACHE_MAX_ENTRIES) return;
+	const oldest = cache.keys().next();
+	if (!oldest.done) cache.delete(oldest.value);
+}
+function rememberDiscordDirectoryUser(params) {
+	const userId = normalizeSnowflake(params.userId);
+	if (!userId) return;
+	const cache = ensureAccountCache(params.accountId);
+	for (const candidate of params.handles) {
+		if (typeof candidate !== "string") continue;
+		const handle = normalizeHandleKey(candidate);
+		if (!handle) continue;
+		setCacheEntry(cache, handle, userId);
+		const withoutDiscriminator = handle.replace(DISCORD_DISCRIMINATOR_SUFFIX, "");
+		if (withoutDiscriminator && withoutDiscriminator !== handle) setCacheEntry(cache, withoutDiscriminator, userId);
+	}
+}
+function resolveDiscordDirectoryUserId(params) {
+	const cache = DIRECTORY_HANDLE_CACHE.get(normalizeAccountCacheKey(params.accountId));
+	if (!cache) return;
+	const handle = normalizeHandleKey(params.handle);
+	if (!handle) return;
+	const direct = cache.get(handle);
+	if (direct) return direct;
+	const withoutDiscriminator = handle.replace(DISCORD_DISCRIMINATOR_SUFFIX, "");
+	if (!withoutDiscriminator || withoutDiscriminator === handle) return;
+	return cache.get(withoutDiscriminator);
+}
+//#endregion
+export { resolveDiscordDirectoryUserId as n, rememberDiscordDirectoryUser as t };

package/dist/directory-config-LyMP0sdv.js

@@ -0,0 +1,49 @@
+import { t as __exportAll } from "./rolldown-runtime-C3SqQTfK.js";
+import { a as mergeDiscordAccountConfig, c as resolveDiscordAccountAllowFrom, o as resolveDefaultDiscordAccountId } from "./accounts-BKnkNaoA.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
+var directory_config_exports = /* @__PURE__ */ __exportAll({
+	listDiscordDirectoryGroupsFromConfig: () => listDiscordDirectoryGroupsFromConfig,
+	listDiscordDirectoryPeersFromConfig: () => listDiscordDirectoryPeersFromConfig
+});
+function resolveDiscordDirectoryConfigAccount(cfg, accountId) {
+	const resolvedAccountId = normalizeAccountId(accountId ?? resolveDefaultDiscordAccountId(cfg));
+	const config = mergeDiscordAccountConfig(cfg, resolvedAccountId);
+	return {
+		accountId: resolvedAccountId,
+		config,
+		allowFrom: resolveDiscordAccountAllowFrom({
+			cfg,
+			accountId: resolvedAccountId
+		}) ?? [],
+		dm: config.dm
+	};
+}
+const listDiscordDirectoryPeersFromConfig = createResolvedDirectoryEntriesLister({
+	kind: "user",
+	resolveAccount: (cfg, accountId) => resolveDiscordDirectoryConfigAccount(cfg, accountId),
+	resolveSources: (account) => {
+		const guildUsers = Object.values(account.config.guilds ?? {}).flatMap((guild) => (guild.users ?? []).concat(Object.values(guild.channels ?? {}).flatMap((channel) => channel.users ?? [])));
+		return [
+			account.allowFrom,
+			Object.keys(account.config.dms ?? {}),
+			guildUsers
+		];
+	},
+	normalizeId: (raw) => {
+		const cleaned = (raw.match(/^<@!?(\d+)>$/)?.[1] ?? raw).replace(/^(discord|user):/i, "").trim();
+		return /^\d+$/.test(cleaned) ? `user:${cleaned}` : null;
+	}
+});
+const listDiscordDirectoryGroupsFromConfig = createResolvedDirectoryEntriesLister({
+	kind: "group",
+	resolveAccount: (cfg, accountId) => resolveDiscordDirectoryConfigAccount(cfg, accountId),
+	resolveSources: (account) => Object.values(account.config.guilds ?? {}).map((guild) => Object.keys(guild.channels ?? {})),
+	normalizeId: (raw) => {
+		const cleaned = (raw.match(/^<#(\d+)>$/)?.[1] ?? raw).replace(/^(discord|channel|group):/i, "").trim();
+		return /^\d+$/.test(cleaned) ? `channel:${cleaned}` : null;
+	}
+});
+//#endregion
+export { listDiscordDirectoryGroupsFromConfig as n, listDiscordDirectoryPeersFromConfig as r, directory_config_exports as t };

package/dist/directory-contract-api.js

@@ -0,0 +1,2 @@
+import { n as listDiscordDirectoryGroupsFromConfig, r as listDiscordDirectoryPeersFromConfig } from "./directory-config-LyMP0sdv.js";
+export { listDiscordDirectoryGroupsFromConfig, listDiscordDirectoryPeersFromConfig };

package/dist/directory-live-BQapdpkZ.js

@@ -0,0 +1,101 @@
+import { t as __exportAll } from "./rolldown-runtime-C3SqQTfK.js";
+import { t as normalizeDiscordToken } from "./token-D-w3Rigl.js";
+import { s as resolveDiscordAccount } from "./accounts-BKnkNaoA.js";
+import { t as rememberDiscordDirectoryUser } from "./directory-cache-D93eSrpB.js";
+import { n as fetchDiscord } from "./api-DzNBVTto.js";
+import { a as normalizeDiscordSlug } from "./allow-list-ek-1hMKN.js";
+import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/text-runtime";
+//#region extensions/discord/src/directory-live.ts
+var directory_live_exports = /* @__PURE__ */ __exportAll({
+	listDiscordDirectoryGroupsLive: () => listDiscordDirectoryGroupsLive,
+	listDiscordDirectoryPeersLive: () => listDiscordDirectoryPeersLive
+});
+function normalizeQuery(value) {
+	return normalizeOptionalLowercaseString(value) ?? "";
+}
+function buildUserRank(user) {
+	return user.bot ? 0 : 1;
+}
+function resolveDiscordDirectoryAccess(params) {
+	const account = resolveDiscordAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	const token = normalizeDiscordToken(account.token, "channels.discord.token");
+	if (!token) return null;
+	return {
+		token,
+		query: normalizeQuery(params.query),
+		accountId: account.accountId
+	};
+}
+async function listDiscordGuilds(token) {
+	return (await fetchDiscord("/users/@me/guilds", token)).filter((guild) => guild.id && guild.name);
+}
+async function listDiscordDirectoryGroupsLive(params) {
+	const access = resolveDiscordDirectoryAccess(params);
+	if (!access) return [];
+	const { token, query } = access;
+	const guilds = await listDiscordGuilds(token);
+	const rows = [];
+	for (const guild of guilds) {
+		const channels = await fetchDiscord(`/guilds/${guild.id}/channels`, token);
+		for (const channel of channels) {
+			const name = channel.name?.trim();
+			if (!name) continue;
+			if (query && !normalizeDiscordSlug(name).includes(normalizeDiscordSlug(query))) continue;
+			rows.push({
+				kind: "group",
+				id: `channel:${channel.id}`,
+				name,
+				handle: `#${name}`,
+				raw: channel
+			});
+			if (typeof params.limit === "number" && params.limit > 0 && rows.length >= params.limit) return rows;
+		}
+	}
+	return rows;
+}
+async function listDiscordDirectoryPeersLive(params) {
+	const access = resolveDiscordDirectoryAccess(params);
+	if (!access) return [];
+	const { token, query, accountId } = access;
+	if (!query) return [];
+	const guilds = await listDiscordGuilds(token);
+	const rows = [];
+	const limit = typeof params.limit === "number" && params.limit > 0 ? params.limit : 25;
+	for (const guild of guilds) {
+		const paramsObj = new URLSearchParams({
+			query,
+			limit: String(Math.min(limit, 100))
+		});
+		const members = await fetchDiscord(`/guilds/${guild.id}/members/search?${paramsObj.toString()}`, token);
+		for (const member of members) {
+			const user = member.user;
+			if (!user?.id) continue;
+			rememberDiscordDirectoryUser({
+				accountId,
+				userId: user.id,
+				handles: [
+					user.username,
+					user.global_name,
+					member.nick,
+					user.username ? `@${user.username}` : null
+				]
+			});
+			const name = member.nick?.trim() || user.global_name?.trim() || user.username?.trim();
+			rows.push({
+				kind: "user",
+				id: `user:${user.id}`,
+				name: name || void 0,
+				handle: user.username ? `@${user.username}` : void 0,
+				rank: buildUserRank(user),
+				raw: member
+			});
+			if (rows.length >= limit) return rows;
+		}
+	}
+	return rows;
+}
+//#endregion
+export { listDiscordDirectoryGroupsLive as n, listDiscordDirectoryPeersLive as r, directory_live_exports as t };