@openclaw/discord 2026.9.1-beta.1 → 2026.9.2

package/dist/{voice-runtime-DIeaa8fJ.js → voice-runtime-BQnILUbG.js}

@@ -1,24 +1,368 @@
-import { D as ReadyListener, L as isUnknownDiscordVoiceStateError, O as ResumedListener, Yt as getGuildVoiceState, _ as parseDiscordTarget, j as VoiceStateUpdateListener, y as discord_exports } from "./retry-Cv4jCU5Z.js";
+import { M as VoiceStateUpdateListener, O as ReadyListener, R as isUnknownDiscordVoiceStateError, Xt as getGuildVoiceState, b as discord_exports, k as ResumedListener, sn as __exportAll, v as parseDiscordTarget } from "./retry-DQt1zDgH.js";
 import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.js";
-import { a as normalizeDiscordSlug, h as resolveDiscordOwnerAccess, x as formatDiscordUserTag } from "./allow-list-BDMimASD.js";
-import { a as formatMention } from "./send.outbound-zam0TrZx.js";
-import { n as resolveDiscordVoiceEnabled, r as authorizeDiscordVoiceIngress, t as resolveDiscordVoiceAccess } from "./owner-access-UlYi9t0M.js";
-import { p as buildDiscordGroupSystemPrompt, y as resolveFetchedDiscordThreadLikeChannelContext } from "./provider-B11xwilq.js";
-import { _ as decodeOpusStreamChunks, a as VOICE_CONNECT_READY_TIMEOUT_MS, b as maybeControlDiscordVoiceAgentRun, c as isVoiceChannel, d as resolveVoiceTimeoutMs, g as decodeOpusStream, h as createDiscordOpusPlaybackStream, i as PLAYBACK_READY_TIMEOUT_MS, l as logVoiceVerbose, n as CAPTURE_FINALIZE_GRACE_MS, o as VOICE_RECONNECT_GRACE_MS, s as isDiscordRealtimeVoiceMode, t as loadDiscordVoiceSdk, u as resolveDiscordVoiceMode, v as writeVoiceWavFile, x as formatVoiceLogPreview, y as formatVoiceIngressPrompt } from "./sdk-runtime-4geQHtXc.js";
+import { a as normalizeDiscordSlug, b as formatDiscordUserTag, m as resolveDiscordOwnerAccess } from "./allow-list-DBTtR2dz.js";
+import { a as formatMention } from "./send.outbound-DHuFUL6W.js";
+import { n as resolveDiscordVoiceEnabled, r as authorizeDiscordVoiceIngress, t as resolveDiscordVoiceAccess } from "./owner-access-Cp8r6Ipf.js";
+import { b as resolveFetchedDiscordThreadLikeChannelContext, m as buildDiscordGroupSystemPrompt } from "./provider-uKmmrDM4.js";
+import { createRequire } from "node:module";
+import fs from "node:fs/promises";
 import { asDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
+import { readByteStreamWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/ssrf-runtime";
 import { resolveAgentRoute } from "openclaw/plugin-sdk/routing";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
+import { createSubsystemLogger, logVerbose, shouldLogVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { escapeRegExp, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { stripInlineDirectiveTagsForDisplay } from "openclaw/plugin-sdk/text-chunking";
-import { unlinkIfExists } from "openclaw/plugin-sdk/media-runtime";
+import { resolveFfmpegBin, unlinkIfExists } from "openclaw/plugin-sdk/media-runtime";
+import { resolvePreferredOpenClawTmpDir, tempWorkspace } from "openclaw/plugin-sdk/temp-path";
 import { resolveAgentDir } from "openclaw/plugin-sdk/agent-runtime";
 import { enqueueRoutedSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
-import { Readable } from "node:stream";
-import { OpusError } from "libopus-wasm";
+import { controlRealtimeVoiceAgentRun, resamplePcm, shouldAutoControlRealtimeVoiceAgentText } from "openclaw/plugin-sdk/realtime-voice";
+import { spawn } from "node:child_process";
+import { Readable, Transform } from "node:stream";
+import { StringDecoder } from "node:string_decoder";
+import { Application, OpusError, createDecoder, createEncoder } from "libopus-wasm";
 import { resolveRealtimeBootstrapContextInstructions } from "openclaw/plugin-sdk/realtime-bootstrap-context";
+//#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/log-preview.ts
+const DISCORD_VOICE_LOG_PREVIEW_CHARS = 500;
+function formatVoiceLogPreview(text) {
+	const oneLine = text.replace(/\s+/g, " ").trim();
+	if (oneLine.length <= DISCORD_VOICE_LOG_PREVIEW_CHARS) return oneLine;
+	return `${truncateUtf16Safe(oneLine, DISCORD_VOICE_LOG_PREVIEW_CHARS)}...`;
+}
+//#endregion
+//#region extensions/discord/src/voice/agent-control.ts
+async function maybeControlDiscordVoiceAgentRun(params) {
+	if (!shouldAutoControlRealtimeVoiceAgentText(params.text)) return { handled: false };
+	const result = await controlRealtimeVoiceAgentRun({
+		sessionKey: params.entry.route.sessionKey,
+		text: params.text
+	});
+	if (!result.active) return {
+		handled: false,
+		result
+	};
+	return {
+		handled: true,
+		result,
+		...result.speak && !result.suppress ? { speakText: result.message } : {}
+	};
+}
+//#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();
+	const voiceInput = cleanedLabel ? [`Voice transcript from speaker "${cleanedLabel}":`, cleanedTranscript].join("\n") : cleanedTranscript;
+	return [DISCORD_VOICE_SPOKEN_OUTPUT_CONTRACT, voiceInput].join("\n\n");
+}
+//#endregion
+//#region extensions/discord/src/voice/audio.ts
+const SAMPLE_RATE = 48e3;
+const CHANNELS = 2;
+const BIT_DEPTH = 16;
+const FFMPEG_ERROR_OUTPUT_BYTES = 8192;
+const DISCORD_OPUS_FRAME_SIZE = 960;
+const DISCORD_OPUS_FRAME_BYTES = DISCORD_OPUS_FRAME_SIZE * CHANNELS * (BIT_DEPTH / 8);
+const FFMPEG_PCM_ARGUMENTS = [
+	"-analyzeduration",
+	"0",
+	"-loglevel",
+	"error",
+	"-vn",
+	"-sn",
+	"-dn",
+	"-f",
+	"s16le",
+	"-ar",
+	String(SAMPLE_RATE),
+	"-ac",
+	String(CHANNELS)
+];
+let warnedOpusMissing = false;
+function buildWavBuffer(pcm) {
+	const blockAlign = 4;
+	const byteRate = SAMPLE_RATE * blockAlign;
+	const header = Buffer.alloc(44);
+	header.write("RIFF", 0);
+	header.writeUInt32LE(36 + pcm.length, 4);
+	header.write("WAVE", 8);
+	header.write("fmt ", 12);
+	header.writeUInt32LE(16, 16);
+	header.writeUInt16LE(1, 20);
+	header.writeUInt16LE(CHANNELS, 22);
+	header.writeUInt32LE(SAMPLE_RATE, 24);
+	header.writeUInt32LE(byteRate, 28);
+	header.writeUInt16LE(blockAlign, 32);
+	header.writeUInt16LE(BIT_DEPTH, 34);
+	header.write("data", 36);
+	header.writeUInt32LE(pcm.length, 40);
+	return Buffer.concat([header, pcm]);
+}
+function createDiscordOpusEncodeStream() {
+	return new DiscordOpusEncodeStream();
+}
+function createDiscordOpusPlaybackStream(input) {
+	const inputSource = typeof input === "string" ? input : "pipe:0";
+	const ffmpeg = spawn(resolveFfmpegBin(), [
+		"-i",
+		inputSource,
+		...FFMPEG_PCM_ARGUMENTS,
+		"pipe:1"
+	], {
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		],
+		windowsHide: true
+	});
+	const opusStream = createDiscordOpusEncodeStream();
+	const stderr = Buffer.alloc(FFMPEG_ERROR_OUTPUT_BYTES);
+	let stderrBytes = 0;
+	let ffmpegClosed = false;
+	const killFfmpeg = (signal = "SIGTERM") => {
+		if (!ffmpegClosed && !ffmpeg.killed) ffmpeg.kill(signal);
+	};
+	ffmpeg.stderr.on("data", (chunk) => {
+		if (stderrBytes < FFMPEG_ERROR_OUTPUT_BYTES) stderrBytes += chunk.copy(stderr, stderrBytes, 0, FFMPEG_ERROR_OUTPUT_BYTES - stderrBytes);
+	});
+	ffmpeg.once("error", (err) => {
+		opusStream.destroy(err);
+	});
+	ffmpeg.once("close", (code, signal) => {
+		ffmpegClosed = true;
+		if (code && code !== 0) {
+			const stderrText = new StringDecoder("utf8").write(stderr.subarray(0, stderrBytes)).trim();
+			const suffix = stderrText ? `: ${stderrText}` : "";
+			opusStream.destroy(/* @__PURE__ */ new Error(`ffmpeg exited with code ${code}${suffix}`));
+			return;
+		}
+		if (signal) opusStream.destroy(/* @__PURE__ */ new Error(`ffmpeg exited with signal ${signal}`));
+	});
+	for (const readable of [ffmpeg.stdout, ffmpeg.stderr]) readable.on("error", (err) => {
+		killFfmpeg("SIGKILL");
+		opusStream.destroy(err);
+	});
+	ffmpeg.stdin.on("error", (err) => {
+		if (err.code !== "EPIPE") opusStream.destroy(err);
+	});
+	ffmpeg.stdout.pipe(opusStream);
+	opusStream.once("close", () => {
+		if (!opusStream.readableEnded) killFfmpeg();
+	});
+	if (typeof input !== "string") {
+		input.on("error", (err) => {
+			ffmpeg.stdin.destroy(err);
+			opusStream.destroy(err);
+		});
+		input.pipe(ffmpeg.stdin);
+	} else ffmpeg.stdin.end();
+	return opusStream;
+}
+var DiscordOpusEncodeStream = class extends Transform {
+	#buffer = Buffer.alloc(0);
+	#encoder;
+	#packetPcmBytes = /* @__PURE__ */ new WeakMap();
+	constructor() {
+		super({ readableObjectMode: true });
+	}
+	_construct(done) {
+		createEncoder({
+			application: Application.Audio,
+			channels: CHANNELS,
+			sampleRate: SAMPLE_RATE
+		}).then((encoder) => {
+			this.#encoder = encoder;
+			done();
+		}, (err) => done(err instanceof Error ? err : new Error(formatErrorMessage(err))));
+	}
+	_transform(chunk, _encoding, done) {
+		try {
+			this.#buffer = this.#buffer.length > 0 ? Buffer.concat([this.#buffer, chunk]) : Buffer.from(chunk);
+			while (this.#buffer.length >= DISCORD_OPUS_FRAME_BYTES) {
+				const frame = this.#buffer.subarray(0, DISCORD_OPUS_FRAME_BYTES);
+				this.#buffer = this.#buffer.subarray(DISCORD_OPUS_FRAME_BYTES);
+				this.#encodeFrame(frame);
+			}
+			done();
+		} catch (err) {
+			done(err instanceof Error ? err : new Error(formatErrorMessage(err)));
+		}
+	}
+	_flush(done) {
+		try {
+			this.flushPartialFrame();
+			done();
+		} catch (err) {
+			done(err instanceof Error ? err : new Error(formatErrorMessage(err)));
+		}
+	}
+	flushPartialFrame() {
+		if (this.destroyed || this.#buffer.length === 0) return false;
+		const pcmBytes = this.#buffer.length;
+		const frame = Buffer.alloc(DISCORD_OPUS_FRAME_BYTES);
+		this.#buffer.copy(frame);
+		this.#buffer = Buffer.alloc(0);
+		this.#encodeFrame(frame, pcmBytes);
+		return true;
+	}
+	takePcmBytes(packet) {
+		const bytes = this.#packetPcmBytes.get(packet) ?? 0;
+		this.#packetPcmBytes.delete(packet);
+		return bytes;
+	}
+	_destroy(err, done) {
+		this.#encoder?.free();
+		this.#buffer = Buffer.alloc(0);
+		done(err);
+	}
+	#encodeFrame(frame, pcmBytes = frame.length) {
+		const packet = Buffer.from(this.#encoder.encode(frame, { frameSize: DISCORD_OPUS_FRAME_SIZE }));
+		this.#packetPcmBytes.set(packet, pcmBytes);
+		this.push(packet);
+	}
+};
+function pcmInt16ToBuffer(pcm) {
+	return Buffer.from(pcm.buffer, pcm.byteOffset, pcm.byteLength);
+}
+async function decodeOpusStream(stream, params) {
+	return await readByteStreamWithLimit(decodeOpusFrames(stream, params), {
+		maxBytes: params.maxBytes,
+		onOverflow: () => /* @__PURE__ */ new Error(`Discord voice capture exceeds the transcription PCM limit (${params.maxBytes} bytes); speak a shorter segment.`)
+	});
+}
+async function decodeOpusStreamChunks(stream, params) {
+	try {
+		for await (const pcm of decodeOpusFrames(stream, params)) params.onChunk(pcm);
+	} catch (err) {
+		params.onError?.(err);
+	}
+}
+async function* decodeOpusFrames(stream, params) {
+	let decoder;
+	try {
+		decoder = await createDecoder({
+			channels: CHANNELS,
+			sampleRate: SAMPLE_RATE
+		});
+	} catch (err) {
+		if (!warnedOpusMissing) {
+			warnedOpusMissing = true;
+			params.onWarn(`discord voice: no usable opus decoder available (libopus-wasm: ${formatErrorMessage(err)}); cannot decode voice audio`);
+		}
+		return;
+	}
+	params.onVerbose("opus decoder: libopus-wasm");
+	try {
+		for await (const chunk of stream) {
+			if (!chunk || !(chunk instanceof Buffer) || chunk.length === 0) continue;
+			const decoded = decoder.decode(chunk, { maxFrameSize: DISCORD_OPUS_FRAME_SIZE });
+			if (decoded.length > 0) yield pcmInt16ToBuffer(decoded);
+		}
+	} catch (err) {
+		params.onError?.(err);
+		if (shouldLogVerbose()) logVerbose(`discord voice: opus decode failed: ${formatErrorMessage(err)}`);
+	} finally {
+		decoder.free();
+	}
+}
+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;
+	return pcm.length / (bytesPerSample * SAMPLE_RATE);
+}
+async function writeVoiceWavFile(pcm) {
+	const workspace = await tempWorkspace({
+		rootDir: resolvePreferredOpenClawTmpDir(),
+		prefix: "discord-voice-"
+	});
+	scheduleTempCleanup(workspace.dir);
+	const wav = buildWavBuffer(pcm);
+	return {
+		path: await workspace.write("segment.wav", wav),
+		durationSeconds: estimateDurationSeconds(pcm)
+	};
+}
+function scheduleTempCleanup(tempDir, delayMs = 18e5) {
+	setTimeout(() => {
+		fs.rm(tempDir, {
+			recursive: true,
+			force: true
+		}).catch((err) => {
+			if (shouldLogVerbose()) logVerbose(`discord voice: temp cleanup failed for ${tempDir}: ${formatErrorMessage(err)}`);
+		});
+	}, delayMs).unref();
+}
+const CAPTURE_FINALIZE_GRACE_MS = 2e3;
+const VOICE_CONNECT_READY_TIMEOUT_MS = 3e4;
+const VOICE_RECONNECT_GRACE_MS = 15e3;
+const PLAYBACK_READY_TIMEOUT_MS = 6e4;
+function resolveVoiceTimeoutMs(value, fallbackMs) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return fallbackMs;
+	return Math.floor(value);
+}
+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 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/ingress.ts
 const DISCORD_VOICE_MESSAGE_PROVIDER = "discord-voice";
 const logger$7 = createSubsystemLogger("discord/voice");
@@ -471,7 +815,11 @@ var DiscordVoiceSpeakerContextResolver = class {
 			label: identity.label,
 			name: identity.name,
 			tag: identity.tag,
-			senderIsOwner: this.resolveIsOwner(identity)
+			senderIsOwner: resolveDiscordOwnerAccess({
+				allowFrom: this.params.ownerAllowFrom,
+				sender: identity,
+				allowNameMatching: false
+			}).ownerAllowed
 		};
 		this.setCachedContext(guildId, userId, context);
 		return context;
@@ -507,17 +855,6 @@ var DiscordVoiceSpeakerContextResolver = class {
 			}
 		}
 	}
-	resolveIsOwner(identity) {
-		return resolveDiscordOwnerAccess({
-			allowFrom: this.params.ownerAllowFrom,
-			sender: {
-				id: identity.id,
-				name: identity.name,
-				tag: identity.tag
-			},
-			allowNameMatching: false
-		}).ownerAllowed;
-	}
 	resolveCacheKey(guildId, userId) {
 		return `${guildId}:${userId}`;
 	}
@@ -1030,70 +1367,43 @@ var DiscordVoiceFollowing = class {
 //#endregion
 //#region extensions/discord/src/voice/capture-state.ts
 function createVoiceCaptureState() {
-	return {
-		activeSpeakers: /* @__PURE__ */ new Set(),
-		activeCaptureStreams: /* @__PURE__ */ new Map(),
-		captureFinalizeTimers: /* @__PURE__ */ new Map(),
-		captureGenerations: /* @__PURE__ */ new Map()
-	};
+	return /* @__PURE__ */ new Map();
 }
 function stopVoiceCaptureState(state) {
-	for (const { timer } of state.captureFinalizeTimers.values()) clearTimeout(timer);
-	state.captureFinalizeTimers.clear();
-	for (const { stream } of state.activeCaptureStreams.values()) stream.destroy();
-	state.activeCaptureStreams.clear();
-	state.captureGenerations.clear();
-	state.activeSpeakers.clear();
-}
-function getActiveVoiceCapture(state, userId) {
-	return state.activeCaptureStreams.get(userId);
-}
-function isVoiceCaptureActive(state, userId) {
-	return state.activeSpeakers.has(userId);
-}
-function clearVoiceCaptureFinalizeTimer(state, userId, generation) {
-	const scheduled = state.captureFinalizeTimers.get(userId);
-	if (!scheduled || generation !== void 0 && scheduled.generation !== generation) return false;
-	clearTimeout(scheduled.timer);
-	state.captureFinalizeTimers.delete(userId);
+	const captures = [...state.values()];
+	state.clear();
+	for (const capture of captures) {
+		clearVoiceCaptureFinalizeTimer(capture);
+		capture.stream?.destroy();
+	}
+}
+function clearVoiceCaptureFinalizeTimer(capture) {
+	if (!capture.finalizeTimer) return false;
+	clearTimeout(capture.finalizeTimer);
+	delete capture.finalizeTimer;
 	return true;
 }
 function beginVoiceCapture(state, userId, stream) {
-	const generation = (state.captureGenerations.get(userId) ?? 0) + 1;
-	state.captureGenerations.set(userId, generation);
-	state.activeSpeakers.add(userId);
-	state.activeCaptureStreams.set(userId, {
-		generation,
-		stream
-	});
-	clearVoiceCaptureFinalizeTimer(state, userId, generation);
-	return generation;
-}
-function finishVoiceCapture(state, userId, generation) {
-	clearVoiceCaptureFinalizeTimer(state, userId, generation);
-	if (state.activeCaptureStreams.get(userId)?.generation !== generation) return false;
-	state.activeCaptureStreams.delete(userId);
-	state.activeSpeakers.delete(userId);
+	const capture = { stream };
+	state.set(userId, capture);
+	return capture;
+}
+function finishVoiceCapture(state, userId, capture) {
+	clearVoiceCaptureFinalizeTimer(capture);
+	if (state.get(userId) !== capture) return false;
+	state.delete(userId);
 	return true;
 }
 function scheduleVoiceCaptureFinalize(params) {
 	const { state, userId, delayMs, onFinalize } = params;
-	const capture = state.activeCaptureStreams.get(userId);
+	const capture = state.get(userId);
 	if (!capture) return false;
-	clearVoiceCaptureFinalizeTimer(state, userId, capture.generation);
-	const timer = setTimeout(() => {
-		const activeCapture = state.activeCaptureStreams.get(userId);
-		if (!activeCapture || activeCapture.generation !== capture.generation) return;
-		state.captureFinalizeTimers.delete(userId);
-		state.activeCaptureStreams.delete(userId);
-		state.activeSpeakers.delete(userId);
-		onFinalize?.(activeCapture);
-		activeCapture.stream.destroy();
+	clearVoiceCaptureFinalizeTimer(capture);
+	capture.finalizeTimer = setTimeout(() => {
+		if (!finishVoiceCapture(state, userId, capture)) return;
+		onFinalize?.(capture);
+		capture.stream?.destroy();
 	}, delayMs);
-	state.captureFinalizeTimers.set(userId, {
-		generation: capture.generation,
-		timer
-	});
 	return true;
 }
 //#endregion
@@ -1115,12 +1425,13 @@ function sanitizeVoiceReplyTextForSpeech(text, speakerLabel) {
 //#endregion
 //#region extensions/discord/src/voice/tts.ts
 async function transcribeVoiceAudio(params) {
-	return normalizeOptionalString((await getDiscordRuntime().mediaUnderstanding.transcribeAudioFile({
+	const result = await getDiscordRuntime().mediaUnderstanding.transcribeAudioFile({
 		filePath: params.filePath,
 		cfg: params.cfg,
 		agentDir: resolveAgentDir(params.cfg, params.agentId),
 		mime: "audio/wav"
-	})).text);
+	});
+	return normalizeOptionalString(result.text);
 }
 async function synthesizeVoiceReplyAudio(params) {
 	const runtime = getDiscordRuntime();
@@ -1199,6 +1510,7 @@ async function processDiscordVoiceSegment(params) {
 	logVoiceVerbose(`transcription ok (${transcript.length} chars): guild ${entry.guildId} channel ${entry.channelId}`);
 	logVoiceVerbose(`transcript from ${ingress.speakerLabel} (${userId}) in guild ${entry.guildId} channel ${entry.channelId}: ${formatVoiceLogPreview(transcript)}`);
 	if (params.transcripts) {
+		if (entry.sessionLifecycle.status === "stopped" || entry.transcripts !== params.transcripts) return;
 		await params.transcripts.onUtterance({
 			sessionId: params.transcripts.sessionId,
 			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1335,38 +1647,22 @@ var DiscordVoiceReceive = class {
 		const botUserId = this.params.botUserId();
 		if (botUserId && userId === botUserId) return;
 		this.params.membership.notePresent(entry, userId);
-		if (isVoiceCaptureActive(entry.capture, userId)) {
-			const activeCapture = getActiveVoiceCapture(entry.capture, userId);
-			const extended = activeCapture ? clearVoiceCaptureFinalizeTimer(entry.capture, userId, activeCapture.generation) : false;
+		const activeCapture = entry.capture.get(userId);
+		if (activeCapture) {
+			const extended = clearVoiceCaptureFinalizeTimer(activeCapture);
 			logVoiceVerbose(`capture start ignored (already active): guild ${entry.guildId} channel ${entry.channelId} user ${userId}${extended ? " (finalize canceled)" : ""}`);
 			return;
 		}
 		logVoiceVerbose(`capture start: guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
 		const voiceSdk = loadDiscordVoiceSdk();
+		const transcripts = entry.transcripts;
 		const voiceMode = resolveDiscordVoiceMode(this.params.discordConfig.voice);
 		const realtime = entry.realtimeLifecycle.status === "active" && isDiscordRealtimeVoiceMode(voiceMode) ? entry.realtimeLifecycle.instance : 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 (!this.params.isEntryCurrent(entry)) return;
-		if (entry.player.state.status === voiceSdk.AudioPlayerStatus.Playing && realtime) {
-			if (!realtime.isBargeInEnabled()) {
-				logger$3.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}`);
-			logger$3.info(`discord voice: realtime barge-in detected source=speaker-start guild=${entry.guildId} channel=${entry.channelId} user=${userId} playerStatus=${entry.player.state.status}`);
-			realtime.handleBargeIn("speaker-start");
-		}
-		this.enableDaveReceivePassthrough(entry, `speaker ${userId} start`, 15);
-		const stream = entry.connection.receiver.subscribe(userId, { end: { behavior: voiceSdk.EndBehaviorType.Manual } });
-		const generation = beginVoiceCapture(entry.capture, userId, stream);
+		const capture = beginVoiceCapture(entry.capture, userId);
 		let streamAborted = false;
 		let receiveFailureHandled = false;
 		let receiveStreamEndHandled = false;
@@ -1383,8 +1679,25 @@ var DiscordVoiceReceive = class {
 			receiveFailureHandled = true;
 			this.handleReceiveError(entry, err);
 		};
-		stream.on("error", handleStreamError);
 		try {
+			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 (!this.params.isEntryCurrent(entry) || entry.capture.get(userId) !== capture) return;
+			if (entry.player.state.status === voiceSdk.AudioPlayerStatus.Playing && realtime) {
+				if (!realtime.isBargeInEnabled()) {
+					logger$3.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}`);
+				logger$3.info(`discord voice: realtime barge-in detected source=speaker-start guild=${entry.guildId} channel=${entry.channelId} user=${userId} playerStatus=${entry.player.state.status}`);
+				realtime.handleBargeIn("speaker-start");
+			}
+			this.enableDaveReceivePassthrough(entry, `speaker ${userId} start`, 15);
+			const stream = capture.stream = entry.connection.receiver.subscribe(userId, { end: { behavior: voiceSdk.EndBehaviorType.Manual } });
+			stream.on("error", handleStreamError);
 			if (realtime && realtimeIngress) {
 				const turn = realtime.beginSpeakerTurn(realtimeIngress, userId);
 				try {
@@ -1399,7 +1712,12 @@ var DiscordVoiceReceive = class {
 				}
 				return;
 			}
+			if (!entry.audioInputBudget.enabled) {
+				logger$3.warn("discord voice: capture skipped: audio understanding is disabled; enable tools.media.audio.enabled to transcribe voice.");
+				return;
+			}
 			const pcm = await decodeOpusStream(stream, {
+				maxBytes: Math.max(0, entry.audioInputBudget.maxBytes - 44),
 				onError: handleStreamError,
 				onVerbose: logVoiceVerbose,
 				onWarn: (message) => logger$3.warn(message)
@@ -1420,6 +1738,7 @@ var DiscordVoiceReceive = class {
 			logVoiceVerbose(`capture ready (${durationSeconds.toFixed(2)}s): guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
 			entry.processingQueue = entry.processingQueue.then(async () => {
 				if (!this.params.isEntryCurrent(entry)) return;
+				if (entry.transcripts !== transcripts) return;
 				await this.processSegment({
 					entry,
 					wavPath,
@@ -1431,8 +1750,9 @@ var DiscordVoiceReceive = class {
 			if (!receiveFailureHandled) this.handleReceiveError(entry, err);
 			throw err;
 		} finally {
-			stream.off?.("error", handleStreamError);
-			if (finishVoiceCapture(entry.capture, userId, generation) && !stream.destroyed) stream.destroy();
+			const stream = capture.stream;
+			stream?.off?.("error", handleStreamError);
+			if (finishVoiceCapture(entry.capture, userId, capture) && stream && !stream.destroyed) stream.destroy();
 		}
 	}
 	async processSegment(params) {
@@ -1613,6 +1933,17 @@ const REALTIME_PLAYBACK_MAX_MISSED_FRAMES = 100;
 function isVoiceSessionStopped(entry) {
 	return entry.sessionLifecycle.status === "stopped";
 }
+function retireTranscripts(entry) {
+	const transcripts = entry.transcripts;
+	entry.transcripts = void 0;
+	try {
+		Promise.resolve(transcripts?.onStop?.()).catch((error) => {
+			logger$2.warn(`discord voice: transcripts retirement failed: ${formatErrorMessage(error)}`);
+		});
+	} catch (error) {
+		logger$2.warn(`discord voice: transcripts retirement failed: ${formatErrorMessage(error)}`);
+	}
+}
 function isVoiceConnectionDestroyed(connection, voiceSdk) {
 	return connection.state.status === voiceSdk.VoiceConnectionStatus.Destroyed;
 }
@@ -1699,7 +2030,10 @@ var DiscordVoiceSessions = class {
 		if (existing && existing.channelId === channelId) {
 			existing.autoJoinWhenOccupied = options?.autoJoinWhenOccupied === true;
 			if (authority) existing.generation = authority.generation;
-			if (options?.transcripts) existing.transcripts = options.transcripts;
+			if (options?.transcripts) {
+				retireTranscripts(existing);
+				existing.transcripts = options.transcripts;
+			}
 			if (!options?.transcripts && isDiscordRealtimeVoiceMode(voiceMode) && existing.realtimeLifecycle.status !== "active" && existing.realtimeLifecycle.status !== "starting") {
 				const realtimeResult = await this.attachRealtimeSession(existing, voiceMode, {
 					requireLiveEntry: true,
@@ -1751,6 +2085,8 @@ var DiscordVoiceSessions = class {
 			ok: false,
 			message: "Discord voice plugin is not available."
 		};
+		const audioInputBudget = await getDiscordRuntime().mediaUnderstanding.resolveAudioInputBudget({ cfg: this.params.cfg });
+		if (authority && !authority.isCurrent()) return cancelledJoinResult();
 		const adapterCreator = voicePlugin.getGatewayAdapterCreator(guildId);
 		const daveEncryption = voiceConfig?.daveEncryption;
 		const decryptionFailureTolerance = voiceConfig?.decryptionFailureTolerance;
@@ -1862,6 +2198,7 @@ var DiscordVoiceSessions = class {
 				status: "stopped",
 				reason: optionsLocal.reason
 			};
+			retireTranscripts(entry);
 			if (this.params.sessions.get(guildId) === entry) this.params.sessions.delete(guildId);
 			this.params.membership.deactivate(entry);
 			connection.receiver.speaking.off("start", speakingHandler);
@@ -1900,6 +2237,7 @@ var DiscordVoiceSessions = class {
 			player,
 			playbackQueue: Promise.resolve(),
 			processingQueue: Promise.resolve(),
+			audioInputBudget,
 			ttsStreamFallbackWarned: false,
 			capture: createVoiceCaptureState(),
 			transcripts: options?.transcripts,
@@ -2004,7 +2342,7 @@ var DiscordVoiceSessions = class {
 				channelId: entry.channelId
 			};
 			if (entry.realtimeLifecycle.status === "active" || entry.realtimeLifecycle.status === "starting") {
-				entry.transcripts = void 0;
+				retireTranscripts(entry);
 				return {
 					ok: true,
 					message: `Stopped transcripts for ${formatMention({ channelId: entry.channelId })}.`,
@@ -2034,7 +2372,7 @@ var DiscordVoiceSessions = class {
 			ok: false,
 			message: "Discord realtime voice session stopped before startup completed."
 		};
-		const { DiscordRealtimeVoiceSession } = await import("./realtime-session.runtime-CU8IQUS-.js");
+		const { DiscordRealtimeVoiceSession } = await import("./realtime-session.runtime-CGYm1t_0.js");
 		const realtime = new DiscordRealtimeVoiceSession({
 			accountId: this.params.accountId,
 			bootstrapContextInstructions,
@@ -2138,6 +2476,13 @@ var DiscordVoiceStateUpdateListener = class extends VoiceStateUpdateListener {
 };
 //#endregion
 //#region extensions/discord/src/voice/voice-runtime.ts
+var voice_runtime_exports = /* @__PURE__ */ __exportAll({
+	DiscordVoiceGuildCreateListener: () => DiscordVoiceGuildCreateListener,
+	DiscordVoiceManager: () => DiscordVoiceManager,
+	DiscordVoiceReadyListener: () => DiscordVoiceReadyListener,
+	DiscordVoiceResumedListener: () => DiscordVoiceResumedListener,
+	DiscordVoiceStateUpdateListener: () => DiscordVoiceStateUpdateListener
+});
 const logger = createSubsystemLogger("discord/voice");
 const DISCORD_VOICE_FATAL_AUTOJOIN_ERROR_PATTERNS = [
 	"api key missing",
@@ -2166,6 +2511,7 @@ var DiscordVoiceManager = class {
 		this.joinTasks = /* @__PURE__ */ new Map();
 		this.autoJoinTasks = /* @__PURE__ */ new Map();
 		this.fatalAutoJoinFailures = /* @__PURE__ */ new Map();
+		this.occupancyWatchers = /* @__PURE__ */ new Set();
 		this.destroyed = false;
 		this.client = params.client;
 		this.botUserId = params.botUserId;
@@ -2245,8 +2591,42 @@ var DiscordVoiceManager = class {
 	refreshGuildRoster(guildId) {
 		this.voiceSessions.refreshGuildRoster(guildId);
 	}
+	watchChannelOccupancy(params, listener) {
+		if (this.destroyed) return () => void 0;
+		const guildId = params.guildId.trim();
+		const channelId = params.channelId.trim();
+		let wasOccupied = false;
+		const watcher = {
+			guildId,
+			refresh: () => {
+				const states = listDiscordVoiceParticipantStates({
+					client: this.client,
+					guildId,
+					channelId
+				});
+				if (states === null) return;
+				const occupied = countDiscordVoiceHumanParticipants({
+					states,
+					botUserId: this.botUserId
+				}) > 0;
+				if (occupied !== wasOccupied) {
+					wasOccupied = occupied;
+					listener({ occupied });
+				}
+			}
+		};
+		this.occupancyWatchers.add(watcher);
+		watcher.refresh();
+		return () => {
+			this.occupancyWatchers.delete(watcher);
+		};
+	}
+	reconcileChannelOccupancy(guildId) {
+		for (const watcher of this.occupancyWatchers) if (!guildId || watcher.guildId === guildId) watcher.refresh();
+	}
 	async autoJoin() {
 		if (!this.voiceEnabled || this.destroyed) return;
+		this.reconcileChannelOccupancy();
 		const entriesByGuild = /* @__PURE__ */ new Map();
 		const duplicateGuilds = /* @__PURE__ */ new Set();
 		for (const entry of this.autoJoinChannels) {
@@ -2262,6 +2642,7 @@ var DiscordVoiceManager = class {
 		await this.following.startReconciliation();
 	}
 	async reconcileAutoJoinGuild(guildId) {
+		this.reconcileChannelOccupancy(guildId);
 		const entry = this.resolveAutoJoinTarget(guildId);
 		if (!entry?.whenOccupied || !this.voiceEnabled || this.destroyed) return;
 		await this.enqueueAutoJoin(entry);
@@ -2386,6 +2767,10 @@ var DiscordVoiceManager = class {
 					guildId,
 					channelId
 				}));
+				return {
+					...result,
+					...entry.channelName ? { channelName: entry.channelName } : {}
+				};
 			} else if (!result.ok && isCurrent()) this.guildLifecycles.set(guildId, {
 				status: "inactive",
 				generation
@@ -2453,6 +2838,7 @@ var DiscordVoiceManager = class {
 			return;
 		}
 		this.membership.track(this.sessions.get(guildId), data, previousVoiceState);
+		this.reconcileChannelOccupancy(guildId);
 		if (this.following.isFollowedUser(userId)) await this.following.handleFollowedUserVoiceStateUpdate({
 			guildId,
 			channelId,
@@ -2463,6 +2849,7 @@ var DiscordVoiceManager = class {
 	}
 	async destroy() {
 		this.destroyed = true;
+		this.occupancyWatchers.clear();
 		this.following.destroy();
 		for (const entry of this.sessions.values()) entry.stop();
 		for (const [guildId, lifecycle] of this.guildLifecycles) this.guildLifecycles.set(guildId, {
@@ -2538,4 +2925,4 @@ var DiscordVoiceManager = class {
 	}
 };
 //#endregion
-export { DiscordVoiceGuildCreateListener, DiscordVoiceManager, DiscordVoiceReadyListener, DiscordVoiceResumedListener, DiscordVoiceStateUpdateListener };
+export { DiscordVoiceGuildCreateListener, DiscordVoiceManager, DiscordVoiceReadyListener, DiscordVoiceResumedListener, DiscordVoiceStateUpdateListener, createDiscordOpusEncodeStream as a, formatVoiceLogPreview as c, convertRealtimePcm24kMonoToDiscordPcm48kStereo as i, loadDiscordVoiceSdk as l, logVoiceVerbose as n, formatVoiceIngressPrompt as o, convertDiscordPcm48kStereoToRealtimePcm24kMono as r, maybeControlDiscordVoiceAgentRun as s, voice_runtime_exports as t };