@openclaw/discord 2026.5.12 → 2026.5.14-beta.2

package/dist/{approval-native-Gtqpyfdj.js → conversation-identity-C3AI-1tz.js}

@@ -1,8 +1,97 @@
-import { r as listDiscordAccountIds, s as resolveDiscordAccount } from "./accounts-BcwyaFd-.js";
-import { c as createChannelNativeOriginTargetResolver, i as isDiscordExecApprovalClientEnabled, n as getDiscordExecApprovalApprovers, o as createApproverRestrictedNativeApprovalCapability, r as isDiscordExecApprovalApprover, s as createChannelApproverDmTargetResolver, t as shouldHandleDiscordApprovalRequest } from "./approval-shared-BFnWKSQD.js";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { Ht as parseDiscordTarget } from "./send.receipt-nKLxvA1s.js";
+import { r as listDiscordAccountIds, s as resolveDiscordAccount } from "./accounts-DnNVBDfc.js";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createLazyChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
-import { resolveApprovalRequestSessionConversation } from "openclaw/plugin-sdk/approval-native-runtime";
+import { createChannelApproverDmTargetResolver, createChannelNativeOriginTargetResolver, doesApprovalRequestMatchChannelAccount, resolveApprovalRequestSessionConversation } from "openclaw/plugin-sdk/approval-native-runtime";
+import { getExecApprovalReplyMetadata, isChannelExecApprovalClientEnabledFromConfig, matchesApprovalRequestFilters } from "openclaw/plugin-sdk/approval-client-runtime";
+import { resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
+import { createApproverRestrictedNativeApprovalCapability } from "openclaw/plugin-sdk/approval-delivery-runtime";
+//#region extensions/discord/src/exec-approvals.ts
+function normalizeDiscordApproverId(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return;
+	if (/^\d+$/.test(trimmed)) return trimmed;
+	try {
+		const target = parseDiscordTarget(trimmed);
+		return target?.kind === "user" ? target.id : void 0;
+	} catch {
+		return;
+	}
+}
+function resolveDiscordOwnerApprovers(cfg) {
+	const ownerAllowFrom = cfg.commands?.ownerAllowFrom;
+	if (!Array.isArray(ownerAllowFrom) || ownerAllowFrom.length === 0) return [];
+	return resolveApprovalApprovers({
+		explicit: ownerAllowFrom,
+		normalizeApprover: (value) => normalizeDiscordApproverId(String(value))
+	});
+}
+function getDiscordExecApprovalApprovers(params) {
+	return resolveApprovalApprovers({
+		explicit: params.configOverride?.approvers ?? resolveDiscordAccount(params).config.execApprovals?.approvers ?? resolveDiscordOwnerApprovers(params.cfg),
+		normalizeApprover: (value) => normalizeDiscordApproverId(String(value))
+	});
+}
+function isDiscordExecApprovalClientEnabled(params) {
+	return isChannelExecApprovalClientEnabledFromConfig({
+		enabled: (params.configOverride ?? resolveDiscordAccount(params).config.execApprovals)?.enabled,
+		approverCount: getDiscordExecApprovalApprovers({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			configOverride: params.configOverride
+		}).length
+	});
+}
+function isDiscordExecApprovalApprover(params) {
+	const senderId = params.senderId?.trim();
+	if (!senderId) return false;
+	return getDiscordExecApprovalApprovers({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		configOverride: params.configOverride
+	}).includes(senderId);
+}
+function shouldSuppressLocalDiscordExecApprovalPrompt(params) {
+	const metadata = getExecApprovalReplyMetadata(params.payload);
+	const config = resolveDiscordAccount(params).config.execApprovals;
+	return params.hint?.kind === "approval-pending" && params.hint.nativeRouteActive === true && isDiscordExecApprovalClientEnabled(params) && metadata !== null && matchesApprovalRequestFilters({
+		request: {
+			agentId: metadata.agentId,
+			sessionKey: metadata.sessionKey
+		},
+		agentFilter: config?.agentFilter,
+		sessionFilter: config?.sessionFilter
+	});
+}
+//#endregion
+//#region extensions/discord/src/approval-shared.ts
+function shouldHandleDiscordApprovalRequest(params) {
+	const config = params.configOverride ?? resolveDiscordAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}).config.execApprovals;
+	const approvers = getDiscordExecApprovalApprovers({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		configOverride: params.configOverride
+	});
+	if (!doesApprovalRequestMatchChannelAccount({
+		cfg: params.cfg,
+		request: params.request,
+		channel: "discord",
+		accountId: params.accountId
+	})) return false;
+	if (!isChannelExecApprovalClientEnabledFromConfig({
+		enabled: config?.enabled,
+		approverCount: approvers.length
+	})) return false;
+	return matchesApprovalRequestFilters({
+		request: params.request.request,
+		agentFilter: config?.agentFilter,
+		sessionFilter: config?.sessionFilter
+	});
+}
+//#endregion
 //#region extensions/discord/src/approval-native.ts
 function extractDiscordSessionKind(sessionKey) {
 	if (!sessionKey) return null;
@@ -140,7 +229,7 @@ function createDiscordApprovalCapability(configOverride) {
 				request,
 				configOverride
 			}),
-			load: async () => (await import("./approval-handler.runtime-S-ircYcz.js").then((n) => n.t)).discordApprovalNativeRuntime
+			load: async () => (await import("./approval-handler.runtime-Uco62pII.js").then((n) => n.t)).discordApprovalNativeRuntime
 		})
 	});
 }
@@ -150,4 +239,32 @@ function getDiscordApprovalCapability() {
 	return cachedDiscordApprovalCapability;
 }
 //#endregion
-export { getDiscordApprovalCapability as t };
+//#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 { getDiscordExecApprovalApprovers as a, shouldSuppressLocalDiscordExecApprovalPrompt as c, shouldHandleDiscordApprovalRequest as i, resolveDiscordCurrentConversationIdentity as n, isDiscordExecApprovalApprover as o, getDiscordApprovalCapability as r, isDiscordExecApprovalClientEnabled as s, resolveDiscordConversationIdentity as t };

package/dist/{directory-config-CDl4JTCA.js → directory-config-CW_JusGS.js}

@@ -1,5 +1,5 @@
-import { Ft as __exportAll } from "./discord-BqYcwxvG.js";
-import { a as mergeDiscordAccountConfig, c as resolveDiscordAccountAllowFrom, o as resolveDefaultDiscordAccountId } from "./accounts-BcwyaFd-.js";
+import { Wt as __exportAll } from "./send.receipt-nKLxvA1s.js";
+import { a as mergeDiscordAccountConfig, c as resolveDiscordAccountAllowFrom, o as resolveDefaultDiscordAccountId } from "./accounts-DnNVBDfc.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,2 +1,2 @@
-import { n as listDiscordDirectoryGroupsFromConfig, r as listDiscordDirectoryPeersFromConfig } from "./directory-config-CDl4JTCA.js";
+import { n as listDiscordDirectoryGroupsFromConfig, r as listDiscordDirectoryPeersFromConfig } from "./directory-config-CW_JusGS.js";
 export { listDiscordDirectoryGroupsFromConfig, listDiscordDirectoryPeersFromConfig };

package/dist/directory-live-MrDSKsMf.js

@@ -0,0 +1,159 @@
+import { Wt as __exportAll } from "./send.receipt-nKLxvA1s.js";
+import { p as normalizeDiscordToken, s as resolveDiscordAccount } from "./accounts-DnNVBDfc.js";
+import { n as fetchDiscord } from "./api-DgQLz1wq.js";
+import { a as normalizeDiscordSlug } from "./allow-list-CBI-M84K.js";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-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
+//#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 { resolveDiscordDirectoryUserId as a, rememberDiscordDirectoryUser as i, listDiscordDirectoryGroupsLive as n, listDiscordDirectoryPeersLive as r, directory_live_exports as t };

package/dist/doctor-contract-api.js

@@ -1,2 +1,2 @@
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-BGjjFBdq.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-ftWAMvBl.js";
 export { legacyConfigRules, normalizeCompatibilityConfig };

package/dist/{doctor-contract-BGjjFBdq.js → doctor-contract-ftWAMvBl.js}

@@ -1,4 +1,4 @@
-import { t as resolveDiscordPreviewStreamMode } from "./preview-streaming-DCPAe24T.js";
+import { t as resolveDiscordPreviewStreamMode } from "./preview-streaming-CXTZydhx.js";
 import { asObjectRecord, normalizeLegacyChannelAliases } from "openclaw/plugin-sdk/runtime-doctor";
 //#region extensions/discord/src/doctor-contract.ts
 const LEGACY_TTS_PROVIDER_KEYS = [

package/dist/{doctor-jcX_qXsS.js → doctor-mn2XyjuF.js}

@@ -1,8 +1,8 @@
-import { o as resolveDefaultDiscordAccountId } from "./accounts-BcwyaFd-.js";
-import { t as inspectDiscordAccount } from "./account-inspect-D7jL5YDH.js";
-import { n as normalizeCompatibilityConfig } from "./doctor-contract-BGjjFBdq.js";
-import { t as DISCORD_LEGACY_CONFIG_RULES } from "./doctor-shared-D_QLzu30.js";
-import { t as isDiscordMutableAllowEntry } from "./security-doctor-BJH5YIGL.js";
+import { o as resolveDefaultDiscordAccountId } from "./accounts-DnNVBDfc.js";
+import { t as inspectDiscordAccount } from "./account-inspect-B_N30NV0.js";
+import { r as DISCORD_LEGACY_CONFIG_RULES } from "./shared-0kdaIxXP.js";
+import { n as normalizeCompatibilityConfig } from "./doctor-contract-ftWAMvBl.js";
+import { t as isDiscordMutableAllowEntry } from "./security-doctor-Cp-NqNdS.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { collectProviderDangerousNameMatchingScopes } from "openclaw/plugin-sdk/runtime-doctor";
 //#region extensions/discord/src/doctor.ts

package/dist/{handle-action.guild-admin-C4phin-a.js → handle-action.guild-admin-DriifPwO.js}

@@ -1,4 +1,4 @@
-import { a as readDiscordChannelCreateParams, n as isDiscordModerationAction, o as readDiscordChannelEditParams, r as readDiscordModerationCommand, s as readDiscordChannelMoveParams, t as handleDiscordAction } from "./runtime-CdnAT8R5.js";
+import { a as readDiscordChannelCreateParams, n as isDiscordModerationAction, o as readDiscordChannelEditParams, r as readDiscordModerationCommand, s as readDiscordChannelMoveParams, t as handleDiscordAction } from "./runtime-DL82ijB1.js";
 import "./action-runtime-api.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { readNumberParam, readStringArrayParam, readStringParam } from "openclaw/plugin-sdk/agent-runtime";

package/dist/{inbound-context-jtKcY9on.js → inbound-context-DD7n3Q6U.js}

@@ -1,4 +1,4 @@
-import { h as resolveDiscordOwnerAllowFrom, p as resolveDiscordMemberAllowed } from "./allow-list-n8Ki-Rt3.js";
+import { h as resolveDiscordOwnerAllowFrom, p as resolveDiscordMemberAllowed } from "./allow-list-CBI-M84K.js";
 import { buildUntrustedChannelMetadata, wrapExternalContent } from "openclaw/plugin-sdk/security-runtime";
 //#region extensions/discord/src/monitor/inbound-context.ts
 function createDiscordSupplementalContextAccessChecker(params) {

package/dist/{manager.runtime-DqMGETqp.js → manager.runtime-DauS2xA3.js}

@@ -1,12 +1,10 @@
-import { c as ResumedListener, s as ReadyListener, t as discord_exports, u as VoiceStateUpdateListener } from "./discord-BqYcwxvG.js";
-import { c as resolveDiscordAccountAllowFrom } from "./accounts-BcwyaFd-.js";
-import { t as parseDiscordTarget } from "./target-parsing-D-H7nnh2.js";
-import { n as formatDiscordUserTag } from "./format-D8TsaXxW.js";
-import { a as normalizeDiscordSlug, m as resolveDiscordOwnerAccess } from "./allow-list-n8Ki-Rt3.js";
-import { t as formatMention } from "./mentions-BZoGn0ul.js";
-import { t as getDiscordRuntime } from "./runtime-BqCoo-zp.js";
-import { t as buildDiscordGroupSystemPrompt } from "./inbound-context-jtKcY9on.js";
-import { n as resolveDiscordVoiceEnabled, t as authorizeDiscordVoiceIngress } from "./access-Dxmzr0ix.js";
+import { Ht as parseDiscordTarget, _ as VoiceStateUpdateListener, c as discord_exports, h as ResumedListener, m as ReadyListener } from "./send.receipt-nKLxvA1s.js";
+import { c as resolveDiscordAccountAllowFrom } from "./accounts-DnNVBDfc.js";
+import { a as normalizeDiscordSlug, b as formatDiscordUserTag, m as resolveDiscordOwnerAccess } from "./allow-list-CBI-M84K.js";
+import { i as formatMention } from "./send.outbound-D8o8BW6q.js";
+import { t as getDiscordRuntime } from "./runtime-Tqtvj5GX.js";
+import { o as authorizeDiscordVoiceIngress, u as resolveDiscordVoiceEnabled } from "./provider-nzJg2k5t.js";
+import { t as buildDiscordGroupSystemPrompt } from "./inbound-context-DD7n3Q6U.js";
 import { createRequire } from "node:module";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveAgentRoute } from "openclaw/plugin-sdk/routing";
@@ -245,6 +243,27 @@ function scheduleVoiceCaptureFinalize(params) {
 	});
 	return true;
 }
+const logger$3 = createSubsystemLogger("discord/voice");
+function summarizeAgentTurnPayloads(payloads) {
+	let textPayloads = 0;
+	let nonEmptyTextPayloads = 0;
+	let reasoningPayloads = 0;
+	let errorPayloads = 0;
+	let mediaPayloads = 0;
+	for (const payload of payloads) {
+		if (!payload || typeof payload !== "object") continue;
+		const record = payload;
+		const text = record.text;
+		if (typeof text === "string") {
+			textPayloads += 1;
+			if (text.trim()) nonEmptyTextPayloads += 1;
+		}
+		if (record.isReasoning === true) reasoningPayloads += 1;
+		if (record.isError === true) errorPayloads += 1;
+		if (typeof record.mediaUrl === "string" || Array.isArray(record.mediaUrls) && record.mediaUrls.length > 0) mediaPayloads += 1;
+	}
+	return `payloadCount=${payloads.length} textPayloads=${textPayloads} nonEmptyTextPayloads=${nonEmptyTextPayloads} reasoningPayloads=${reasoningPayloads} errorPayloads=${errorPayloads} mediaPayloads=${mediaPayloads}`;
+}
 async function resolveDiscordVoiceIngressContext(params) {
 	const { entry, userId } = params;
 	if (!entry.guildName) entry.guildName = await params.fetchGuildName(entry.guildId);
@@ -286,21 +305,24 @@ async function runDiscordVoiceAgentTurn(params) {
 	});
 	if (!context) return null;
 	const voiceModel = normalizeOptionalString(params.discordConfig.voice?.model);
+	const payloads = (await agentCommandFromIngress({
+		message: params.message,
+		sessionKey: params.entry.route.sessionKey,
+		agentId: params.entry.route.agentId,
+		messageChannel: "discord",
+		messageProvider: "discord-voice",
+		extraSystemPrompt: context.extraSystemPrompt,
+		senderIsOwner: context.senderIsOwner,
+		allowModelOverride: Boolean(voiceModel),
+		model: voiceModel,
+		toolsAllow: params.toolsAllow,
+		deliver: false
+	}, params.runtime)).payloads ?? [];
+	const text = payloads.map((payload) => payload.text).filter((entry) => typeof entry === "string" && entry.trim()).join("\n").trim();
+	if (!text) logger$3.info(`discord voice: agent turn produced no speakable payloads guild=${params.entry.guildId} channel=${params.entry.channelId} voiceSession=${params.entry.voiceSessionKey} supervisorSession=${params.entry.route.sessionKey} agent=${params.entry.route.agentId} user=${params.userId} ${summarizeAgentTurnPayloads(payloads)}`);
 	return {
 		context,
-		text: ((await agentCommandFromIngress({
-			message: params.message,
-			sessionKey: params.entry.route.sessionKey,
-			agentId: params.entry.route.agentId,
-			messageChannel: "discord",
-			messageProvider: "discord-voice",
-			extraSystemPrompt: context.extraSystemPrompt,
-			senderIsOwner: context.senderIsOwner,
-			allowModelOverride: Boolean(voiceModel),
-			model: voiceModel,
-			toolsAllow: params.toolsAllow,
-			deliver: false
-		}, params.runtime)).payloads ?? []).map((payload) => payload.text).filter((text) => typeof text === "string" && text.trim()).join("\n").trim()
+		text
 	};
 }
 //#endregion
@@ -356,6 +378,7 @@ const DISCORD_REALTIME_RECENT_AGENT_PROXY_CONSULT_TTL_MS = 15e3;
 const DISCORD_REALTIME_LOG_PREVIEW_CHARS = 500;
 const DISCORD_REALTIME_DEFAULT_MIN_BARGE_IN_AUDIO_END_MS = 250;
 const DISCORD_REALTIME_FORCED_CONSULT_FALLBACK_DELAY_MS = 200;
+const DISCORD_REALTIME_DUPLICATE_ERROR_SUPPRESS_MS = 6e4;
 const REALTIME_PCM16_BYTES_PER_SAMPLE = 2;
 const DISCORD_REALTIME_FORCED_CONSULT_TRAILING_FRAGMENT_WORDS = new Set([
 	"a",
@@ -603,8 +626,11 @@ var DiscordRealtimeVoiceSession = class {
 				const interruptionLog = formatRealtimeInterruptionLog(event);
 				if (interruptionLog) logger$2.info(interruptionLog);
 			},
-			onError: (error) => logger$2.warn(`discord voice: realtime error: ${formatErrorMessage(error)}`),
-			onClose: (reason) => logVoiceVerbose(`realtime closed: ${reason}`)
+			onError: (error) => this.logRealtimeError(formatErrorMessage(error)),
+			onClose: (reason) => {
+				this.flushSuppressedRealtimeErrors();
+				logVoiceVerbose(`realtime closed: ${reason}`);
+			}
 		});
 		const resolvedModel = readProviderConfigString(resolved.providerConfig, "model") ?? resolved.provider.defaultModel;
 		const resolvedVoice = readProviderConfigString(resolved.providerConfig, "voice");
@@ -619,6 +645,7 @@ var DiscordRealtimeVoiceSession = class {
 	}
 	close() {
 		this.stopped = true;
+		this.flushSuppressedRealtimeErrors();
 		this.talkback.close();
 		this.clearForcedConsultTimers();
 		this.pendingAgentProxyConsultContexts = [];
@@ -633,6 +660,25 @@ var DiscordRealtimeVoiceSession = class {
 		const voiceSdk = loadDiscordVoiceSdk();
 		this.params.entry.player.off(voiceSdk.AudioPlayerStatus.Idle, this.playerIdleHandler);
 	}
+	logRealtimeError(message) {
+		const now = Date.now();
+		if (this.lastRealtimeError?.message === message && now - this.lastRealtimeError.lastLoggedAt < DISCORD_REALTIME_DUPLICATE_ERROR_SUPPRESS_MS) {
+			this.lastRealtimeError.suppressed += 1;
+			return;
+		}
+		this.flushSuppressedRealtimeErrors();
+		this.lastRealtimeError = {
+			message,
+			suppressed: 0,
+			lastLoggedAt: now
+		};
+		logger$2.warn(`discord voice: realtime error: ${message}`);
+	}
+	flushSuppressedRealtimeErrors() {
+		if (!this.lastRealtimeError || this.lastRealtimeError.suppressed === 0) return;
+		logger$2.warn(`discord voice: suppressed ${this.lastRealtimeError.suppressed} duplicate realtime errors: ${this.lastRealtimeError.message}`);
+		this.lastRealtimeError.suppressed = 0;
+	}
 	beginSpeakerTurn(context, userId) {
 		const turn = {
 			context: {
@@ -1485,6 +1531,15 @@ var DiscordVoiceSpeakerContextResolver = class {
 //#region extensions/discord/src/voice/manager.ts
 const logger = createSubsystemLogger("discord/voice");
 const VOICE_LOG_PREVIEW_CHARS = 500;
+const DISCORD_VOICE_FATAL_AUTOJOIN_ERROR_PATTERNS = [
+	"api key missing",
+	"incorrect api key",
+	"invalid api key",
+	"unauthorized",
+	"authentication",
+	"permission denied",
+	"forbidden"
+];
 function formatVoiceLogPreview(text) {
 	const oneLine = text.replace(/\s+/g, " ").trim();
 	if (oneLine.length <= VOICE_LOG_PREVIEW_CHARS) return oneLine;
@@ -1524,6 +1579,13 @@ function normalizeVoiceChannelResidencies(entries) {
 function isVoiceChannelAllowed(params) {
 	return params.allowedChannels === null || params.allowedChannels.some((entry) => entry.guildId === params.guildId && entry.channelId === params.channelId);
 }
+function formatAutoJoinFailureKey(entry) {
+	return `${entry.guildId}:${entry.channelId}`;
+}
+function isFatalAutoJoinFailure(message) {
+	const normalized = message.toLowerCase();
+	return DISCORD_VOICE_FATAL_AUTOJOIN_ERROR_PATTERNS.some((pattern) => normalized.includes(pattern));
+}
 function startAutoJoin(manager) {
 	manager.autoJoin().catch((err) => logger.warn(`discord voice: autoJoin failed: ${formatErrorMessage(err)}`));
 }
@@ -1570,6 +1632,7 @@ var DiscordVoiceManager$1 = class {
 		this.params = params;
 		this.sessions = /* @__PURE__ */ new Map();
 		this.autoJoinTask = null;
+		this.fatalAutoJoinFailures = /* @__PURE__ */ new Map();
 		this.botUserId = params.botUserId;
 		this.voiceEnabled = resolveDiscordVoiceEnabled(params.discordConfig.voice);
 		this.ownerAllowFrom = resolveDiscordAccountAllowFrom({
@@ -1611,12 +1674,27 @@ var DiscordVoiceManager$1 = class {
 				if (selected) logger.warn(`discord voice: autoJoin has multiple entries for guild ${guildId}; using channel ${selected.channelId}`);
 			}
 			for (const entry of entriesByGuild.values()) {
+				const failureKey = formatAutoJoinFailureKey(entry);
+				const fatalFailure = this.fatalAutoJoinFailures.get(failureKey);
+				if (fatalFailure) {
+					if (!fatalFailure.skipLogged) {
+						logger.warn(`discord voice: autoJoin suppressed guild=${entry.guildId} channel=${entry.channelId} after fatal startup failure; retry with /vc join or reload config after fixing credentials: ${fatalFailure.message}`);
+						fatalFailure.skipLogged = true;
+					}
+					continue;
+				}
 				logVoiceVerbose(`autoJoin: joining guild ${entry.guildId} channel ${entry.channelId}`);
 				const result = await this.join({
 					guildId: entry.guildId,
 					channelId: entry.channelId
 				});
-				if (!result.ok) logger.warn(`discord voice: autoJoin skipped guild=${entry.guildId} channel=${entry.channelId}: ${result.message}`);
+				if (!result.ok) {
+					logger.warn(`discord voice: autoJoin skipped guild=${entry.guildId} channel=${entry.channelId}: ${result.message}`);
+					if (isFatalAutoJoinFailure(result.message)) this.fatalAutoJoinFailures.set(failureKey, {
+						message: result.message,
+						skipLogged: false
+					});
+				}
 			}
 		})().finally(() => {
 			this.autoJoinTask = null;
@@ -1881,6 +1959,10 @@ var DiscordVoiceManager$1 = class {
 		connection.on(voiceSdk.VoiceConnectionStatus.Destroyed, destroyedHandler);
 		player.on("error", playerErrorHandler);
 		this.sessions.set(guildId, entry);
+		this.fatalAutoJoinFailures.delete(formatAutoJoinFailureKey({
+			guildId,
+			channelId
+		}));
 		logger.info(`discord voice: joined guild=${guildId} channel=${channelId} mode=${voiceMode} agent=${route.agentId} voiceSession=${voiceRoute.sessionKey} supervisorSession=${route.sessionKey} voiceModel=${voiceConfig?.model ?? "route-default"}`);
 		return {
 			ok: true,

package/dist/{message-handler-DIsnboy2.js → message-handler-CMHwRlxG.js}

@@ -1,8 +1,8 @@
-import { j as createDiscordRestClient } from "./send.shared-Dza0jdso.js";
-import { a as resolveDiscordChannelParentSafe, n as resolveDiscordChannelInfoSafe, r as resolveDiscordChannelNameSafe, t as resolveDiscordChannelIdSafe } from "./channel-access-BL-wemES.js";
-import { a as mergeAbortSignals } from "./timeouts-C3FYXWJX.js";
-import { l as resolveDiscordMessageChannelId, r as resolveDiscordMessageText, s as hasDiscordMessageStickers } from "./message-utils-ByofKwPe.js";
-import { t as sendTyping } from "./typing-_jePdFIw.js";
+import { M as createDiscordRestClient } from "./send.shared-DSpva7uA.js";
+import { d as resolveDiscordChannelNameSafe, l as resolveDiscordChannelIdSafe, p as resolveDiscordChannelParentSafe, u as resolveDiscordChannelInfoSafe } from "./thread-bindings.discord-api-DJACBZJ1.js";
+import { a as mergeAbortSignals } from "./timeouts-snXNwR4m.js";
+import { l as resolveDiscordMessageChannelId, r as resolveDiscordMessageText, s as hasDiscordMessageStickers } from "./message-utils-N5UTOXQ2.js";
+import { t as sendTyping } from "./typing-C_8U8J7E.js";
 import { danger, logVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { resolveOpenProviderRuntimeGroupPolicy } from "openclaw/plugin-sdk/runtime-group-policy";
 import { resolveBatchedReplyThreadingPolicy } from "openclaw/plugin-sdk/reply-reference";
@@ -121,7 +121,7 @@ function applyImplicitReplyBatchGate(ctx, replyToMode, isBatched) {
 //#region extensions/discord/src/monitor/message-run-queue.ts
 let messageProcessRuntimePromise;
 async function loadMessageProcessRuntime() {
-	messageProcessRuntimePromise ??= import("./message-handler.process-Bs5wropA.js");
+	messageProcessRuntimePromise ??= import("./message-handler.process-Cy7_-0H0.js");
 	return await messageProcessRuntimePromise;
 }
 async function processDiscordQueuedMessage(params) {
@@ -173,7 +173,7 @@ function createDiscordMessageRunQueue(params) {
 //#region extensions/discord/src/monitor/message-handler.ts
 let messagePreflightRuntimePromise;
 async function loadMessagePreflightRuntime() {
-	messagePreflightRuntimePromise ??= import("./message-handler.preflight-BRH-dv1o.js");
+	messagePreflightRuntimePromise ??= import("./message-handler.preflight-C0sT-ewp.js");
 	return await messagePreflightRuntimePromise;
 }
 function isNonEmptyString(value) {