@openclaw/discord 2026.8.1-beta.3 → 2026.8.2

package/dist/{voice-runtime-CjNFaynA.js → voice-runtime-COyYYTDD.js}

@@ -1,25 +1,350 @@
-import { S as ResumedListener, T as VoiceStateUpdateListener, Ut as getGuildVoiceState, j as isUnknownDiscordVoiceStateError, p as discord_exports, x as ReadyListener } from "./retry-DNsVTeTo.js";
-import { k as parseDiscordTarget } from "./accounts-DNl-oCEw.js";
+import { D as ReadyListener, L as isUnknownDiscordVoiceStateError, O as ResumedListener, Yt as getGuildVoiceState, _ as parseDiscordTarget, j as VoiceStateUpdateListener, on as __exportAll, y as discord_exports } from "./retry-t5RcEsPk.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-HIkgji_7.js";
-import { n as resolveDiscordVoiceEnabled, r as authorizeDiscordVoiceIngress, t as resolveDiscordVoiceAccess } from "./owner-access-Bg41VzAf.js";
-import { p as buildDiscordGroupSystemPrompt, y as resolveFetchedDiscordThreadLikeChannelContext } from "./provider-DlK_ynqt.js";
-import { S as formatVoiceLogPreview, _ as decodeOpusStream, a as SPEAKING_READY_TIMEOUT_MS, b as formatVoiceIngressPrompt, c as isDiscordRealtimeVoiceMode, d as resolveDiscordVoiceMode, f as resolveVoiceTimeoutMs, g as createDiscordOpusPlaybackStream, i as PLAYBACK_READY_TIMEOUT_MS, l as isVoiceChannel, n as CAPTURE_FINALIZE_GRACE_MS, o as VOICE_CONNECT_READY_TIMEOUT_MS, s as VOICE_RECONNECT_GRACE_MS, t as loadDiscordVoiceSdk, u as logVoiceVerbose, v as decodeOpusStreamChunks, x as maybeControlDiscordVoiceAgentRun, y as writeVoiceWavFile } from "./sdk-runtime-37OU6_Yh.js";
+import { a as normalizeDiscordSlug, h as resolveDiscordOwnerAccess, x as formatDiscordUserTag } from "./allow-list-C2JuH-R0.js";
+import { a as formatMention } from "./send.outbound-CaOs9Zy1.js";
+import { n as resolveDiscordVoiceEnabled, r as authorizeDiscordVoiceIngress, t as resolveDiscordVoiceAccess } from "./owner-access-yc1sX7Gx.js";
+import { b as resolveFetchedDiscordThreadLikeChannelContext, m as buildDiscordGroupSystemPrompt } from "./provider-CjI8BSzS.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 { 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 { agentCommandFromIngress, resolveAgentDir } from "openclaw/plugin-sdk/agent-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/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;
+	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 {
+			if (this.#buffer.length > 0) {
+				const frame = Buffer.alloc(DISCORD_OPUS_FRAME_BYTES);
+				this.#buffer.copy(frame);
+				this.#buffer = Buffer.alloc(0);
+				this.#encodeFrame(frame);
+			}
+			done();
+		} catch (err) {
+			done(err instanceof Error ? err : new Error(formatErrorMessage(err)));
+		}
+	}
+	_destroy(err, done) {
+		this.#encoder?.free();
+		this.#buffer = Buffer.alloc(0);
+		done(err);
+	}
+	#encodeFrame(frame) {
+		this.push(Buffer.from(this.#encoder.encode(frame, { frameSize: DISCORD_OPUS_FRAME_SIZE })));
+	}
+};
+function pcmInt16ToBuffer(pcm) {
+	return Buffer.from(pcm.buffer, pcm.byteOffset, pcm.byteLength);
+}
+async function decodeOpusStream(stream, params) {
+	const chunks = [];
+	await decodeOpusStreamChunks(stream, {
+		...params,
+		onChunk: (chunk) => chunks.push(chunk)
+	});
+	return Buffer.concat(chunks);
+}
+async function decodeOpusStreamChunks(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) params.onChunk(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/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/ingress.ts
 const DISCORD_VOICE_MESSAGE_PROVIDER = "discord-voice";
 const logger$7 = createSubsystemLogger("discord/voice");
@@ -84,7 +409,7 @@ async function runDiscordVoiceAgentTurn(params) {
 	});
 	if (!context) return null;
 	const voiceModel = normalizeOptionalString(params.discordConfig.voice?.model);
-	const payloads = (await agentCommandFromIngress({
+	const payloads = (await getDiscordRuntime().agent.runCommandFromIngress({
 		message: params.message,
 		sessionKey: params.entry.route.sessionKey,
 		agentId: params.entry.route.agentId,
@@ -1116,12 +1441,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();
@@ -1200,6 +1526,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(),
@@ -1281,16 +1608,24 @@ async function processDiscordVoiceSegment(params) {
 	}
 	params.enqueuePlayback(entry, async () => {
 		const voiceSdk = loadDiscordVoiceSdk();
+		const playbackLifecycle = new AbortController();
+		let playbackStarted = false;
+		const cancelStoppedPlayback = () => (!playbackStarted || entry.sessionLifecycle.status === "stopped") && playbackLifecycle.abort();
 		try {
 			if (entry.sessionLifecycle.status === "stopped") return;
+			entry.player.on(voiceSdk.AudioPlayerStatus.Idle, cancelStoppedPlayback);
 			const input = voiceReplyAudio.mode === "stream" ? Readable.fromWeb(voiceReplyAudio.audioStream) : voiceReplyAudio.audioPath;
 			logVoiceVerbose(`playback start: guild ${entry.guildId} channel ${entry.channelId} ${voiceReplyAudio.mode}`);
 			const resource = voiceSdk.createAudioResource(createDiscordOpusPlaybackStream(input), { inputType: voiceSdk.StreamType.Opus });
 			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);
+			await voiceSdk.entersState(entry.player, voiceSdk.AudioPlayerStatus.Playing, AbortSignal.any([AbortSignal.timeout(PLAYBACK_READY_TIMEOUT_MS), playbackLifecycle.signal]));
+			playbackStarted = true;
+			await voiceSdk.entersState(entry.player, voiceSdk.AudioPlayerStatus.Idle, playbackLifecycle.signal);
 			logVoiceVerbose(`playback done: guild ${entry.guildId} channel ${entry.channelId}`);
+		} catch (error) {
+			if (entry.sessionLifecycle.status !== "stopped") throw error;
 		} finally {
+			entry.player.off(voiceSdk.AudioPlayerStatus.Idle, cancelStoppedPlayback);
 			await releaseAudio?.();
 		}
 	});
@@ -1336,6 +1671,7 @@ var DiscordVoiceReceive = class {
 		}
 		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) {
@@ -1413,6 +1749,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,
@@ -1602,9 +1939,21 @@ var DiscordVoiceReceive = class {
 //#endregion
 //#region extensions/discord/src/voice/voice-session.ts
 const logger$2 = createSubsystemLogger("discord/voice");
+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;
 }
@@ -1691,7 +2040,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,10 +2103,7 @@ var DiscordVoiceSessions = class {
 		logVoiceVerbose(`join: DAVE settings encryption=${daveEncryption === false ? "off" : "on"} tolerance=${decryptionFailureTolerance ?? "default"} connectTimeout=${connectReadyTimeoutMs}ms reconnectGrace=${reconnectGraceMs}ms`);
 		const voiceSdk = loadDiscordVoiceSdk();
 		const existingEntry = this.params.sessions.get(guildId);
-		if (existingEntry) {
-			existingEntry.stop();
-			this.params.sessions.delete(guildId);
-		}
+		if (existingEntry) existingEntry.stop();
 		const voiceConnectionGroup = resolveVoiceConnectionGroup(this.params.accountId);
 		const staleConnection = voiceSdk.getVoiceConnection(guildId, voiceConnectionGroup);
 		if (staleConnection) destroyVoiceConnectionSafely({
@@ -1849,24 +2198,23 @@ var DiscordVoiceSessions = class {
 		}
 		const { route, voiceRoute, agentSessionMode, agentSessionTarget } = routeInfo;
 		logger$2.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?.speakerVoice ?? voiceConfig?.realtime?.speakerVoiceId ?? "provider-default"}`);
-		const player = voiceSdk.createAudioPlayer();
+		const player = isDiscordRealtimeVoiceMode(voiceMode) ? voiceSdk.createAudioPlayer({ behaviors: { maxMissedFrames: REALTIME_PLAYBACK_MAX_MISSED_FRAMES } }) : voiceSdk.createAudioPlayer();
 		connection.subscribe(player);
-		const clearSessionIfCurrent = () => {
-			if (this.params.sessions.get(guildId)?.connection === connection) this.params.sessions.delete(guildId);
-		};
-		const stopEntry = (entry, optionsLocal) => {
+		const stopEntry = (optionsLocal) => {
 			if (entry.sessionLifecycle.status === "stopped") return;
 			entry.sessionLifecycle = {
 				status: "stopped",
 				reason: optionsLocal.reason
 			};
+			retireTranscripts(entry);
+			if (this.params.sessions.get(guildId) === entry) this.params.sessions.delete(guildId);
 			this.params.membership.deactivate(entry);
-			if (speakingHandler) connection.receiver.speaking.off("start", speakingHandler);
-			if (speakingEndHandler) connection.receiver.speaking.off("end", speakingEndHandler);
+			connection.receiver.speaking.off("start", speakingHandler);
+			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);
+			connection.off(voiceSdk.VoiceConnectionStatus.Disconnected, disconnectedHandler);
+			connection.off(voiceSdk.VoiceConnectionStatus.Destroyed, destroyedHandler);
+			player.off("error", playerErrorHandler);
 			const realtimeLifecycle = entry.realtimeLifecycle;
 			if (realtimeLifecycle.status === "starting" || realtimeLifecycle.status === "active") realtimeLifecycle.instance.close();
 			entry.realtimeLifecycle = {
@@ -1874,7 +2222,7 @@ var DiscordVoiceSessions = class {
 				generation: realtimeLifecycle.generation,
 				reason: optionsLocal.reason
 			};
-			player.stop();
+			player.stop(true);
 			if (optionsLocal.destroyConnection) destroyVoiceConnectionSafely({
 				connection,
 				voiceSdk,
@@ -1906,41 +2254,12 @@ var DiscordVoiceSessions = class {
 				generation: 0
 			},
 			stop(reason) {
-				clearSessionIfCurrent();
-				stopEntry(entry, {
+				stopEntry({
 					destroyConnection: true,
 					reason: reason ?? `stop guild ${guildId} channel ${channelId}`
 				});
 			}
 		};
-		if (!options?.transcripts && isDiscordRealtimeVoiceMode(voiceMode)) {
-			const realtimeResult = await this.attachRealtimeSession(entry, voiceMode, { isCurrent: authority?.isCurrent });
-			if (!realtimeResult.ok) {
-				destroyVoiceConnectionSafely({
-					connection,
-					voiceSdk,
-					reason: `realtime setup failed guild ${guildId} channel ${channelId}`
-				});
-				return {
-					ok: false,
-					message: realtimeResult.message,
-					guildId,
-					channelId
-				};
-			}
-		}
-		if (this.params.destroyed() || authority && !authority.isCurrent()) {
-			stopEntry(entry, {
-				destroyConnection: true,
-				reason: `${this.params.destroyed() ? "manager stopped" : "join cancelled"} during setup guild ${guildId} channel ${channelId}`
-			});
-			return {
-				ok: false,
-				message: this.params.destroyed() ? "Discord voice manager is stopped." : "Discord voice join was cancelled.",
-				guildId,
-				channelId
-			};
-		}
 		const speakingHandler = (userId) => {
 			this.params.receive.handleSpeakingStart(entry, userId).catch((err) => {
 				logger$2.warn(`discord voice: capture failed: ${formatErrorMessage(err)}`);
@@ -1957,8 +2276,7 @@ var DiscordVoiceSessions = class {
 					logVoiceVerbose(`disconnected: recovery started guild ${guildId} channel ${channelId}`);
 				} catch (err) {
 					logger$2.warn(`discord voice: disconnect recovery failed: guild ${guildId} channel ${channelId} timeout=${reconnectGraceMs}ms error=${formatErrorMessage(err)}; destroying connection`);
-					clearSessionIfCurrent();
-					stopEntry(entry, {
+					stopEntry({
 						destroyConnection: true,
 						reason: `disconnect recovery failed guild ${guildId} channel ${channelId}`
 					});
@@ -1966,8 +2284,7 @@ var DiscordVoiceSessions = class {
 			})();
 		};
 		const destroyedHandler = () => {
-			clearSessionIfCurrent();
-			stopEntry(entry, {
+			stopEntry({
 				destroyConnection: false,
 				reason: `destroyed guild ${guildId} channel ${channelId}`
 			});
@@ -1975,12 +2292,33 @@ var DiscordVoiceSessions = class {
 		const playerErrorHandler = (err) => {
 			logger$2.warn(`discord voice: playback error: ${formatErrorMessage(err)}`);
 		};
-		this.params.receive.enableDaveReceivePassthrough(entry, "post-join warmup", 30);
-		connection.receiver.speaking.on("start", speakingHandler);
-		connection.receiver.speaking.on("end", speakingEndHandler);
 		connection.on(voiceSdk.VoiceConnectionStatus.Disconnected, disconnectedHandler);
 		connection.on(voiceSdk.VoiceConnectionStatus.Destroyed, destroyedHandler);
 		player.on("error", playerErrorHandler);
+		if (!options?.transcripts && isDiscordRealtimeVoiceMode(voiceMode)) {
+			const realtimeResult = await this.attachRealtimeSession(entry, voiceMode, { isCurrent: authority?.isCurrent });
+			if (!realtimeResult.ok) {
+				entry.stop(`realtime setup failed guild ${guildId} channel ${channelId}`);
+				return {
+					ok: false,
+					message: realtimeResult.message,
+					guildId,
+					channelId
+				};
+			}
+		}
+		if (isVoiceSessionStopped(entry) || this.params.destroyed() || authority && !authority.isCurrent()) {
+			entry.stop(`${this.params.destroyed() ? "manager stopped" : "join cancelled"} during setup guild ${guildId} channel ${channelId}`);
+			return {
+				ok: false,
+				message: this.params.destroyed() ? "Discord voice manager is stopped." : "Discord voice join was cancelled.",
+				guildId,
+				channelId
+			};
+		}
+		this.params.receive.enableDaveReceivePassthrough(entry, "post-join warmup", 30);
+		connection.receiver.speaking.on("start", speakingHandler);
+		connection.receiver.speaking.on("end", speakingEndHandler);
 		this.params.sessions.set(guildId, entry);
 		this.params.membership.activate(entry, this.params.botUserId());
 		logger$2.info(`discord voice: joined guild=${guildId} channel=${channelId} mode=${voiceMode} agent=${route.agentId} voiceSession=${voiceRoute.sessionKey} supervisorSession=${route.sessionKey} voiceModel=${voiceConfig?.model ?? "route-default"}`);
@@ -2011,7 +2349,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 })}.`,
@@ -2021,7 +2359,6 @@ var DiscordVoiceSessions = class {
 			}
 		}
 		entry.stop();
-		this.params.sessions.delete(guildId);
 		if (!entry.receiveRecovery.decryptRecoveryInFlight) this.params.receive.deleteRecoveryAttempt(guildId);
 		if (!options?.preserveFollowState) this.params.onLeaveFollowState(guildId);
 		logVoiceVerbose(`leave: disconnected from guild ${guildId} channel ${entry.channelId}`);
@@ -2042,7 +2379,7 @@ var DiscordVoiceSessions = class {
 			ok: false,
 			message: "Discord realtime voice session stopped before startup completed."
 		};
-		const { DiscordRealtimeVoiceSession } = await import("./realtime-session.runtime-ysbMG8v7.js");
+		const { DiscordRealtimeVoiceSession } = await import("./realtime-session.runtime-37IC-p5K.js");
 		const realtime = new DiscordRealtimeVoiceSession({
 			accountId: this.params.accountId,
 			bootstrapContextInstructions,
@@ -2146,6 +2483,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",
@@ -2546,4 +2890,4 @@ var DiscordVoiceManager = class {
 	}
 };
 //#endregion
-export { DiscordVoiceGuildCreateListener, DiscordVoiceManager, DiscordVoiceReadyListener, DiscordVoiceResumedListener, DiscordVoiceStateUpdateListener };
+export { DiscordVoiceGuildCreateListener, DiscordVoiceManager, DiscordVoiceReadyListener, DiscordVoiceResumedListener, DiscordVoiceStateUpdateListener, convertRealtimePcm24kMonoToDiscordPcm48kStereo as a, maybeControlDiscordVoiceAgentRun as c, convertDiscordPcm48kStereoToRealtimePcm24kMono as i, formatVoiceLogPreview as l, loadDiscordVoiceSdk as n, createDiscordOpusEncodeStream as o, logVoiceVerbose as r, formatVoiceIngressPrompt as s, voice_runtime_exports as t };

package/node_modules/@discord/embedded-app-sdk/node_modules/@types/lodash/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for lodash (https://lodash.com).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/lodash.
 
 ### Additional Details
- * Last updated: Mon, 23 Feb 2026 05:30:26 GMT
+ * Last updated: Sat, 01 Aug 2026 03:43:12 GMT
  * Dependencies: none
 
 # Credits