@openclaw/discord 2026.9.6 → 2026.9.8

package/dist/.setup/provider-session.runtime-BYlTBFD2.mjs

@@ -0,0 +1,6 @@
+import { i as createNoopThreadBindingManager, t as createThreadBindingManager } from "./thread-bindings.manager-DN-NissX.mjs";
+import { c as reconcileAcpThreadBindingsOnStartup } from "./thread-bindings-D7TfgjR_.mjs";
+import { t as createDiscordMessageHandler } from "./message-handler-B-Jk4oDk.mjs";
+import { resolveThreadBindingIdleTimeoutMs, resolveThreadBindingMaxAgeMs, resolveThreadBindingsEnabled } from "openclaw/plugin-sdk/conversation-runtime";
+import { getAcpSessionManager, isAcpRuntimeError } from "openclaw/plugin-sdk/acp-runtime";
+export { createDiscordMessageHandler, createNoopThreadBindingManager, createThreadBindingManager, getAcpSessionManager, isAcpRuntimeError, reconcileAcpThreadBindingsOnStartup, resolveThreadBindingIdleTimeoutMs, resolveThreadBindingMaxAgeMs, resolveThreadBindingsEnabled };

package/dist/.setup/provider.runtime-CUE3UxER.mjs

@@ -0,0 +1,2 @@
+import { t as monitorDiscordProvider } from "./provider-B_G5hASF.mjs";
+export { monitorDiscordProvider };

package/dist/.setup/{realtime-session.runtime-Dz8uVutq.mjs → realtime-session.runtime-oUd9DOcz.mjs}

@@ -1,11 +1,12 @@
-import { a as buildProviderConfigOverrides, o as buildProviderConfigs } from "./transcripts-source-DVegW0WI.mjs";
-import { S as setDiscordAudioOutputStatus, _ as getDiscordAudioOutputStatus, d as createDiscordPcmToRealtimeConverter, g as admitDiscordAudioInput, h as DiscordAudioOutputStatus, v as releaseDiscordAudioInput, y as restoreDiscordAudioError } from "./receive-recovery-DHst8WRx.mjs";
-import { n as discordRealtimeVoiceSecretOwnerId } from "./secret-config-contract-DFu9hfU8.mjs";
-import { a as handleDiscordVoiceAgentControlToolCall, c as formatRealtimeInterruptionLog, d as shouldLogRealtimeVerboseEvent, i as formatVoiceIngressPrompt, l as formatRealtimeLifecycleLog, n as DiscordRealtimeRecording, o as logDiscordVoiceAgentControlResult, r as logVoiceVerbose, s as maybeControlDiscordVoiceAgentRun, u as formatVoiceLogPreview } from "./voice-runtime-elTtjEIG.mjs";
+import { _ as releaseDiscordAudioInput, g as getDiscordAudioOutputStatus, h as admitDiscordAudioInput, m as DiscordAudioOutputStatus, u as createDiscordPcmToRealtimeConverter, v as restoreDiscordAudioError, x as setDiscordAudioOutputStatus } from "./receive-recovery-CHPOsnLc.mjs";
+import { n as discordRealtimeVoiceSecretOwnerId } from "./secret-config-contract-uOE2J7yM.mjs";
+import { g as logVoiceVerbose } from "./provider-B_G5hASF.mjs";
+import { a as logDiscordVoiceAgentControlResult, c as formatRealtimeLifecycleLog, i as handleDiscordVoiceAgentControlToolCall, l as formatVoiceLogPreview, n as DiscordRealtimeRecording, o as maybeControlDiscordVoiceAgentRun, r as formatVoiceIngressPrompt, s as formatRealtimeInterruptionLog, u as shouldLogRealtimeVerboseEvent } from "./voice-runtime-B46rcwrG.mjs";
 import { randomUUID } from "node:crypto";
 import { asDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/ssrf-runtime";
 import { formatErrorMessage as formatErrorMessage$1, readErrorName, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
 import { sliceUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { MessageChannel } from "node:worker_threads";
@@ -384,16 +385,16 @@ var DiscordRealtimeConsults = class {
 		const outcome = classifyRealtimeVoiceConsultToolCall(event.args, { retainedExactSpeechTexts: this.params.playback.retainedExactSpeechTexts() });
 		switch (outcome.kind) {
 			case "exact-speech-echo":
-				logger$3.info(`discord voice: realtime exact speech consult bypassed call=${callId || "unknown"} answerChars=${outcome.text.length}`);
+				logger$3.info(`discord voice: realtime exact speech consult bypassed call=${callId} answerChars=${outcome.text.length}`);
 				await session.submitToolResult(callId, { text: outcome.text });
 				return;
 			case "malformed":
-				logger$3.warn(`discord voice: realtime consult rejected malformed args call=${callId || "unknown"}: ${outcome.error}`);
+				logger$3.warn(`discord voice: realtime consult rejected malformed args call=${callId}: ${outcome.error}`);
 				await session.submitToolResult(callId, { error: outcome.error });
 				return;
 		}
 		const consultMessage = outcome.message;
-		logger$3.info(`discord voice: realtime consult requested call=${callId || "unknown"} voiceSession=${this.params.entry.voiceSessionKey} supervisorSession=${this.params.entry.route.sessionKey} agent=${this.params.entry.route.agentId} question=${formatVoiceLogPreview(consultMessage)}`);
+		logger$3.info(`discord voice: realtime consult requested call=${callId} voiceSession=${this.params.entry.voiceSessionKey} supervisorSession=${this.params.entry.route.sessionKey} agent=${this.params.entry.route.agentId} question=${formatVoiceLogPreview(consultMessage)}`);
 		const nativeConsult = this.params.harness.forcedConsults.recordNativeConsult(event.args, callId);
 		if (nativeConsult.kind === "already_delivered" && this.params.harness.forcedConsults.isCancelled(nativeConsult.handle)) {
 			await this.submitTerminalRealtimeToolResult(callId, session, CANCELLED_CONSULT_RESULT);
@@ -417,14 +418,22 @@ var DiscordRealtimeConsults = class {
 		}
 		if (!context) {
 			context = this.params.turns.consumePendingSpeakerContext();
-			if (context) recent = this.rememberRecentAgentProxyConsultContext(consultMessage, context, {
-				...callId === "unknown" ? {} : { id: `native-consult:${callId}` },
-				started: true
-			});
+			if (context) {
+				recent = this.params.harness.forcedConsults.prepare(consultMessage, {
+					context: {
+						speaker: context,
+						providerEpoch: this.params.providerEpoch(),
+						delivery: "provider"
+					},
+					...callId === "unknown" ? {} : { id: `native-consult:${callId}` }
+				});
+				if (!recent) throw new Error("Discord realtime consult context requires a non-empty question");
+				this.params.harness.forcedConsults.markStarted(recent);
+			}
 		}
 		const state = recent?.context;
 		if (!context || !state) {
-			logger$3.warn(`discord voice: realtime consult has no speaker context call=${callId || "unknown"}`);
+			logger$3.warn(`discord voice: realtime consult has no speaker context call=${callId}`);
 			await session.submitToolResult(callId, { error: "No Discord speaker context available" });
 			return;
 		}
@@ -475,7 +484,7 @@ var DiscordRealtimeConsults = class {
 		}
 		if (!this.params.isAgentProxy()) return;
 		if (usesRealtimeAgentHandoff) {
-			if (pendingForcedConsult) this.schedulePreparedForcedAgentProxyConsult(pendingForcedConsult);
+			if (pendingForcedConsult) this.params.harness.forcedConsults.schedule(pendingForcedConsult, DISCORD_REALTIME_FORCED_CONSULT_FALLBACK_DELAY_MS, (handle) => void this.runForcedAgentProxyConsult(handle));
 			return;
 		}
 		this.talkback.enqueue(acceptedText, fallbackSpeakerContext);
@@ -553,9 +562,6 @@ var DiscordRealtimeConsults = class {
 			delivery: "provider"
 		} });
 	}
-	schedulePreparedForcedAgentProxyConsult(pending) {
-		this.params.harness.forcedConsults.schedule(pending, DISCORD_REALTIME_FORCED_CONSULT_FALLBACK_DELAY_MS, (handle) => void this.runForcedAgentProxyConsult(handle));
-	}
 	async runForcedAgentProxyConsult(pending) {
 		this.params.harness.forcedConsults.markStarted(pending);
 		const state = pending.context;
@@ -590,19 +596,6 @@ var DiscordRealtimeConsults = class {
 			this.params.playback.enqueueExactSpeechMessage(text);
 		}
 	}
-	rememberRecentAgentProxyConsultContext(question, context, options = {}) {
-		const handle = this.params.harness.forcedConsults.prepare(question, {
-			context: {
-				speaker: context,
-				providerEpoch: this.params.providerEpoch(),
-				delivery: "provider"
-			},
-			...options.id ? { id: options.id } : {}
-		});
-		if (!handle) throw new Error("Discord realtime consult context requires a non-empty question");
-		if (options.started) this.params.harness.forcedConsults.markStarted(handle);
-		return handle;
-	}
 	trackAgentProxyConsult(recent, promise) {
 		const state = recent?.context;
 		if (recent) this.params.harness.forcedConsults.markStarted(recent);
@@ -1099,8 +1092,9 @@ var DiscordRealtimePlayback = class {
 	/** Accept completed consult ownership without starting provider work during transport cleanup. */
 	retainExactSpeechMessage(text) {
 		if (!text.trim()) return false;
-		const retainedMessages = this.queuedExactSpeechMessages.length + (this.exactSpeechState.status === "active" ? 1 : 0);
-		const retainedBytes = this.queuedExactSpeechMessages.reduce((total, message) => total + Buffer.byteLength(message, "utf8"), 0) + Buffer.byteLength(this.exactSpeechState.status === "active" ? this.exactSpeechState.message : "", "utf8");
+		const retained = this.retainedExactSpeechTexts();
+		const retainedMessages = retained.length;
+		const retainedBytes = retained.reduce((total, message) => total + Buffer.byteLength(message, "utf8"), 0);
 		const incomingBytes = Buffer.byteLength(text, "utf8");
 		if (retainedMessages >= DISCORD_REALTIME_MAX_RETAINED_RESPONSES || retainedBytes + incomingBytes > DISCORD_REALTIME_MAX_RETAINED_EXACT_SPEECH_BYTES) {
 			this.stopAfterPlaybackFailure("exact-speech-overflow", /* @__PURE__ */ new Error(`Discord realtime exact speech overflow: retained=${retainedMessages} retainedBytes=${retainedBytes} incomingBytes=${incomingBytes}`));
@@ -1209,7 +1203,6 @@ var DiscordRealtimePlayback = class {
 		const logContext = `guild=${this.params.entry.guildId} channel=${this.params.entry.channelId}`;
 		const output = new DiscordRealtimeOutput({
 			player: this.params.player,
-			logContext,
 			continuous: this.isContinuousOutput(),
 			onStart: () => {
 				this.params.harness.outputActivity.markPlaybackStarted();
@@ -1264,10 +1257,6 @@ var DiscordRealtimePlayback = class {
 };
 //#endregion
 //#region extensions/discord/src/voice/realtime-speaker-config.ts
-function readProviderConfigString(config, key) {
-	const value = config[key];
-	return typeof value === "string" && value.trim() ? value.trim() : void 0;
-}
 /** Resolve the same provider, voice catalog, and policies for initial and replacement connections. */
 function resolveDiscordRealtimeSpeakerConfig(params) {
 	const { realtimeConfig, isAgentProxy } = params;
@@ -1278,11 +1267,14 @@ function resolveDiscordRealtimeSpeakerConfig(params) {
 		if (canonicalProviderId) ownerProviderIds.add(canonicalProviderId);
 		for (const providerId of ownerProviderIds) assertSecretOwnerAvailable("capability", discordRealtimeVoiceSecretOwnerId(params.accountId, providerId));
 	}
+	const configuredVoice = realtimeConfig?.speakerVoice || realtimeConfig?.speakerVoiceId;
 	const resolved = resolveConfiguredRealtimeVoiceProvider({
 		configuredProviderId: realtimeConfig?.provider,
-		providerConfigs: buildProviderConfigs(realtimeConfig),
+		providerConfigs: { ...realtimeConfig?.providers },
 		providerConfigOverrides: {
-			...buildProviderConfigOverrides(realtimeConfig),
+			...realtimeConfig?.model ? { model: realtimeConfig.model } : {},
+			...configuredVoice ? { voice: configuredVoice } : {},
+			...typeof realtimeConfig?.minBargeInAudioEndMs === "number" ? { minBargeInAudioEndMs: realtimeConfig.minBargeInAudioEndMs } : {},
 			...params.voiceOverride ? {
 				voice: params.voiceOverride,
 				speakerVoice: params.voiceOverride
@@ -1300,14 +1292,14 @@ function resolveDiscordRealtimeSpeakerConfig(params) {
 	});
 	assertSecretOwnerAvailable("capability", discordRealtimeVoiceSecretOwnerId(params.accountId, resolved.provider.id));
 	const capabilities = resolved.capabilities;
-	const model = readProviderConfigString(resolved.providerConfig, "model") ?? resolved.provider.defaultModel;
+	const model = normalizeOptionalString(resolved.providerConfig.model) ?? resolved.provider.defaultModel;
 	const voices = [...capabilities?.voices ?? (model ? capabilities?.voicesByModel?.[model] : void 0) ?? resolved.provider.voices ?? []];
 	const publicConfig = projectInternalRealtimeVoicePublicConfig({
 		provider: resolved.provider,
 		providerConfig: resolved.providerConfig,
 		config: {
 			model,
-			voice: readProviderConfigString(resolved.providerConfig, "speakerVoice") ?? readProviderConfigString(resolved.providerConfig, "voice")
+			voice: normalizeOptionalString(resolved.providerConfig.speakerVoice) ?? normalizeOptionalString(resolved.providerConfig.voice)
 		}
 	});
 	const selection = {
@@ -1358,7 +1350,7 @@ function resolveDiscordRealtimeSpeakerConfig(params) {
 		bargeIn,
 		minBargeInAudioEndMs,
 		resolvedModel: model,
-		resolvedVoice: readProviderConfigString(resolved.providerConfig, "voice")
+		resolvedVoice: normalizeOptionalString(resolved.providerConfig.voice)
 	};
 }
 //#endregion
@@ -1366,9 +1358,6 @@ function resolveDiscordRealtimeSpeakerConfig(params) {
 const logger$1 = createSubsystemLogger("discord/voice");
 const DISCORD_REALTIME_DUPLICATE_ERROR_SUPPRESS_MS = 6e4;
 const discordRealtimeTalkPayload = () => ({});
-function isDiscordAgentProxyVoiceMode(mode) {
-	return mode === "agent-proxy";
-}
 var DiscordRealtimeSpeakerSession = class {
 	constructor(params) {
 		this.params = params;
@@ -1391,7 +1380,12 @@ var DiscordRealtimeSpeakerSession = class {
 		this.inputIdleListeners = /* @__PURE__ */ new Set();
 		this.lastActivityAt = Date.now();
 		this.outputEnabled = !params.standby;
-		this.recording = this.createRecording();
+		const recordingEpoch = this.providerContinuityEpoch;
+		this.recording = new DiscordRealtimeRecording({
+			entry: this.params.entry,
+			isCurrent: () => this.lifecycle.status !== "stopped" && this.providerContinuityEpoch === recordingEpoch,
+			warn: (message) => logger$1.warn(message)
+		});
 		this.harness = createRealtimeVoiceSessionHarness({
 			talk: {
 				sessionId: this.params.sessionId,
@@ -1462,7 +1456,7 @@ var DiscordRealtimeSpeakerSession = class {
 			debounceMs: () => this.realtimeConfig?.debounceMs,
 			entry: this.params.entry,
 			harness: this.harness,
-			isAgentProxy: () => isDiscordAgentProxyVoiceMode(this.params.mode) && !this.handlesAgentConsult,
+			isAgentProxy: () => this.params.mode === "agent-proxy" && !this.handlesAgentConsult,
 			isWakeNameRequired: () => this.isWakeNameRequired(),
 			playback: this.playback,
 			providerEpoch: () => this.providerContinuityEpoch,
@@ -1485,7 +1479,7 @@ var DiscordRealtimeSpeakerSession = class {
 			agentId: this.params.entry.route.agentId,
 			cfg: this.params.cfg,
 			realtimeConfig: this.realtimeConfig,
-			isAgentProxy: isDiscordAgentProxyVoiceMode(this.params.mode),
+			isAgentProxy: this.params.mode === "agent-proxy",
 			bootstrapContextInstructions: this.params.bootstrapContextInstructions,
 			voiceOverride: this.params.voiceOverride,
 			conversationHistory: this.params.conversationHistory
@@ -1791,14 +1785,6 @@ var DiscordRealtimeSpeakerSession = class {
 		this.turns.resetProviderContinuity();
 		this.playback.resetProviderContinuity(reason);
 	}
-	createRecording() {
-		const epoch = this.providerContinuityEpoch;
-		return new DiscordRealtimeRecording({
-			entry: this.params.entry,
-			isCurrent: () => this.lifecycle.status !== "stopped" && this.providerContinuityEpoch === epoch,
-			warn: (message) => logger$1.warn(message)
-		});
-	}
 	logRealtimeError(message) {
 		const now = Date.now();
 		if (this.lastRealtimeError?.message === message && now - this.lastRealtimeError.lastLoggedAt < DISCORD_REALTIME_DUPLICATE_ERROR_SUPPRESS_MS) {

package/dist/.setup/{receive-recovery-DHst8WRx.mjs → receive-recovery-CHPOsnLc.mjs}

@@ -479,9 +479,6 @@ function resetVoiceReceiveRecoveryState(state) {
 	state.decryptFailureCount = 0;
 	state.lastDecryptFailureAt = 0;
 }
-function finishVoiceDecryptRecovery(state) {
-	state.decryptRecoveryInFlight = false;
-}
 function isDaveReinitializing(session) {
 	return session.reinitializing === true;
 }
@@ -514,4 +511,4 @@ function enableDaveReceivePassthrough(params) {
 	}
 }
 //#endregion
-export { setDiscordAudioOutputStatus as S, getDiscordAudioOutputStatus as _, finishVoiceDecryptRecovery as a, retireDiscordAudioOutput as b, resetVoiceReceiveRecoveryState as c, createDiscordPcmToRealtimeConverter as d, createRealtimePcmToDiscordConverter as f, admitDiscordAudioInput as g, DiscordAudioOutputStatus as h, enableDaveReceivePassthrough as i, createDiscordOpusEncodeStream as l, writeVoiceWavFile as m, analyzeVoiceReceiveError as n, noteVoiceDecryptFailure as o, decodeOpusStreamChunks as p, createVoiceReceiveRecoveryState as r, recoverDaveZeroTransition as s, DECRYPT_FAILURE_WINDOW_MS as t, createDiscordOpusPlaybackStream as u, releaseDiscordAudioInput as v, serializeDiscordAudioError as x, restoreDiscordAudioError as y };
+export { releaseDiscordAudioInput as _, noteVoiceDecryptFailure as a, serializeDiscordAudioError as b, createDiscordOpusEncodeStream as c, createRealtimePcmToDiscordConverter as d, decodeOpusStreamChunks as f, getDiscordAudioOutputStatus as g, admitDiscordAudioInput as h, enableDaveReceivePassthrough as i, createDiscordOpusPlaybackStream as l, DiscordAudioOutputStatus as m, analyzeVoiceReceiveError as n, recoverDaveZeroTransition as o, writeVoiceWavFile as p, createVoiceReceiveRecoveryState as r, resetVoiceReceiveRecoveryState as s, DECRYPT_FAILURE_WINDOW_MS as t, createDiscordPcmToRealtimeConverter as u, restoreDiscordAudioError as v, setDiscordAudioOutputStatus as x, retireDiscordAudioOutput as y };

package/dist/.setup/{resolve-allowlist-common-CwMBzbx9.mjs → resolve-allowlist-common-DPdRggu5.mjs}

@@ -1,6 +1,6 @@
-import { o as normalizeDiscordSlug } from "./channel-type-DKnjV1XW.mjs";
-import { m as normalizeDiscordToken } from "./accounts-CwJQoLjM.mjs";
-import { r as fetchDiscord } from "./api-CBK9zcq5.mjs";
+import { o as normalizeDiscordSlug } from "./channel-type-DRCrEMss.mjs";
+import { m as normalizeDiscordToken } from "./accounts-ChaMcixG.mjs";
+import { r as fetchDiscord } from "./api-DVbJwZVt.mjs";
 //#region extensions/discord/src/guilds.ts
 async function listGuilds(token, fetcher, options) {
 	return (await fetchDiscord("/users/@me/guilds", token, fetcher, options)).filter((guild) => typeof guild.id === "string" && typeof guild.name === "string").map((guild) => ({
@@ -14,9 +14,6 @@ async function listGuilds(token, fetcher, options) {
 function resolveDiscordAllowlistToken(token) {
 	return normalizeDiscordToken(token, "channels.discord.token");
 }
-function buildDiscordUnresolvedResults(entries, buildResult) {
-	return entries.map(buildResult);
-}
 function findDiscordGuildByName(guilds, input) {
 	const slug = normalizeDiscordSlug(input);
 	if (!slug) return;
@@ -31,4 +28,4 @@ function filterDiscordGuilds(guilds, params) {
 	return guilds;
 }
 //#endregion
-export { listGuilds as i, filterDiscordGuilds as n, resolveDiscordAllowlistToken as r, buildDiscordUnresolvedResults as t };
+export { resolveDiscordAllowlistToken as n, listGuilds as r, filterDiscordGuilds as t };

package/dist/.setup/{resolve-channels-BbvsLQOZ.mjs → resolve-channels-BFPNRmVv.mjs}

@@ -1,7 +1,7 @@
-import { Ut as __exportAll } from "./discord-BXpHW-cu.mjs";
-import { o as normalizeDiscordSlug, t as isDiscordThreadChannelType } from "./channel-type-DKnjV1XW.mjs";
-import { n as DiscordApiError, r as fetchDiscord, t as DISCORD_DIRECTORY_LOOKUP_TIMEOUT_MS } from "./api-CBK9zcq5.mjs";
-import { i as listGuilds, n as filterDiscordGuilds, r as resolveDiscordAllowlistToken, t as buildDiscordUnresolvedResults } from "./resolve-allowlist-common-CwMBzbx9.mjs";
+import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
+import { o as normalizeDiscordSlug, t as isDiscordThreadChannelType } from "./channel-type-DRCrEMss.mjs";
+import { n as DiscordApiError, r as fetchDiscord, t as DISCORD_DIRECTORY_LOOKUP_TIMEOUT_MS } from "./api-DVbJwZVt.mjs";
+import { n as resolveDiscordAllowlistToken, r as listGuilds, t as filterDiscordGuilds } from "./resolve-allowlist-common-DPdRggu5.mjs";
 //#region extensions/discord/src/resolve-channels.ts
 var resolve_channels_exports = /* @__PURE__ */ __exportAll({ resolveDiscordChannelAllowlist: () => resolveDiscordChannelAllowlist });
 function parseDiscordChannelInput(raw) {
@@ -12,7 +12,7 @@ function parseDiscordChannelInput(raw) {
 	const channelPrefix = trimmed.match(/^(?:channel:|discord:)?(\d+)$/i);
 	if (channelPrefix) return { channelId: channelPrefix[1] };
 	const guildPrefix = trimmed.match(/^(?:guild:|server:)?(\d+)$/i);
-	if (guildPrefix && !trimmed.includes("/") && !trimmed.includes("#")) return {
+	if (guildPrefix) return {
 		guildId: guildPrefix[1],
 		guildOnly: true
 	};
@@ -88,9 +88,20 @@ function preferActiveMatch(candidates) {
 	scored.sort((a, b) => b.score - a.score);
 	return scored[0]?.channel ?? candidates[0];
 }
+function resolvedChannelResult(input, channel, guildName) {
+	return {
+		input,
+		resolved: true,
+		guildId: channel.guildId,
+		guildName,
+		channelId: channel.id,
+		channelName: channel.name,
+		archived: channel.archived
+	};
+}
 async function resolveDiscordChannelAllowlist(params) {
 	const token = resolveDiscordAllowlistToken(params.token);
-	if (!token) return buildDiscordUnresolvedResults(params.entries, (input) => ({
+	if (!token) return params.entries.map((input) => ({
 		input,
 		resolved: false
 	}));
@@ -146,15 +157,7 @@ async function resolveDiscordChannelAllowlist(params) {
 					continue;
 				}
 				const guild = guilds.find((entry) => entry.id === channel.guildId);
-				results.push({
-					input,
-					resolved: true,
-					guildId: channel.guildId,
-					guildName: guild?.name,
-					channelId: channel.id,
-					channelName: channel.name,
-					archived: channel.archived
-				});
+				results.push(resolvedChannelResult(input, channel, guild?.name));
 				continue;
 			}
 			if (result.status === "not-found" && parsed.guildId) {
@@ -162,15 +165,7 @@ async function resolveDiscordChannelAllowlist(params) {
 				if (guild) {
 					const match = preferActiveMatch((await getChannels(guild.id)).filter((channel) => normalizeDiscordSlug(channel.name) === normalizeDiscordSlug(channelId)));
 					if (match) {
-						results.push({
-							input,
-							resolved: true,
-							guildId: guild.id,
-							guildName: guild.name,
-							channelId: match.id,
-							channelName: match.name,
-							archived: match.archived
-						});
+						results.push(resolvedChannelResult(input, match, guild.name));
 						continue;
 					}
 				}
@@ -205,15 +200,7 @@ async function resolveDiscordChannelAllowlist(params) {
 			let matches = channels.filter((channel) => isNumericId ? channel.id === channelQuery : normalizeDiscordSlug(channel.name) === normalizedChannelQuery);
 			if (isNumericId && matches.length === 0) matches = channels.filter((channel) => normalizeDiscordSlug(channel.name) === normalizedChannelQuery);
 			const match = preferActiveMatch(matches);
-			if (match) results.push({
-				input,
-				resolved: true,
-				guildId: guild.id,
-				guildName: guild.name,
-				channelId: match.id,
-				channelName: match.name,
-				archived: match.archived
-			});
+			if (match) results.push(resolvedChannelResult(input, match, guild.name));
 			else results.push({
 				input,
 				resolved: false,
@@ -242,13 +229,7 @@ async function resolveDiscordChannelAllowlist(params) {
 		if (match) {
 			const guild = guilds.find((entry) => entry.id === match.guildId);
 			results.push({
-				input,
-				resolved: true,
-				guildId: match.guildId,
-				guildName: guild?.name,
-				channelId: match.id,
-				channelName: match.name,
-				archived: match.archived,
+				...resolvedChannelResult(input, match, guild?.name),
 				note: candidates.length > 1 && guild?.name ? `matched multiple; chose ${guild.name}` : void 0
 			});
 			continue;

package/dist/.setup/{resolve-users-ByFlR7LQ.mjs → resolve-users-0-aBuCy3.mjs}

@@ -1,6 +1,6 @@
-import { Ut as __exportAll } from "./discord-BXpHW-cu.mjs";
-import { r as fetchDiscord, t as DISCORD_DIRECTORY_LOOKUP_TIMEOUT_MS } from "./api-CBK9zcq5.mjs";
-import { i as listGuilds, n as filterDiscordGuilds, r as resolveDiscordAllowlistToken, t as buildDiscordUnresolvedResults } from "./resolve-allowlist-common-CwMBzbx9.mjs";
+import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
+import { r as fetchDiscord, t as DISCORD_DIRECTORY_LOOKUP_TIMEOUT_MS } from "./api-DVbJwZVt.mjs";
+import { n as resolveDiscordAllowlistToken, r as listGuilds, t as filterDiscordGuilds } from "./resolve-allowlist-common-DPdRggu5.mjs";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/discord/src/resolve-users.ts
 var resolve_users_exports = /* @__PURE__ */ __exportAll({ resolveDiscordUserAllowlist: () => resolveDiscordUserAllowlist });
@@ -45,7 +45,7 @@ function scoreDiscordMember(member, query) {
 }
 async function resolveDiscordUserAllowlist(params) {
 	const token = resolveDiscordAllowlistToken(params.token);
-	if (!token) return buildDiscordUnresolvedResults(params.entries, (input) => ({
+	if (!token) return params.entries.map((input) => ({
 		input,
 		resolved: false
 	}));

package/dist/.setup/{retry-BEYkDy0P.mjs → retry-pz_cSha2.mjs}

@@ -1,6 +1,6 @@
-import { v as RateLimitError } from "./discord-BXpHW-cu.mjs";
-import { parseStrictNonNegativeInteger, resolveIntegerOption } from "openclaw/plugin-sdk/number-runtime";
+import { v as RateLimitError } from "./discord-0xJYfdDD.mjs";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
+import { parseStrictNonNegativeInteger, resolveIntegerOption } from "openclaw/plugin-sdk/number-runtime";
 import { collectErrorGraphCandidates, extractErrorCode, formatErrorMessage, readErrorName } from "openclaw/plugin-sdk/error-runtime";
 import { classifyTransientNetworkErrorCode, createChannelApiRetryRunner, resolveRetryConfig, retryAsync } from "openclaw/plugin-sdk/retry-runtime";
 import { buildMessagingTarget, parseMentionPrefixOrAtUserTarget, requireTargetKind } from "openclaw/plugin-sdk/channel-targets";
@@ -692,4 +692,4 @@ function createDiscordRetryRunner(params) {
 	};
 }
 //#endregion
-export { normalizeDiscordMessagingTarget as _, recordDiscordMessageCreateAmbiguity as a, resolveDiscordChannelId as b, createDiscordSendReceiptFromResults as c, createReusableDiscordReplyReference as d, resolveDiscordReplyMessageId as f, matchesDiscordToolContextTarget as g, looksLikeDiscordTargetId as h, hasDiscordMessageCreateAmbiguity as i, createDiscordSendResult as l, allowFromContainsDiscordUserId as m, classifyDiscordDeliveryFailure as n, chunkDiscordTextWithMode as o, resolveDiscordReplyReference as p, createDiscordRetryRunner as r, createDiscordSendReceipt as s, canFallbackDiscordWebhookSend as t, toDiscordOutboundDeliveryResult as u, normalizeDiscordOutboundTarget as v, parseDiscordTarget as y };
+export { matchesDiscordToolContextTarget as _, recordDiscordMessageCreateAmbiguity as a, parseDiscordTarget as b, createDiscordSendReceipt as c, toDiscordOutboundDeliveryResult as d, createReusableDiscordReplyReference as f, looksLikeDiscordTargetId as g, allowFromContainsDiscordUserId as h, hasDiscordMessageCreateAmbiguity as i, createDiscordSendReceiptFromResults as l, resolveDiscordReplyReference as m, classifyDiscordDeliveryFailure as n, chunkDiscordTextWithMode as o, resolveDiscordReplyMessageId as p, createDiscordRetryRunner as r, findGraphemeChunkEnd as s, canFallbackDiscordWebhookSend as t, createDiscordSendResult as u, normalizeDiscordMessagingTarget as v, resolveDiscordChannelId as x, normalizeDiscordOutboundTarget as y };

package/dist/.setup/rolldown-runtime-B4FMCO8f.mjs

@@ -0,0 +1,28 @@
+import "node:module";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+//#endregion
+export { __reExport as n, __exportAll as t };