@openclaw/discord 2026.5.7 → 2026.5.9-beta.1

package/dist/{manager.runtime-Cug1PoeZ.js → manager.runtime-C_cPd048.js}

@@ -1,21 +1,23 @@
 import { c as resolveDiscordAccountAllowFrom } from "./accounts-CaHGiVB4.js";
-import { c as ResumedListener, s as ReadyListener, t as discord_exports } from "./discord-eZlimVfW.js";
-import { n as formatDiscordUserTag } from "./format-D8TsaXxW.js";
-import { a as normalizeDiscordSlug, m as resolveDiscordOwnerAccess } from "./allow-list-ek-1hMKN.js";
-import { t as formatMention } from "./mentions-BPZUaFk7.js";
-import { t as getDiscordRuntime } from "./runtime-K9RT6Egn.js";
-import { t as buildDiscordGroupSystemPrompt } from "./inbound-context-CRylwjg0.js";
-import { n as resolveDiscordVoiceEnabled, t as authorizeDiscordVoiceIngress } from "./access-CHY9FK3X.js";
+import { t as parseDiscordTarget } from "./target-parsing-D-H7nnh2.js";
+import { c as ResumedListener, s as ReadyListener, t as discord_exports } from "./discord-Du6FnKAq.js";
+import { n as formatDiscordUserTag } from "./format-XDPCvGK4.js";
+import { a as normalizeDiscordSlug, m as resolveDiscordOwnerAccess } from "./allow-list-Dtho5Hww.js";
+import { t as formatMention } from "./mentions-CiPUID82.js";
+import { t as getDiscordRuntime } from "./runtime-EoVRXYxX.js";
+import { t as buildDiscordGroupSystemPrompt } from "./inbound-context-BobVUBqo.js";
+import { n as resolveDiscordVoiceEnabled, t as authorizeDiscordVoiceIngress } from "./access-Lk7H_e7y.js";
 import { createRequire } from "node:module";
-import { normalizeOptionalString, stripInlineDirectiveTagsForDisplay } from "openclaw/plugin-sdk/text-runtime";
+import { escapeRegExp, normalizeOptionalString, stripInlineDirectiveTagsForDisplay } from "openclaw/plugin-sdk/text-runtime";
 import { resolveAgentRoute } from "openclaw/plugin-sdk/routing";
-import { randomUUID } from "node:crypto";
-import fs from "node:fs/promises";
 import path from "node:path";
 import { createSubsystemLogger, logVerbose, shouldLogVerbose } from "openclaw/plugin-sdk/runtime-env";
-import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/temp-path";
+import fs from "node:fs/promises";
+import { resolvePreferredOpenClawTmpDir, tempWorkspace } from "openclaw/plugin-sdk/temp-path";
 import { formatErrorMessage } from "openclaw/plugin-sdk/ssrf-runtime";
 import { agentCommandFromIngress, getTtsProvider, resolveAgentDir, resolveTtsConfig, resolveTtsPrefsPath } from "openclaw/plugin-sdk/agent-runtime";
+import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, REALTIME_VOICE_AUDIO_FORMAT_PCM16_24KHZ, buildRealtimeVoiceAgentConsultChatMessage, buildRealtimeVoiceAgentConsultPolicyInstructions, buildRealtimeVoiceAgentConsultWorkingResponse, createRealtimeVoiceAgentTalkbackQueue, createRealtimeVoiceBridgeSession, resamplePcm, resolveConfiguredRealtimeVoiceProvider, resolveRealtimeVoiceAgentConsultToolPolicy, resolveRealtimeVoiceAgentConsultTools, resolveRealtimeVoiceAgentConsultToolsAllow } from "openclaw/plugin-sdk/realtime-voice";
+import { PassThrough, Readable } from "node:stream";
 import { parseTtsDirectives } from "openclaw/plugin-sdk/speech";
 //#region extensions/discord/src/voice/audio.ts
 const require = createRequire(import.meta.url);
@@ -98,17 +100,58 @@ async function decodeOpusStream(stream, params) {
 	}
 	return chunks.length > 0 ? Buffer.concat(chunks) : Buffer.alloc(0);
 }
+async function decodeOpusStreamChunks(stream, params) {
+	const selected = createOpusDecoder({ onWarn: params.onWarn });
+	if (!selected) return;
+	params.onVerbose(`opus decoder: ${selected.name}`);
+	try {
+		for await (const chunk of stream) {
+			if (!chunk || !(chunk instanceof Buffer) || chunk.length === 0) continue;
+			const decoded = selected.decoder.decode(chunk);
+			if (decoded && decoded.length > 0) params.onChunk(Buffer.from(decoded));
+		}
+	} catch (err) {
+		if (shouldLogVerbose()) logVerbose(`discord voice: opus decode failed: ${formatErrorMessage(err)}`);
+	}
+}
+function convertDiscordPcm48kStereoToRealtimePcm24kMono(pcm) {
+	const frameCount = Math.floor(pcm.length / 4);
+	if (frameCount === 0) return Buffer.alloc(0);
+	const mono48k = Buffer.alloc(frameCount * 2);
+	for (let frame = 0; frame < frameCount; frame += 1) {
+		const offset = frame * 4;
+		const left = pcm.readInt16LE(offset);
+		const right = pcm.readInt16LE(offset + 2);
+		mono48k.writeInt16LE(Math.round((left + right) / 2), frame * 2);
+	}
+	return resamplePcm(mono48k, SAMPLE_RATE, 24e3);
+}
+function convertRealtimePcm24kMonoToDiscordPcm48kStereo(pcm) {
+	const mono48k = resamplePcm(pcm, 24e3, SAMPLE_RATE);
+	const sampleCount = Math.floor(mono48k.length / 2);
+	if (sampleCount === 0) return Buffer.alloc(0);
+	const stereo = Buffer.alloc(sampleCount * 4);
+	for (let sampleIndex = 0; sampleIndex < sampleCount; sampleIndex += 1) {
+		const sample = mono48k.readInt16LE(sampleIndex * 2);
+		const offset = sampleIndex * 4;
+		stereo.writeInt16LE(sample, offset);
+		stereo.writeInt16LE(sample, offset + 2);
+	}
+	return stereo;
+}
 function estimateDurationSeconds(pcm) {
 	const bytesPerSample = BIT_DEPTH / 8 * CHANNELS;
 	if (bytesPerSample <= 0) return 0;
 	return pcm.length / (bytesPerSample * SAMPLE_RATE);
 }
 async function writeVoiceWavFile(pcm) {
-	const tempDir = await fs.mkdtemp(path.join(resolvePreferredOpenClawTmpDir(), "discord-voice-"));
-	const filePath = path.join(tempDir, `segment-${randomUUID()}.wav`);
+	const workspace = await tempWorkspace({
+		rootDir: resolvePreferredOpenClawTmpDir(),
+		prefix: "discord-voice-"
+	});
 	const wav = buildWavBuffer(pcm);
-	await fs.writeFile(filePath, wav);
-	scheduleTempCleanup(tempDir);
+	const filePath = await workspace.write("segment.wav", wav);
+	scheduleTempCleanup(workspace.dir);
 	return {
 		path: filePath,
 		durationSeconds: estimateDurationSeconds(pcm)
@@ -193,6 +236,447 @@ function scheduleVoiceCaptureFinalize(params) {
 	});
 	return true;
 }
+async function resolveDiscordVoiceIngressContext(params) {
+	const { entry, userId } = params;
+	if (!entry.guildName) entry.guildName = await params.fetchGuildName(entry.guildId);
+	const speaker = await params.speakerContext.resolveContext(entry.guildId, userId);
+	const speakerIdentity = await params.speakerContext.resolveIdentity(entry.guildId, userId);
+	const access = await authorizeDiscordVoiceIngress({
+		cfg: params.cfg,
+		discordConfig: params.discordConfig,
+		guildName: entry.guildName,
+		guildId: entry.guildId,
+		channelId: entry.channelId,
+		channelName: entry.channelName,
+		channelSlug: entry.channelName ? normalizeDiscordSlug(entry.channelName) : "",
+		channelLabel: formatMention({ channelId: entry.channelId }),
+		memberRoleIds: speakerIdentity.memberRoleIds,
+		ownerAllowFrom: params.ownerAllowFrom,
+		sender: {
+			id: speakerIdentity.id,
+			name: speakerIdentity.name,
+			tag: speakerIdentity.tag
+		}
+	});
+	if (!access.ok) return null;
+	return {
+		extraSystemPrompt: buildDiscordGroupSystemPrompt(access.channelConfig),
+		senderIsOwner: speaker.senderIsOwner,
+		speakerLabel: speaker.label
+	};
+}
+async function runDiscordVoiceAgentTurn(params) {
+	const context = params.context ?? await resolveDiscordVoiceIngressContext({
+		entry: params.entry,
+		userId: params.userId,
+		cfg: params.cfg,
+		discordConfig: params.discordConfig,
+		ownerAllowFrom: params.ownerAllowFrom,
+		fetchGuildName: params.fetchGuildName,
+		speakerContext: params.speakerContext
+	});
+	if (!context) return null;
+	const voiceModel = normalizeOptionalString(params.discordConfig.voice?.model);
+	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()
+	};
+}
+//#endregion
+//#region extensions/discord/src/voice/prompt.ts
+const DISCORD_VOICE_SPOKEN_OUTPUT_CONTRACT = [
+	"You are OpenClaw's Discord voice interface in a live voice channel.",
+	"Discord voice reply requirements:",
+	"- Return only the concise text that should be spoken aloud in the voice channel.",
+	"- Treat the transcript as speech-to-text from a live conversation; repair obvious transcription artifacts and ignore repeated partial fragments caused by voice buffering.",
+	"- If the transcript is garbled, incomplete, or missing the user's intent, ask one brief clarifying question instead of guessing.",
+	"- If the request needs deeper reasoning, current information, or tools, use the available tools before answering.",
+	"- Do not call the tts tool; Discord voice will synthesize and play the returned text.",
+	"- Do not reply with NO_REPLY unless no spoken response is appropriate.",
+	"- Keep the response brief, natural, and conversational. Prefer one to three short sentences.",
+	"- Avoid markdown tables, code fences, citations, and visual formatting unless the user explicitly asks for something that cannot be spoken naturally."
+].join("\n");
+function formatVoiceIngressPrompt(transcript, speakerLabel) {
+	const cleanedTranscript = transcript.trim();
+	const cleanedLabel = speakerLabel?.trim();
+	return [DISCORD_VOICE_SPOKEN_OUTPUT_CONTRACT, cleanedLabel ? [`Voice transcript from speaker "${cleanedLabel}":`, cleanedTranscript].join("\n") : cleanedTranscript].join("\n\n");
+}
+//#endregion
+//#region extensions/discord/src/voice/sdk-runtime.ts
+let cachedDiscordVoiceSdk = null;
+function loadDiscordVoiceSdk() {
+	if (cachedDiscordVoiceSdk) return cachedDiscordVoiceSdk;
+	cachedDiscordVoiceSdk = createRequire(import.meta.url)("@discordjs/voice");
+	return cachedDiscordVoiceSdk;
+}
+const CAPTURE_FINALIZE_GRACE_MS = 2500;
+const VOICE_CONNECT_READY_TIMEOUT_MS = 3e4;
+const VOICE_RECONNECT_GRACE_MS = 15e3;
+const PLAYBACK_READY_TIMEOUT_MS = 6e4;
+const SPEAKING_READY_TIMEOUT_MS = 6e4;
+function resolveVoiceTimeoutMs(value, fallbackMs) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return fallbackMs;
+	return Math.floor(value);
+}
+function logVoiceVerbose(message) {
+	logVerbose(`discord voice: ${message}`);
+}
+function isVoiceChannel(type) {
+	return type === discord_exports.ChannelType.GuildVoice || type === discord_exports.ChannelType.GuildStageVoice;
+}
+//#endregion
+//#region extensions/discord/src/voice/realtime.ts
+const logger$2 = createSubsystemLogger("discord/voice");
+const DISCORD_REALTIME_TALKBACK_DEBOUNCE_MS = 350;
+const DISCORD_REALTIME_FALLBACK_TEXT = "I hit an error while checking that. Please try again.";
+const DISCORD_REALTIME_PENDING_SPEAKER_CONTEXT_LIMIT = 32;
+const DISCORD_REALTIME_LOG_PREVIEW_CHARS = 500;
+const DISCORD_REALTIME_DEFAULT_MIN_BARGE_IN_AUDIO_END_MS = 250;
+function formatRealtimeLogPreview(text) {
+	const oneLine = text.replace(/\s+/g, " ").trim();
+	if (oneLine.length <= DISCORD_REALTIME_LOG_PREVIEW_CHARS) return oneLine;
+	return `${oneLine.slice(0, DISCORD_REALTIME_LOG_PREVIEW_CHARS)}...`;
+}
+function formatRealtimeInterruptionLog(event) {
+	const detail = event.detail ? ` ${event.detail}` : "";
+	if (event.direction === "client") {
+		if (event.type === "response.cancel") return `discord voice: realtime model interrupt requested ${event.direction}:${event.type}${detail}`;
+		if (event.type === "conversation.item.truncate.skipped") return `discord voice: realtime model interrupt ignored ${event.direction}:${event.type}${detail}`;
+		if (event.type === "conversation.item.truncate") return `discord voice: realtime model audio truncated ${event.direction}:${event.type}${detail}`;
+	}
+	if (event.direction === "server") {
+		if (event.type === "response.cancelled") return `discord voice: realtime model interrupt confirmed ${event.direction}:${event.type}${detail}`;
+		if (event.type === "response.done" && event.detail?.includes("status=cancelled")) return `discord voice: realtime model interrupt confirmed ${event.direction}:${event.type}${detail}`;
+		if (event.type === "error" && event.detail === "Cancellation failed: no active response found") return `discord voice: realtime model interrupt raced ${event.direction}:${event.type}${detail}`;
+	}
+}
+function readProviderConfigString(config, key) {
+	const value = config[key];
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readProviderConfigBoolean(config, key) {
+	const value = config?.[key];
+	return typeof value === "boolean" ? value : void 0;
+}
+function resolveDiscordVoiceMode(voice) {
+	const mode = voice?.mode;
+	if (mode === "stt-tts" || mode === "bidi") return mode;
+	return "agent-proxy";
+}
+function isDiscordRealtimeVoiceMode(mode) {
+	return mode === "agent-proxy" || mode === "bidi";
+}
+function isDiscordAgentProxyVoiceMode(mode) {
+	return mode === "agent-proxy";
+}
+function resolveDiscordRealtimeInterruptResponseOnInputAudio(params) {
+	const providerConfig = params.realtimeConfig?.providers?.[params.providerId];
+	return readProviderConfigBoolean(providerConfig, "interruptResponseOnInputAudio") ?? true;
+}
+function resolveDiscordRealtimeBargeIn(params) {
+	const configured = params.realtimeConfig?.bargeIn;
+	if (typeof configured === "boolean") return configured;
+	return resolveDiscordRealtimeInterruptResponseOnInputAudio(params);
+}
+function buildDiscordSpeakExactUserMessage(text) {
+	return ["Speak this exact OpenClaw answer to the Discord voice channel, without adding, removing, or rephrasing words.", `Answer: ${JSON.stringify(text)}`].join("\n");
+}
+var DiscordRealtimeVoiceSession = class {
+	constructor(params) {
+		this.params = params;
+		this.bridge = null;
+		this.outputStream = null;
+		this.stopped = false;
+		this.consultToolPolicy = "safe-read-only";
+		this.pendingSpeakerTurns = [];
+		this.playerIdleHandler = () => {
+			this.resetOutputStream();
+		};
+		this.talkback = createRealtimeVoiceAgentTalkbackQueue({
+			debounceMs: this.realtimeConfig?.debounceMs ?? DISCORD_REALTIME_TALKBACK_DEBOUNCE_MS,
+			isStopped: () => this.stopped,
+			logger: logger$2,
+			logPrefix: "[discord] realtime agent",
+			responseStyle: "Brief, natural spoken answer for a Discord voice channel.",
+			fallbackText: DISCORD_REALTIME_FALLBACK_TEXT,
+			consult: async ({ question, responseStyle, metadata }) => {
+				const context = isDiscordRealtimeSpeakerContext(metadata) ? metadata : void 0;
+				return { text: await this.runAgentTurn({
+					context,
+					message: formatVoiceIngressPrompt([question, responseStyle ? `Spoken style: ${responseStyle}` : void 0].filter(Boolean).join("\n\n"), context?.speakerLabel ?? "Discord voice speaker")
+				}) };
+			},
+			deliver: (text) => this.bridge?.sendUserMessage(buildDiscordSpeakExactUserMessage(text))
+		});
+	}
+	async connect() {
+		const resolved = resolveConfiguredRealtimeVoiceProvider({
+			configuredProviderId: this.realtimeConfig?.provider,
+			providerConfigs: buildProviderConfigs(this.realtimeConfig),
+			providerConfigOverrides: buildProviderConfigOverrides(this.realtimeConfig),
+			cfg: this.params.cfg,
+			defaultModel: this.realtimeConfig?.model,
+			noRegisteredProviderMessage: "No configured realtime voice provider registered"
+		});
+		const toolPolicy = resolveRealtimeVoiceAgentConsultToolPolicy(this.realtimeConfig?.toolPolicy, "safe-read-only");
+		this.consultToolPolicy = toolPolicy;
+		this.consultToolsAllow = resolveRealtimeVoiceAgentConsultToolsAllow(toolPolicy);
+		const consultPolicy = this.realtimeConfig?.consultPolicy ?? "auto";
+		const interruptResponseOnInputAudio = resolveDiscordRealtimeInterruptResponseOnInputAudio({
+			realtimeConfig: this.realtimeConfig,
+			providerId: resolved.provider.id
+		});
+		const instructions = buildDiscordRealtimeInstructions({
+			mode: this.params.mode,
+			instructions: this.realtimeConfig?.instructions,
+			toolPolicy,
+			consultPolicy
+		});
+		this.bridge = createRealtimeVoiceBridgeSession({
+			provider: resolved.provider,
+			providerConfig: resolved.providerConfig,
+			audioFormat: REALTIME_VOICE_AUDIO_FORMAT_PCM16_24KHZ,
+			instructions,
+			autoRespondToAudio: this.params.mode === "bidi",
+			interruptResponseOnInputAudio,
+			markStrategy: "ack-immediately",
+			tools: this.params.mode === "bidi" ? resolveRealtimeVoiceAgentConsultTools(toolPolicy) : [],
+			audioSink: {
+				isOpen: () => !this.stopped,
+				sendAudio: (audio) => this.sendOutputAudio(audio),
+				clearAudio: () => this.clearOutputAudio()
+			},
+			onTranscript: (role, text, isFinal) => {
+				if (isFinal && text.trim()) logger$2.info(`discord voice: realtime ${role} transcript (${text.length} chars): ${formatRealtimeLogPreview(text)}`);
+				if (!isFinal || role !== "user" || !isDiscordAgentProxyVoiceMode(this.params.mode)) return;
+				this.talkback.enqueue(text, this.consumePendingSpeakerContext());
+			},
+			onToolCall: (event, session) => this.handleToolCall(event, session),
+			onEvent: (event) => {
+				const detail = event.detail ? ` ${event.detail}` : "";
+				logVoiceVerbose(`realtime ${event.direction}:${event.type}${detail}`);
+				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}`)
+		});
+		const resolvedModel = readProviderConfigString(resolved.providerConfig, "model") ?? resolved.provider.defaultModel;
+		const resolvedVoice = readProviderConfigString(resolved.providerConfig, "voice");
+		logger$2.info(`discord voice: realtime bridge starting mode=${this.params.mode} provider=${resolved.provider.id} model=${resolvedModel ?? "default"} voice=${resolvedVoice ?? "default"} consultPolicy=${consultPolicy} toolPolicy=${toolPolicy} autoRespond=${this.params.mode === "bidi"} interruptResponse=${interruptResponseOnInputAudio} bargeIn=${resolveDiscordRealtimeBargeIn({
+			realtimeConfig: this.realtimeConfig,
+			providerId: resolved.provider.id
+		})} minBargeInAudioEndMs=${resolveDiscordRealtimeMinBargeInAudioEndMs(this.realtimeConfig)}`);
+		const voiceSdk = loadDiscordVoiceSdk();
+		this.params.entry.player.on(voiceSdk.AudioPlayerStatus.Idle, this.playerIdleHandler);
+		await this.bridge.connect();
+		logger$2.info(`discord voice: realtime bridge ready mode=${this.params.mode} provider=${resolved.provider.id} model=${resolvedModel ?? "default"} voice=${resolvedVoice ?? "default"}`);
+	}
+	close() {
+		this.stopped = true;
+		this.talkback.close();
+		this.pendingSpeakerTurns.length = 0;
+		this.clearOutputAudio();
+		this.bridge?.close();
+		this.bridge = null;
+		const voiceSdk = loadDiscordVoiceSdk();
+		this.params.entry.player.off(voiceSdk.AudioPlayerStatus.Idle, this.playerIdleHandler);
+	}
+	beginSpeakerTurn(context, userId) {
+		const turn = {
+			context: {
+				...context,
+				userId
+			},
+			hasAudio: false,
+			interruptedPlayback: false,
+			closed: false
+		};
+		this.pendingSpeakerTurns.push(turn);
+		this.prunePendingSpeakerTurns();
+		return {
+			sendInputAudio: (discordPcm48kStereo) => this.sendInputAudioForTurn(turn, discordPcm48kStereo),
+			close: () => {
+				turn.closed = true;
+				this.prunePendingSpeakerTurns();
+			}
+		};
+	}
+	sendInputAudioForTurn(turn, discordPcm48kStereo) {
+		if (!this.bridge || this.stopped) return;
+		turn.hasAudio = true;
+		const realtimePcm = convertDiscordPcm48kStereoToRealtimePcm24kMono(discordPcm48kStereo);
+		if (realtimePcm.length > 0) {
+			if (!turn.interruptedPlayback && this.isBargeInEnabled()) {
+				turn.interruptedPlayback = true;
+				logVoiceVerbose(`realtime barge-in from active speaker audio: guild ${this.params.entry.guildId} channel ${this.params.entry.channelId} user ${turn.context.userId}`);
+				this.handleBargeIn();
+			}
+			this.bridge.sendAudio(realtimePcm);
+		}
+	}
+	handleBargeIn() {
+		if (!this.isBargeInEnabled()) return;
+		this.bridge?.handleBargeIn({ audioPlaybackActive: true });
+	}
+	isBargeInEnabled() {
+		const providerId = this.realtimeConfig?.provider ?? "openai";
+		return resolveDiscordRealtimeBargeIn({
+			realtimeConfig: this.realtimeConfig,
+			providerId
+		});
+	}
+	get realtimeConfig() {
+		return this.params.discordConfig.voice?.realtime;
+	}
+	sendOutputAudio(realtimePcm24kMono) {
+		const discordPcm = convertRealtimePcm24kMonoToDiscordPcm48kStereo(realtimePcm24kMono);
+		if (discordPcm.length === 0) return;
+		this.ensureOutputStream().write(discordPcm);
+	}
+	ensureOutputStream() {
+		if (this.outputStream && !this.outputStream.destroyed) return this.outputStream;
+		const voiceSdk = loadDiscordVoiceSdk();
+		const stream = new PassThrough();
+		this.outputStream = stream;
+		stream.once("close", () => {
+			if (this.outputStream === stream) this.outputStream = null;
+		});
+		const resource = voiceSdk.createAudioResource(stream, { inputType: voiceSdk.StreamType.Raw });
+		this.params.entry.player.play(resource);
+		const realtimeConfig = this.realtimeConfig;
+		logger$2.info(`discord voice: realtime audio playback started guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} mode=${this.params.mode} model=${realtimeConfig?.model ?? "provider-default"} voice=${realtimeConfig?.voice ?? "provider-default"}`);
+		return stream;
+	}
+	clearOutputAudio() {
+		this.resetOutputStream();
+		this.params.entry.player.stop(true);
+	}
+	resetOutputStream() {
+		const stream = this.outputStream;
+		this.outputStream = null;
+		stream?.end();
+		stream?.destroy();
+	}
+	handleToolCall(event, session) {
+		const callId = event.callId || event.itemId;
+		if (this.params.mode !== "bidi") {
+			session.submitToolResult(callId, { error: `Tool "${event.name}" is only available in bidi Discord voice mode` });
+			return;
+		}
+		if (event.name !== REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME) {
+			session.submitToolResult(callId, { error: `Tool "${event.name}" not available` });
+			return;
+		}
+		if (this.consultToolPolicy === "none") {
+			session.submitToolResult(callId, { error: `Tool "${event.name}" not available` });
+			return;
+		}
+		const consultMessage = buildRealtimeVoiceAgentConsultChatMessage(event.args);
+		logger$2.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=${formatRealtimeLogPreview(consultMessage)}`);
+		if (session.bridge.supportsToolResultContinuation) session.submitToolResult(callId, buildRealtimeVoiceAgentConsultWorkingResponse("speaker"), { willContinue: true });
+		const context = this.consumePendingSpeakerContext();
+		if (!context) {
+			logger$2.warn(`discord voice: realtime consult has no speaker context call=${callId || "unknown"}`);
+			session.submitToolResult(callId, { error: "No Discord speaker context available" });
+			return;
+		}
+		this.runAgentTurn({
+			context,
+			message: consultMessage
+		}).then((text) => {
+			logger$2.info(`discord voice: realtime consult answer (${text.length} chars) voiceSession=${this.params.entry.voiceSessionKey} supervisorSession=${this.params.entry.route.sessionKey} agent=${this.params.entry.route.agentId} speaker=${context.speakerLabel} owner=${context.senderIsOwner}: ${formatRealtimeLogPreview(text)}`);
+			session.submitToolResult(callId, { text });
+		}).catch((error) => {
+			logger$2.warn(`discord voice: realtime consult failed call=${callId || "unknown"}: ${formatErrorMessage(error)}`);
+			session.submitToolResult(callId, { error: formatErrorMessage(error) });
+		});
+	}
+	async runAgentTurn(params) {
+		const context = params.context;
+		if (!context) return "";
+		return this.params.runAgentTurn({
+			context,
+			message: params.message,
+			toolsAllow: this.params.mode === "bidi" ? this.consultToolsAllow : void 0,
+			userId: context.userId
+		});
+	}
+	consumePendingSpeakerContext() {
+		this.prunePendingSpeakerTurns();
+		this.expireClosedSpeakerTurnsBeforeLaterAudio();
+		const index = this.pendingSpeakerTurns.findIndex((turn) => turn.hasAudio);
+		if (index < 0) return;
+		const [turn] = this.pendingSpeakerTurns.splice(index, 1);
+		this.prunePendingSpeakerTurns();
+		return turn?.context;
+	}
+	prunePendingSpeakerTurns() {
+		for (let index = this.pendingSpeakerTurns.length - 1; index >= 0; index -= 1) {
+			const turn = this.pendingSpeakerTurns[index];
+			if (turn?.closed && !turn.hasAudio) this.pendingSpeakerTurns.splice(index, 1);
+		}
+		while (this.pendingSpeakerTurns.length > DISCORD_REALTIME_PENDING_SPEAKER_CONTEXT_LIMIT) {
+			const completedIndex = this.pendingSpeakerTurns.findIndex((turn) => turn.closed);
+			this.pendingSpeakerTurns.splice(Math.max(completedIndex, 0), 1);
+		}
+	}
+	expireClosedSpeakerTurnsBeforeLaterAudio() {
+		let hasLaterAudio = false;
+		for (let index = this.pendingSpeakerTurns.length - 1; index >= 0; index -= 1) {
+			const turn = this.pendingSpeakerTurns[index];
+			if (!turn?.hasAudio) continue;
+			if (turn.closed && hasLaterAudio) {
+				this.pendingSpeakerTurns.splice(index, 1);
+				continue;
+			}
+			hasLaterAudio = true;
+		}
+	}
+};
+function isDiscordRealtimeSpeakerContext(value) {
+	return Boolean(value) && typeof value === "object" && typeof value.userId === "string" && typeof value.senderIsOwner === "boolean" && typeof value.speakerLabel === "string";
+}
+function buildProviderConfigs(realtimeConfig) {
+	const configs = realtimeConfig?.providers;
+	return configs && Object.keys(configs).length > 0 ? { ...configs } : void 0;
+}
+function buildProviderConfigOverrides(realtimeConfig) {
+	const overrides = {
+		...realtimeConfig?.model ? { model: realtimeConfig.model } : {},
+		...realtimeConfig?.voice ? { voice: realtimeConfig.voice } : {},
+		...typeof realtimeConfig?.minBargeInAudioEndMs === "number" ? { minBargeInAudioEndMs: realtimeConfig.minBargeInAudioEndMs } : {}
+	};
+	return Object.keys(overrides).length > 0 ? overrides : void 0;
+}
+function resolveDiscordRealtimeMinBargeInAudioEndMs(realtimeConfig) {
+	return typeof realtimeConfig?.minBargeInAudioEndMs === "number" ? realtimeConfig.minBargeInAudioEndMs : DISCORD_REALTIME_DEFAULT_MIN_BARGE_IN_AUDIO_END_MS;
+}
+function buildDiscordRealtimeInstructions(params) {
+	const base = params.instructions ?? ["You are OpenClaw's Discord voice interface.", "Keep spoken replies concise, natural, and suitable for a live Discord voice channel."].join("\n");
+	if (isDiscordAgentProxyVoiceMode(params.mode)) return [
+		base,
+		"Mode: OpenClaw agent proxy.",
+		"Use audio input only to transcribe the speaker. Do not answer user speech by yourself.",
+		"When OpenClaw sends an exact answer to speak, say only that answer."
+	].join("\n\n");
+	return [base, buildRealtimeVoiceAgentConsultPolicyInstructions({
+		toolPolicy: params.toolPolicy,
+		consultPolicy: params.consultPolicy
+	})].filter(Boolean).join("\n\n");
+}
 //#endregion
 //#region extensions/discord/src/voice/receive-recovery.ts
 const DECRYPT_FAILURE_WINDOW_MS = 3e4;
@@ -261,53 +745,8 @@ function enableDaveReceivePassthrough(params) {
 	}
 }
 //#endregion
-//#region extensions/discord/src/voice/sdk-runtime.ts
-let cachedDiscordVoiceSdk = null;
-function loadDiscordVoiceSdk() {
-	if (cachedDiscordVoiceSdk) return cachedDiscordVoiceSdk;
-	cachedDiscordVoiceSdk = createRequire(import.meta.url)("@discordjs/voice");
-	return cachedDiscordVoiceSdk;
-}
-//#endregion
-//#region extensions/discord/src/voice/prompt.ts
-const DISCORD_VOICE_SPOKEN_OUTPUT_CONTRACT = [
-	"You are OpenClaw's Discord voice interface in a live voice channel.",
-	"Discord voice reply requirements:",
-	"- Return only the concise text that should be spoken aloud in the voice channel.",
-	"- Treat the transcript as speech-to-text from a live conversation; repair obvious transcription artifacts and ignore repeated partial fragments caused by voice buffering.",
-	"- If the transcript is garbled, incomplete, or missing the user's intent, ask one brief clarifying question instead of guessing.",
-	"- If the request needs deeper reasoning, current information, or tools, use the available tools before answering.",
-	"- Do not call the tts tool; Discord voice will synthesize and play the returned text.",
-	"- Do not reply with NO_REPLY unless no spoken response is appropriate.",
-	"- Keep the response brief, natural, and conversational. Prefer one to three short sentences.",
-	"- Avoid markdown tables, code fences, citations, and visual formatting unless the user explicitly asks for something that cannot be spoken naturally."
-].join("\n");
-function formatVoiceIngressPrompt(transcript, speakerLabel) {
-	const cleanedTranscript = transcript.trim();
-	const cleanedLabel = speakerLabel?.trim();
-	return [DISCORD_VOICE_SPOKEN_OUTPUT_CONTRACT, cleanedLabel ? [`Voice transcript from speaker "${cleanedLabel}":`, cleanedTranscript].join("\n") : cleanedTranscript].join("\n\n");
-}
-const CAPTURE_FINALIZE_GRACE_MS = 2500;
-const VOICE_CONNECT_READY_TIMEOUT_MS = 3e4;
-const VOICE_RECONNECT_GRACE_MS = 15e3;
-const PLAYBACK_READY_TIMEOUT_MS = 6e4;
-const SPEAKING_READY_TIMEOUT_MS = 6e4;
-function resolveVoiceTimeoutMs(value, fallbackMs) {
-	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return fallbackMs;
-	return Math.floor(value);
-}
-function logVoiceVerbose(message) {
-	logVerbose(`discord voice: ${message}`);
-}
-function isVoiceChannel(type) {
-	return type === discord_exports.ChannelType.GuildVoice || type === discord_exports.ChannelType.GuildStageVoice;
-}
-//#endregion
 //#region extensions/discord/src/voice/sanitize.ts
 const SPEECH_EMOJI_RE = /(?:\p{Extended_Pictographic}(?:\uFE0F|\u200D|\p{Extended_Pictographic}|\p{Emoji_Modifier})*)+/gu;
-function escapeRegExp(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function stripEmojiForSpeech(text) {
 	return text.replace(SPEECH_EMOJI_RE, " ").replace(/\s+([?!.,:;])/g, "$1").replace(/[ \t]{2,}/g, " ").replace(/ *\n */g, "\n").trim();
 }
@@ -384,7 +823,22 @@ async function synthesizeVoiceReplyAudio(params) {
 	});
 	const speakText = sanitizeVoiceReplyTextForSpeech(directive.overrides.ttsText ?? directive.cleanedText.trim(), params.speakerLabel);
 	if (!speakText) return { status: "empty" };
-	const result = await getDiscordRuntime().tts.textToSpeech({
+	const runtime = getDiscordRuntime();
+	const streamResult = await runtime.tts.textToSpeechStream?.({
+		text: speakText,
+		cfg: ttsCfg,
+		channel: "discord",
+		overrides: directive.overrides,
+		disableFallback: true
+	});
+	if (streamResult?.success && streamResult.audioStream) return {
+		status: "ok",
+		mode: "stream",
+		audioStream: streamResult.audioStream,
+		release: streamResult.release,
+		speakText
+	};
+	const result = await runtime.tts.textToSpeech({
 		text: speakText,
 		cfg: ttsCfg,
 		channel: "discord",
@@ -396,39 +850,34 @@ async function synthesizeVoiceReplyAudio(params) {
 	};
 	return {
 		status: "ok",
+		mode: "file",
 		audioPath: result.audioPath,
 		speakText
 	};
 }
 //#endregion
 //#region extensions/discord/src/voice/segment.ts
-const DISCORD_VOICE_MESSAGE_PROVIDER = "discord-voice";
+const VOICE_TRANSCRIPT_LOG_PREVIEW_CHARS = 500;
 const logger$1 = createSubsystemLogger("discord/voice");
+function formatVoiceTranscriptLogPreview(text) {
+	const oneLine = text.replace(/\s+/g, " ").trim();
+	if (oneLine.length <= VOICE_TRANSCRIPT_LOG_PREVIEW_CHARS) return oneLine;
+	return `${oneLine.slice(0, VOICE_TRANSCRIPT_LOG_PREVIEW_CHARS)}...`;
+}
 async function processDiscordVoiceSegment(params) {
 	const { entry, wavPath, userId, durationSeconds } = params;
 	logVoiceVerbose(`segment processing (${durationSeconds.toFixed(2)}s): guild ${entry.guildId} channel ${entry.channelId}`);
-	if (!entry.guildName) entry.guildName = await params.fetchGuildName(entry.guildId);
-	const speaker = await params.speakerContext.resolveContext(entry.guildId, userId);
-	const speakerIdentity = await params.speakerContext.resolveIdentity(entry.guildId, userId);
-	const access = await authorizeDiscordVoiceIngress({
+	const ingress = await resolveDiscordVoiceIngressContext({
+		entry,
+		userId,
 		cfg: params.cfg,
 		discordConfig: params.discordConfig,
-		guildName: entry.guildName,
-		guildId: entry.guildId,
-		channelId: entry.channelId,
-		channelName: entry.channelName,
-		channelSlug: entry.channelName ? normalizeDiscordSlug(entry.channelName) : "",
-		channelLabel: formatMention({ channelId: entry.channelId }),
-		memberRoleIds: speakerIdentity.memberRoleIds,
 		ownerAllowFrom: params.ownerAllowFrom,
-		sender: {
-			id: speakerIdentity.id,
-			name: speakerIdentity.name,
-			tag: speakerIdentity.tag
-		}
+		fetchGuildName: params.fetchGuildName,
+		speakerContext: params.speakerContext
 	});
-	if (!access.ok) {
-		logVoiceVerbose(`segment unauthorized: guild ${entry.guildId} channel ${entry.channelId} user ${userId} reason=${access.message}`);
+	if (!ingress) {
+		logVoiceVerbose(`segment unauthorized: guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
 		return;
 	}
 	const transcript = await transcribeVoiceAudio({
@@ -441,21 +890,24 @@ async function processDiscordVoiceSegment(params) {
 		return;
 	}
 	logVoiceVerbose(`transcription ok (${transcript.length} chars): guild ${entry.guildId} channel ${entry.channelId}`);
-	const prompt = formatVoiceIngressPrompt(transcript, speaker.label);
-	const extraSystemPrompt = buildDiscordGroupSystemPrompt(access.channelConfig);
-	const modelOverride = normalizeOptionalString(params.discordConfig.voice?.model);
-	const replyText = ((await agentCommandFromIngress({
-		message: prompt,
-		sessionKey: entry.route.sessionKey,
-		agentId: entry.route.agentId,
-		messageChannel: "discord",
-		messageProvider: DISCORD_VOICE_MESSAGE_PROVIDER,
-		extraSystemPrompt,
-		senderIsOwner: speaker.senderIsOwner,
-		allowModelOverride: Boolean(modelOverride),
-		model: modelOverride,
-		deliver: false
-	}, params.runtime)).payloads ?? []).map((payload) => payload.text).filter((text) => typeof text === "string" && text.trim()).join("\n").trim();
+	logVoiceVerbose(`transcript from ${ingress.speakerLabel} (${userId}) in guild ${entry.guildId} channel ${entry.channelId}: ${formatVoiceTranscriptLogPreview(transcript)}`);
+	const turn = await runDiscordVoiceAgentTurn({
+		entry,
+		userId,
+		message: formatVoiceIngressPrompt(transcript, ingress.speakerLabel),
+		cfg: params.cfg,
+		discordConfig: params.discordConfig,
+		runtime: params.runtime,
+		context: ingress,
+		ownerAllowFrom: params.ownerAllowFrom,
+		fetchGuildName: params.fetchGuildName,
+		speakerContext: params.speakerContext
+	});
+	if (!turn) {
+		logVoiceVerbose(`segment unauthorized before agent turn: guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
+		return;
+	}
+	const replyText = turn.text;
 	if (!replyText) {
 		logVoiceVerbose(`reply empty: guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
 		return;
@@ -465,7 +917,7 @@ async function processDiscordVoiceSegment(params) {
 		cfg: params.cfg,
 		override: params.discordConfig.voice?.tts,
 		replyText,
-		speakerLabel: speaker.label
+		speakerLabel: ingress.speakerLabel
 	});
 	if (voiceReplyAudio.status === "empty") {
 		logVoiceVerbose(`tts skipped (empty): guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
@@ -477,13 +929,25 @@ async function processDiscordVoiceSegment(params) {
 	}
 	logVoiceVerbose(`tts ok (${voiceReplyAudio.speakText.length} chars): guild ${entry.guildId} channel ${entry.channelId}`);
 	params.enqueuePlayback(entry, async () => {
-		logVoiceVerbose(`playback start: guild ${entry.guildId} channel ${entry.channelId} file ${path.basename(voiceReplyAudio.audioPath)}`);
 		const voiceSdk = loadDiscordVoiceSdk();
-		const resource = voiceSdk.createAudioResource(voiceReplyAudio.audioPath);
-		entry.player.play(resource);
-		await voiceSdk.entersState(entry.player, voiceSdk.AudioPlayerStatus.Playing, PLAYBACK_READY_TIMEOUT_MS).catch(() => void 0);
-		await voiceSdk.entersState(entry.player, voiceSdk.AudioPlayerStatus.Idle, SPEAKING_READY_TIMEOUT_MS).catch(() => void 0);
-		logVoiceVerbose(`playback done: guild ${entry.guildId} channel ${entry.channelId}`);
+		const releaseAudioStream = voiceReplyAudio.mode === "stream" ? voiceReplyAudio.release : void 0;
+		try {
+			if (voiceReplyAudio.mode === "stream") {
+				logVoiceVerbose(`playback start: guild ${entry.guildId} channel ${entry.channelId} stream`);
+				const nodeStream = Readable.fromWeb(voiceReplyAudio.audioStream);
+				const resource = voiceSdk.createAudioResource(nodeStream);
+				entry.player.play(resource);
+			} else {
+				logVoiceVerbose(`playback start: guild ${entry.guildId} channel ${entry.channelId} file ${path.basename(voiceReplyAudio.audioPath)}`);
+				const resource = voiceSdk.createAudioResource(voiceReplyAudio.audioPath);
+				entry.player.play(resource);
+			}
+			await voiceSdk.entersState(entry.player, voiceSdk.AudioPlayerStatus.Playing, PLAYBACK_READY_TIMEOUT_MS).catch(() => void 0);
+			await voiceSdk.entersState(entry.player, voiceSdk.AudioPlayerStatus.Idle, SPEAKING_READY_TIMEOUT_MS).catch(() => void 0);
+			logVoiceVerbose(`playback done: guild ${entry.guildId} channel ${entry.channelId}`);
+		} finally {
+			await releaseAudioStream?.();
+		}
 	});
 }
 //#endregion
@@ -580,6 +1044,12 @@ var DiscordVoiceSpeakerContextResolver = class {
 //#endregion
 //#region extensions/discord/src/voice/manager.ts
 const logger = createSubsystemLogger("discord/voice");
+const VOICE_LOG_PREVIEW_CHARS = 500;
+function formatVoiceLogPreview(text) {
+	const oneLine = text.replace(/\s+/g, " ").trim();
+	if (oneLine.length <= VOICE_LOG_PREVIEW_CHARS) return oneLine;
+	return `${oneLine.slice(0, VOICE_LOG_PREVIEW_CHARS)}...`;
+}
 function isVoiceConnectionDestroyed(connection, voiceSdk) {
 	return connection.state.status === voiceSdk.VoiceConnectionStatus.Destroyed;
 }
@@ -602,6 +1072,44 @@ function destroyVoiceConnectionSafely(params) {
 function startAutoJoin(manager) {
 	manager.autoJoin().catch((err) => logger.warn(`discord voice: autoJoin failed: ${formatErrorMessage(err)}`));
 }
+function resolveDiscordVoiceAgentRoute(params) {
+	const voiceRoute = resolveAgentRoute({
+		cfg: params.cfg,
+		channel: "discord",
+		accountId: params.accountId,
+		guildId: params.guildId,
+		peer: {
+			kind: "channel",
+			id: params.sessionChannelId
+		}
+	});
+	const agentSession = params.voiceConfig?.agentSession;
+	if (agentSession?.mode !== "target") return {
+		route: voiceRoute,
+		voiceRoute,
+		agentSessionMode: "voice",
+		agentSessionTarget: void 0
+	};
+	const target = agentSession.target?.trim();
+	if (!target) throw new Error("channels.discord.voice.agentSession.target is required when mode is \"target\"");
+	const parsed = parseDiscordTarget(target, { defaultKind: "channel" });
+	if (!parsed) throw new Error(`Invalid Discord voice agent session target "${target}"`);
+	return {
+		route: resolveAgentRoute({
+			cfg: params.cfg,
+			channel: "discord",
+			accountId: params.accountId,
+			guildId: params.guildId,
+			peer: {
+				kind: parsed.kind === "user" ? "direct" : "channel",
+				id: parsed.id
+			}
+		}),
+		voiceRoute,
+		agentSessionMode: "target",
+		agentSessionTarget: parsed.normalized
+	};
+}
 var DiscordVoiceManager$1 = class {
 	constructor(params) {
 		this.params = params;
@@ -629,17 +1137,25 @@ var DiscordVoiceManager$1 = class {
 		if (this.autoJoinTask) return this.autoJoinTask;
 		this.autoJoinTask = (async () => {
 			const entries = this.params.discordConfig.voice?.autoJoin ?? [];
-			logVoiceVerbose(`autoJoin: ${entries.length} entries`);
-			const seenGuilds = /* @__PURE__ */ new Set();
+			const entriesByGuild = /* @__PURE__ */ new Map();
+			const duplicateGuilds = /* @__PURE__ */ new Set();
 			for (const entry of entries) {
 				const guildId = entry.guildId.trim();
-				if (!guildId) continue;
-				if (seenGuilds.has(guildId)) {
-					logger.warn(`discord voice: autoJoin has multiple entries for guild ${guildId}; skipping`);
-					continue;
-				}
-				seenGuilds.add(guildId);
-				logVoiceVerbose(`autoJoin: joining guild ${guildId} channel ${entry.channelId}`);
+				const channelId = entry.channelId.trim();
+				if (!guildId || !channelId) continue;
+				if (entriesByGuild.has(guildId)) duplicateGuilds.add(guildId);
+				entriesByGuild.set(guildId, {
+					guildId,
+					channelId
+				});
+			}
+			logVoiceVerbose(`autoJoin: ${entries.length} entries, ${entriesByGuild.size} guilds`);
+			for (const guildId of duplicateGuilds) {
+				const selected = entriesByGuild.get(guildId);
+				if (selected) logger.warn(`discord voice: autoJoin has multiple entries for guild ${guildId}; using channel ${selected.channelId}`);
+			}
+			for (const entry of entriesByGuild.values()) {
+				logVoiceVerbose(`autoJoin: joining guild ${entry.guildId} channel ${entry.channelId}`);
 				await this.join({
 					guildId: entry.guildId,
 					channelId: entry.channelId
@@ -700,6 +1216,7 @@ var DiscordVoiceManager$1 = class {
 			message: "Discord voice plugin is not available."
 		};
 		const voiceConfig = this.params.discordConfig.voice;
+		const voiceMode = resolveDiscordVoiceMode(voiceConfig);
 		const adapterCreator = voicePlugin.getGatewayAdapterCreator(guildId);
 		const daveEncryption = voiceConfig?.daveEncryption;
 		const decryptionFailureTolerance = voiceConfig?.decryptionFailureTolerance;
@@ -744,16 +1261,30 @@ var DiscordVoiceManager$1 = class {
 		}
 		const sessionChannelId = channelInfo?.id ?? channelId;
 		if (sessionChannelId !== channelId) logVoiceVerbose(`join: using session channel ${sessionChannelId} for voice channel ${channelId}`);
-		const route = resolveAgentRoute({
-			cfg: this.params.cfg,
-			channel: "discord",
-			accountId: this.params.accountId,
-			guildId,
-			peer: {
-				kind: "channel",
-				id: sessionChannelId
-			}
-		});
+		let routeInfo;
+		try {
+			routeInfo = resolveDiscordVoiceAgentRoute({
+				cfg: this.params.cfg,
+				accountId: this.params.accountId,
+				guildId,
+				sessionChannelId,
+				voiceConfig
+			});
+		} catch (err) {
+			destroyVoiceConnectionSafely({
+				connection,
+				voiceSdk,
+				reason: `voice agent session route failed guild ${guildId} channel ${channelId}`
+			});
+			return {
+				ok: false,
+				message: `Failed to resolve Discord voice agent session: ${formatErrorMessage(err)}`,
+				guildId,
+				channelId
+			};
+		}
+		const { route, voiceRoute, agentSessionMode, agentSessionTarget } = routeInfo;
+		logger.info(`discord voice: joining guild=${guildId} channel=${channelId} mode=${voiceMode} agent=${route.agentId} voiceSession=${voiceRoute.sessionKey} supervisorSession=${route.sessionKey} agentSessionMode=${agentSessionMode}${agentSessionTarget ? ` agentSessionTarget=${agentSessionTarget}` : ""} voiceModel=${voiceConfig?.model ?? "route-default"} realtimeProvider=${voiceConfig?.realtime?.provider ?? "auto"} realtimeModel=${voiceConfig?.realtime?.model ?? "provider-default"} realtimeVoice=${voiceConfig?.realtime?.voice ?? "provider-default"}`);
 		const player = voiceSdk.createAudioPlayer();
 		connection.subscribe(player);
 		let speakingHandler;
@@ -761,15 +1292,35 @@ var DiscordVoiceManager$1 = class {
 		let disconnectedHandler;
 		let destroyedHandler;
 		let playerErrorHandler;
+		let stopped = false;
 		const clearSessionIfCurrent = () => {
 			if (this.sessions.get(guildId)?.connection === connection) this.sessions.delete(guildId);
 		};
+		const stopEntry = (entry, options) => {
+			if (stopped) return;
+			stopped = true;
+			if (speakingHandler) connection.receiver.speaking.off("start", speakingHandler);
+			if (speakingEndHandler) connection.receiver.speaking.off("end", speakingEndHandler);
+			stopVoiceCaptureState(entry.capture);
+			if (disconnectedHandler) connection.off(voiceSdk.VoiceConnectionStatus.Disconnected, disconnectedHandler);
+			if (destroyedHandler) connection.off(voiceSdk.VoiceConnectionStatus.Destroyed, destroyedHandler);
+			if (playerErrorHandler) player.off("error", playerErrorHandler);
+			entry.realtime?.close();
+			entry.realtime = void 0;
+			player.stop();
+			if (options.destroyConnection) destroyVoiceConnectionSafely({
+				connection,
+				voiceSdk,
+				reason: options.reason
+			});
+		};
 		const entry = {
 			guildId,
 			guildName: channelInfo && "guild" in channelInfo && channelInfo.guild && typeof channelInfo.guild.name === "string" ? channelInfo.guild.name : void 0,
 			channelId,
 			channelName: channelInfo && "name" in channelInfo && typeof channelInfo.name === "string" ? channelInfo.name : void 0,
 			sessionChannelId,
+			voiceSessionKey: voiceRoute.sessionKey,
 			route,
 			connection,
 			player,
@@ -778,20 +1329,43 @@ var DiscordVoiceManager$1 = class {
 			capture: createVoiceCaptureState(),
 			receiveRecovery: createVoiceReceiveRecoveryState(),
 			stop: () => {
-				if (speakingHandler) connection.receiver.speaking.off("start", speakingHandler);
-				if (speakingEndHandler) connection.receiver.speaking.off("end", speakingEndHandler);
-				stopVoiceCaptureState(entry.capture);
-				if (disconnectedHandler) connection.off(voiceSdk.VoiceConnectionStatus.Disconnected, disconnectedHandler);
-				if (destroyedHandler) connection.off(voiceSdk.VoiceConnectionStatus.Destroyed, destroyedHandler);
-				if (playerErrorHandler) player.off("error", playerErrorHandler);
-				player.stop();
+				stopEntry(entry, {
+					destroyConnection: true,
+					reason: `stop guild ${guildId} channel ${channelId}`
+				});
+			}
+		};
+		if (voiceMode !== "stt-tts") {
+			entry.realtime = new DiscordRealtimeVoiceSession({
+				cfg: this.params.cfg,
+				discordConfig: this.params.discordConfig,
+				entry,
+				mode: voiceMode,
+				runAgentTurn: ({ context, message, toolsAllow, userId }) => this.runDiscordRealtimeAgentTurn({
+					context,
+					entry,
+					message,
+					toolsAllow,
+					userId
+				})
+			});
+			try {
+				await entry.realtime.connect();
+			} catch (err) {
+				entry.realtime.close();
 				destroyVoiceConnectionSafely({
 					connection,
 					voiceSdk,
-					reason: `stop guild ${guildId} channel ${channelId}`
+					reason: `realtime setup failed guild ${guildId} channel ${channelId}`
 				});
+				return {
+					ok: false,
+					message: `Failed to start Discord realtime voice: ${formatErrorMessage(err)}`,
+					guildId,
+					channelId
+				};
 			}
-		};
+		}
 		speakingHandler = (userId) => {
 			this.handleSpeakingStart(entry, userId).catch((err) => {
 				logger.warn(`discord voice: capture failed: ${formatErrorMessage(err)}`);
@@ -808,15 +1382,18 @@ var DiscordVoiceManager$1 = class {
 			} catch (err) {
 				logger.warn(`discord voice: disconnect recovery failed: guild ${guildId} channel ${channelId} timeout=${reconnectGraceMs}ms error=${formatErrorMessage(err)}; destroying connection`);
 				clearSessionIfCurrent();
-				destroyVoiceConnectionSafely({
-					connection,
-					voiceSdk,
+				stopEntry(entry, {
+					destroyConnection: true,
 					reason: `disconnect recovery failed guild ${guildId} channel ${channelId}`
 				});
 			}
 		};
 		destroyedHandler = () => {
 			clearSessionIfCurrent();
+			stopEntry(entry, {
+				destroyConnection: false,
+				reason: `destroyed guild ${guildId} channel ${channelId}`
+			});
 		};
 		playerErrorHandler = (err) => {
 			logger.warn(`discord voice: playback error: ${formatErrorMessage(err)}`);
@@ -828,6 +1405,7 @@ var DiscordVoiceManager$1 = class {
 		connection.on(voiceSdk.VoiceConnectionStatus.Destroyed, destroyedHandler);
 		player.on("error", playerErrorHandler);
 		this.sessions.set(guildId, entry);
+		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,
 			message: `Joined ${formatMention({ channelId })}.`,
@@ -892,8 +1470,26 @@ var DiscordVoiceManager$1 = class {
 		}
 		logVoiceVerbose(`capture start: guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
 		const voiceSdk = loadDiscordVoiceSdk();
+		const voiceMode = resolveDiscordVoiceMode(this.params.discordConfig.voice);
+		const realtime = entry.realtime && isDiscordRealtimeVoiceMode(voiceMode) ? entry.realtime : void 0;
+		if (entry.player.state.status === voiceSdk.AudioPlayerStatus.Playing && !realtime) {
+			logVoiceVerbose(`capture ignored during playback: guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
+			return;
+		}
+		const realtimeIngress = realtime ? await this.resolveDiscordVoiceIngressContext(entry, userId) : void 0;
+		if (realtime && !realtimeIngress) {
+			logVoiceVerbose(`realtime capture unauthorized: guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
+			return;
+		}
+		if (entry.player.state.status === voiceSdk.AudioPlayerStatus.Playing && realtime) {
+			if (!realtime.isBargeInEnabled()) {
+				logger.info(`discord voice: realtime capture ignored during playback (barge-in disabled): guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
+				return;
+			}
+			logVoiceVerbose(`realtime barge-in: guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
+			realtime.handleBargeIn();
+		}
 		this.enableDaveReceivePassthrough(entry, `speaker ${userId} start`, 15);
-		if (entry.player.state.status === voiceSdk.AudioPlayerStatus.Playing) entry.player.stop(true);
 		const stream = entry.connection.receiver.subscribe(userId, { end: { behavior: voiceSdk.EndBehaviorType.Manual } });
 		const generation = beginVoiceCapture(entry.capture, userId, stream);
 		let streamAborted = false;
@@ -902,6 +1498,19 @@ var DiscordVoiceManager$1 = class {
 			this.handleReceiveError(entry, err);
 		});
 		try {
+			if (realtime && realtimeIngress) {
+				const turn = realtime.beginSpeakerTurn(realtimeIngress, userId);
+				try {
+					await this.processRealtimeAudioCapture({
+						entry,
+						stream,
+						turn
+					});
+				} finally {
+					turn.close();
+				}
+				return;
+			}
 			const pcm = await decodeOpusStream(stream, {
 				onVerbose: logVoiceVerbose,
 				onWarn: (message) => logger.warn(message)
@@ -929,6 +1538,61 @@ var DiscordVoiceManager$1 = class {
 			finishVoiceCapture(entry.capture, userId, generation);
 		}
 	}
+	async processRealtimeAudioCapture(params) {
+		const { entry, stream, turn } = params;
+		let resetReceiveRecovery = false;
+		await decodeOpusStreamChunks(stream, {
+			onChunk: (pcm) => {
+				if (!resetReceiveRecovery && pcm.length > 0) {
+					resetReceiveRecovery = true;
+					this.resetDecryptFailureState(entry);
+				}
+				turn.sendInputAudio(pcm);
+			},
+			onVerbose: logVoiceVerbose,
+			onWarn: (message) => logger.warn(message)
+		});
+	}
+	async resolveDiscordVoiceIngressContext(entry, userId) {
+		return await resolveDiscordVoiceIngressContext({
+			entry,
+			userId,
+			cfg: this.params.cfg,
+			discordConfig: this.params.discordConfig,
+			ownerAllowFrom: this.ownerAllowFrom,
+			fetchGuildName: async (guildId) => {
+				const guild = await this.params.client.fetchGuild(guildId).catch(() => null);
+				return guild && typeof guild.name === "string" && guild.name.trim() ? guild.name : void 0;
+			},
+			speakerContext: this.speakerContext
+		});
+	}
+	async runDiscordRealtimeAgentTurn(params) {
+		const { context, entry, message, toolsAllow, userId } = params;
+		logger.info(`discord voice: agent turn start guild=${entry.guildId} channel=${entry.channelId} voiceSession=${entry.voiceSessionKey} supervisorSession=${entry.route.sessionKey} agent=${entry.route.agentId} user=${userId} speaker=${context.speakerLabel} owner=${context.senderIsOwner} model=${this.params.discordConfig.voice?.model ?? "route-default"} message=${formatVoiceLogPreview(message)}`);
+		const turn = await runDiscordVoiceAgentTurn({
+			entry,
+			userId,
+			message,
+			cfg: this.params.cfg,
+			discordConfig: this.params.discordConfig,
+			runtime: this.params.runtime,
+			context,
+			toolsAllow,
+			ownerAllowFrom: this.ownerAllowFrom,
+			fetchGuildName: async (guildId) => {
+				const guild = await this.params.client.fetchGuild(guildId).catch(() => null);
+				return guild && typeof guild.name === "string" && guild.name.trim() ? guild.name : void 0;
+			},
+			speakerContext: this.speakerContext
+		});
+		if (!turn) {
+			logVoiceVerbose(`realtime agent unauthorized: guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
+			return "";
+		}
+		logger.info(`discord voice: agent turn answer (${turn.text.length} chars) guild=${entry.guildId} channel=${entry.channelId} voiceSession=${entry.voiceSessionKey} supervisorSession=${entry.route.sessionKey} agent=${entry.route.agentId}: ${formatVoiceLogPreview(turn.text)}`);
+		return turn.text;
+	}
 	async processSegment(params) {
 		await processDiscordVoiceSegment({
 			...params,
@@ -948,6 +1612,10 @@ var DiscordVoiceManager$1 = class {
 	}
 	handleReceiveError(entry, err) {
 		const analysis = analyzeVoiceReceiveError(err);
+		if (analysis.isAbortLike && !analysis.countsAsDecryptFailure) {
+			logVoiceVerbose(`receive stream ended: ${analysis.message}`);
+			return;
+		}
 		logger.warn(`discord voice: receive error: ${analysis.message}`);
 		if (analysis.shouldAttemptPassthrough) this.enableDaveReceivePassthrough(entry, "receive decrypt error", 15);
 		if (!analysis.countsAsDecryptFailure) return;