@openclaw/discord 2026.8.1-beta.2 → 2026.8.1

package/dist/{provider-session.runtime-BUEqD0rA.js → provider-session.runtime-DSNe7r2W.js}

@@ -1,6 +1,6 @@
-import { n as createThreadBindingManager, t as createNoopThreadBindingManager } from "./thread-bindings.manager-DCIH6WDC.js";
-import { a as reconcileAcpThreadBindingsOnStartup } from "./thread-bindings-3L8p82GV.js";
-import { t as createDiscordMessageHandler } from "./message-handler-Unk_f10F.js";
+import { n as createThreadBindingManager, t as createNoopThreadBindingManager } from "./thread-bindings.manager-Clm77DBM.js";
+import { a as reconcileAcpThreadBindingsOnStartup } from "./thread-bindings-DvYP79fy.js";
+import { t as createDiscordMessageHandler } from "./message-handler-C5By3yl5.js";
 import { resolveThreadBindingIdleTimeoutMs, resolveThreadBindingMaxAgeMs, resolveThreadBindingsEnabled } from "openclaw/plugin-sdk/conversation-runtime";
 import { getAcpSessionManager, isAcpRuntimeError } from "openclaw/plugin-sdk/acp-runtime";
 export { createDiscordMessageHandler, createNoopThreadBindingManager, createThreadBindingManager, getAcpSessionManager, isAcpRuntimeError, reconcileAcpThreadBindingsOnStartup, resolveThreadBindingIdleTimeoutMs, resolveThreadBindingMaxAgeMs, resolveThreadBindingsEnabled };

package/dist/provider.runtime-DiInaDXO.js

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

package/dist/{realtime-session.runtime-C7wen-aF.js → realtime-session.runtime-DOViOIjY.js}

@@ -1,9 +1,11 @@
-import { S as formatVoiceLogPreview, b as formatVoiceIngressPrompt, h as createDiscordOpusEncodeStream, m as convertRealtimePcm24kMonoToDiscordPcm48kStereo, p as convertDiscordPcm48kStereoToRealtimePcm24kMono, t as loadDiscordVoiceSdk, u as logVoiceVerbose, x as maybeControlDiscordVoiceAgentRun } from "./sdk-runtime-QpY8PvCh.js";
+import { n as discordRealtimeVoiceSecretOwnerId } from "./secret-config-contract-B3i6WxV5.js";
+import { b as maybeControlDiscordVoiceAgentRun, f as convertDiscordPcm48kStereoToRealtimePcm24kMono, l as logVoiceVerbose, m as createDiscordOpusEncodeStream, p as convertRealtimePcm24kMonoToDiscordPcm48kStereo, t as loadDiscordVoiceSdk, x as formatVoiceLogPreview, y as formatVoiceIngressPrompt } from "./sdk-runtime-6tfgYDjY.js";
 import { asDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/ssrf-runtime";
 import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
 import { sliceUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
-import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, REALTIME_VOICE_AGENT_CONTROL_TOOL, REALTIME_VOICE_AGENT_CONTROL_TOOL_NAME, REALTIME_VOICE_AUDIO_FORMAT_PCM16_24KHZ, buildRealtimeVoiceSessionInstructions, buildRealtimeVoiceSpeakExactMessage, classifyRealtimeVoiceConsultToolCall, classifySkippableRealtimeVoiceConsultTranscript, controlRealtimeVoiceAgentRun, createRealtimeVoiceAgentTalkbackQueue, createRealtimeVoiceSessionHarness, createRealtimeVoiceTurnContextTracker, isRealtimeVoiceWakeNameRequired, matchRealtimeVoiceActivationName, matchRealtimeVoiceConsultQuestions, parseRealtimeVoiceAgentControlToolArgs, resolveConfiguredRealtimeVoiceProvider, resolveRealtimeVoiceAgentConsultTools, resolveRealtimeVoiceBargeIn, resolveRealtimeVoiceInterruptResponseOnInputAudio, resolveRealtimeVoiceMinBargeInAudioEndMs, resolveRealtimeVoiceSessionPolicy } from "openclaw/plugin-sdk/realtime-voice";
+import { assertSecretOwnerAvailable, isSecretOwnerAvailable } from "openclaw/plugin-sdk/channel-secret-owner-runtime";
+import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, REALTIME_VOICE_AGENT_CONTROL_TOOL, REALTIME_VOICE_AGENT_CONTROL_TOOL_NAME, REALTIME_VOICE_AUDIO_FORMAT_PCM16_24KHZ, buildRealtimeVoiceSessionInstructions, buildRealtimeVoiceSpeakExactMessage, canonicalizeRealtimeVoiceProviderId, classifyRealtimeVoiceConsultToolCall, classifySkippableRealtimeVoiceConsultTranscript, controlRealtimeVoiceAgentRun, createRealtimeVoiceAgentTalkbackQueue, createRealtimeVoiceSessionHarness, createRealtimeVoiceTurnContextTracker, isRealtimeVoiceWakeNameRequired, matchRealtimeVoiceActivationName, matchRealtimeVoiceConsultQuestions, parseRealtimeVoiceAgentControlToolArgs, realtimeVoiceAudioDurationMs, resolveConfiguredRealtimeVoiceProvider, resolveRealtimeVoiceAgentConsultTools, resolveRealtimeVoiceBargeIn, resolveRealtimeVoiceInterruptResponseOnInputAudio, resolveRealtimeVoiceMinBargeInAudioEndMs, resolveRealtimeVoiceSessionPolicy } from "openclaw/plugin-sdk/realtime-voice";
 import { PassThrough, pipeline } from "node:stream";
 //#region extensions/discord/src/voice/realtime-transcript.ts
 function mergeRealtimePartialTranscript(previous, next) {
@@ -17,7 +19,7 @@ const logger$3 = createSubsystemLogger("discord/voice");
 const DISCORD_REALTIME_PENDING_SPEAKER_CONTEXT_LIMIT = 32;
 const DISCORD_REALTIME_IGNORED_WAKE_NAME_CONTEXT_TTL_MS = 1e4;
 const DISCORD_REALTIME_WAKE_NAME_FOLLOWUP_TTL_MS = 1e4;
-const REALTIME_PCM16_BYTES_PER_SAMPLE$1 = 2;
+const REALTIME_PCM16_BYTES_PER_SAMPLE = 2;
 const DISCORD_REALTIME_TRAILING_SILENCE_MIN_MS = 700;
 const DISCORD_REALTIME_TRAILING_SILENCE_MAX_MS = 3e3;
 var DiscordRealtimeTurns = class {
@@ -37,6 +39,7 @@ var DiscordRealtimeTurns = class {
 			...context,
 			userId
 		}, {
+			transcripts: this.params.entry.transcripts,
 			inputDiscordBytes: 0,
 			inputRealtimeBytes: 0,
 			inputChunks: 0,
@@ -153,7 +156,7 @@ var DiscordRealtimeTurns = class {
 		const providerId = this.params.providerId() ?? this.params.realtimeConfig()?.provider ?? "openai";
 		const rawSilenceDurationMs = (this.params.realtimeConfig()?.providers?.[providerId])?.silenceDurationMs;
 		const silenceMs = Math.min(DISCORD_REALTIME_TRAILING_SILENCE_MAX_MS, Math.max(DISCORD_REALTIME_TRAILING_SILENCE_MIN_MS, typeof rawSilenceDurationMs === "number" && Number.isFinite(rawSilenceDurationMs) ? rawSilenceDurationMs : 0));
-		const silenceBytes = Math.ceil(24e3 * silenceMs / 1e3) * REALTIME_PCM16_BYTES_PER_SAMPLE$1;
+		const silenceBytes = Math.ceil(24e3 * silenceMs / 1e3) * REALTIME_PCM16_BYTES_PER_SAMPLE;
 		const silence = Buffer.alloc(silenceBytes);
 		bridge.sendAudio(silence);
 		logger$3.info(`discord voice: realtime trailing silence sent guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} user=${turn.context.userId} speaker=${turn.context.speakerLabel} silenceMs=${silenceMs} realtimeBytes=${silence.length}`);
@@ -183,12 +186,13 @@ var DiscordRealtimeTurns = class {
 	transcriptAttributionFromTurn(turn) {
 		return turn ? {
 			context: turn.context,
-			startedAt: turn.startedAt
+			startedAt: turn.startedAt,
+			transcripts: turn.transcripts
 		} : void 0;
 	}
 	recordTranscriptUtterance(text, attribution, providerEpoch) {
-		const transcripts = this.params.entry.transcripts;
-		if (!transcripts || !attribution) return;
+		const transcripts = attribution?.transcripts;
+		if (!transcripts || !attribution || this.params.entry.transcripts !== transcripts) return;
 		const context = attribution.context;
 		const utterance = {
 			sessionId: transcripts.sessionId,
@@ -207,7 +211,7 @@ var DiscordRealtimeTurns = class {
 			}
 		};
 		Promise.resolve().then(() => {
-			if (providerEpoch !== this.params.providerEpoch()) return;
+			if (providerEpoch !== this.params.providerEpoch() || this.params.entry.transcripts !== transcripts) return;
 			return transcripts.onUtterance(utterance);
 		}).catch((error) => {
 			logger$3.warn(`discord voice: realtime transcripts utterance failed: ${formatErrorMessage(error)}`);
@@ -224,6 +228,7 @@ var DiscordRealtimeTurns = class {
 		if (expiresAt === void 0) return;
 		this.pendingWakeNameFollowup = {
 			context,
+			transcripts: turn?.transcripts,
 			startedAt: turn?.startedAt ?? Date.now(),
 			expiresAt
 		};
@@ -240,7 +245,8 @@ var DiscordRealtimeTurns = class {
 		if (currentTurn) this.consumePendingSpeakerContext();
 		return {
 			context: pending.context,
-			startedAt: pending.startedAt
+			startedAt: pending.startedAt,
+			transcripts: pending.transcripts
 		};
 	}
 	rememberIgnoredWakeNameSpeakerContext(context) {
@@ -356,7 +362,9 @@ var DiscordRealtimeConsults = class {
 		await session.submitToolResult(callId, { text });
 	}
 	async handleAcceptedTranscript(acceptedText, forcedSpeakerContext, providerEpoch) {
-		const pendingForcedConsult = this.params.isAgentProxy && this.params.usesRealtimeAgentHandoff() ? this.prepareForcedAgentProxyConsult(acceptedText, forcedSpeakerContext) : void 0;
+		const usesRealtimeAgentHandoff = this.params.usesRealtimeAgentHandoff();
+		const fallbackSpeakerContext = this.params.isAgentProxy && !usesRealtimeAgentHandoff ? forcedSpeakerContext ?? this.params.turns.consumePendingSpeakerContext() : void 0;
+		const pendingForcedConsult = this.params.isAgentProxy && usesRealtimeAgentHandoff ? this.prepareForcedAgentProxyConsult(acceptedText, forcedSpeakerContext) : void 0;
 		let control;
 		try {
 			control = await maybeControlDiscordVoiceAgentRun({
@@ -376,11 +384,11 @@ var DiscordRealtimeConsults = class {
 			return;
 		}
 		if (!this.params.isAgentProxy) return;
-		if (this.params.usesRealtimeAgentHandoff()) {
+		if (usesRealtimeAgentHandoff) {
 			if (pendingForcedConsult) this.schedulePreparedForcedAgentProxyConsult(pendingForcedConsult);
 			return;
 		}
-		this.talkback.enqueue(acceptedText, forcedSpeakerContext ?? this.params.turns.consumePendingSpeakerContext());
+		this.talkback.enqueue(acceptedText, fallbackSpeakerContext);
 	}
 	createTalkbackQueue() {
 		const providerEpoch = this.params.providerEpoch();
@@ -600,11 +608,11 @@ var DiscordRealtimeConsults = class {
 			if (providerOwnsDelivery) {
 				state.handledByForcedPlayback = false;
 				state.settleProviderDelivery = void 0;
-				resolveProviderDelivery?.(true);
+				resolveProviderDelivery?.();
 			}
 		} catch (error) {
 			state.settleProviderDelivery = void 0;
-			resolveProviderDelivery?.(false);
+			resolveProviderDelivery?.();
 			throw error;
 		}
 		return true;
@@ -614,7 +622,7 @@ var DiscordRealtimeConsults = class {
 			const state = handle.context;
 			if (!state) continue;
 			state.handledByForcedPlayback = false;
-			state.settleProviderDelivery?.(false);
+			state.settleProviderDelivery?.();
 			state.settleProviderDelivery = void 0;
 			state.providerDelivery = void 0;
 		}
@@ -625,35 +633,27 @@ var DiscordRealtimeConsults = class {
 //#region extensions/discord/src/voice/realtime-playback.ts
 const logger$1 = createSubsystemLogger("discord/voice");
 const DISCORD_REALTIME_CONTROL_SPEECH_DEDUPE_MS = 5e3;
-const DISCORD_REALTIME_OUTPUT_PLAYBACK_WATCHDOG_MARGIN_MS = 1500;
+const DISCORD_REALTIME_OUTPUT_PLAYBACK_WATCHDOG_MARGIN_MS = 3e3;
 const DISCORD_REALTIME_MAX_RETAINED_EXACT_SPEECH_MESSAGES = 32;
 const DISCORD_REALTIME_MAX_RETAINED_EXACT_SPEECH_BYTES = 32 * 1024;
-const DISCORD_REALTIME_CANCELLATION_RACE_DETAIL = "Cancellation failed: no active response found";
 const DISCORD_REALTIME_WAKE_ACKS = [
 	"Yeah.",
 	"Mm-hmm.",
 	"Got it.",
 	"One sec."
 ];
-const REALTIME_PCM16_BYTES_PER_SAMPLE = 2;
 const DISCORD_RAW_PCM_FRAME_BYTES = 3840;
 const DISCORD_REALTIME_OUTPUT_PREROLL_FRAMES = 25;
-function isRealtimeResponseCancellationRace(event) {
-	return event.direction === "server" && event.type === "error" && event.detail === DISCORD_REALTIME_CANCELLATION_RACE_DETAIL;
-}
+const DISCORD_REALTIME_MAX_PENDING_OUTPUT_BYTES = DISCORD_RAW_PCM_FRAME_BYTES * 6e3;
 function normalizeControlSpeechText(text) {
 	return text.toLowerCase().replace(/\s+/g, " ").trim();
 }
-function pcm16MonoDurationMs(audio, sampleRate) {
-	if (audio.length === 0 || sampleRate <= 0) return 0;
-	return audio.length / REALTIME_PCM16_BYTES_PER_SAMPLE * 1e3 / sampleRate;
-}
 var DiscordRealtimePlayback = class {
 	constructor(params) {
 		this.params = params;
 		this.outputStream = null;
-		this.outputPacedBuffer = Buffer.alloc(0);
-		this.playbackState = { status: "idle" };
+		this.outputPacedBuffers = [];
+		this.outputPacedBytes = 0;
 		this.queuedExactSpeechMessages = [];
 		this.exactSpeechState = { status: "idle" };
 		this.wakeNameAckIndex = 0;
@@ -668,7 +668,6 @@ var DiscordRealtimePlayback = class {
 		this.params.entry.player.on(voiceSdk.AudioPlayerStatus.Idle, this.playerIdleHandler);
 	}
 	close() {
-		this.playbackState = { status: "idle" };
 		this.queuedExactSpeechMessages = [];
 		this.exactSpeechState = { status: "idle" };
 		this.clearOutputAudio("session-close");
@@ -703,7 +702,7 @@ var DiscordRealtimePlayback = class {
 	}
 	sendOutputAudio(realtimePcm24kMono) {
 		this.params.markProviderGenerationObserved();
-		if (this.params.stopped() || this.playbackState.status === "backpressured") return;
+		if (this.params.stopped()) return;
 		const discordPcm = convertRealtimePcm24kMonoToDiscordPcm48kStereo(realtimePcm24kMono);
 		if (discordPcm.length === 0) return;
 		this.params.bridge()?.setMediaTimestamp(this.outputAudioMs());
@@ -717,7 +716,7 @@ var DiscordRealtimePlayback = class {
 			audioStarted: true
 		};
 		this.params.harness.recordOutputAudio(realtimePcm24kMono, {
-			audioMs: pcm16MonoDurationMs(realtimePcm24kMono, 24e3),
+			audioMs: realtimeVoiceAudioDurationMs(REALTIME_VOICE_AUDIO_FORMAT_PCM16_24KHZ, realtimePcm24kMono.byteLength),
 			sourceAudioBytes: realtimePcm24kMono.length,
 			sinkAudioBytes: discordPcm.length
 		});
@@ -741,19 +740,10 @@ var DiscordRealtimePlayback = class {
 			this.completeExactSpeechResponse(reason);
 			return;
 		}
-		stream.end();
-	}
-	handleProviderEvent(event) {
-		if (!(this.playbackState.status === "backpressured" && isRealtimeResponseCancellationRace(event))) return;
-		const outputBackpressured = this.playbackState.status === "backpressured";
-		if (outputBackpressured) this.playbackState = { status: "idle" };
-		if (this.exactSpeechState.status === "active" && (outputBackpressured || !this.exactSpeechState.audioStarted)) this.completeExactSpeechResponse(event.type);
-		this.finishOutputAudioStream(event.type, { playBuffered: false });
+		if (!this.outputDrainHandler) stream.end();
 	}
 	handleResponseDone(outcome) {
-		const outputBackpressured = this.playbackState.status === "backpressured";
-		if (outputBackpressured) this.playbackState = { status: "idle" };
-		if (this.exactSpeechState.status === "active" && (outputBackpressured || !this.exactSpeechState.audioStarted)) this.completeExactSpeechResponse(outcome.status);
+		if (this.exactSpeechState.status === "active" && !this.exactSpeechState.audioStarted) this.completeExactSpeechResponse(outcome.status);
 		this.finishOutputAudioStream(outcome.status, { playBuffered: outcome.status === "completed" });
 	}
 	enqueueExactSpeechMessage(text) {
@@ -762,11 +752,7 @@ var DiscordRealtimePlayback = class {
 		const retainedBytes = this.queuedExactSpeechMessages.reduce((total, message) => total + Buffer.byteLength(message, "utf8"), 0) + Buffer.byteLength(this.exactSpeechState.status === "active" ? this.exactSpeechState.message : "", "utf8");
 		const incomingBytes = Buffer.byteLength(text, "utf8");
 		if (retainedMessages >= DISCORD_REALTIME_MAX_RETAINED_EXACT_SPEECH_MESSAGES || retainedBytes + incomingBytes > DISCORD_REALTIME_MAX_RETAINED_EXACT_SPEECH_BYTES) {
-			this.params.stopTerminally();
-			this.queuedExactSpeechMessages = [];
-			this.exactSpeechState = { status: "idle" };
-			this.clearOutputAudio("exact-speech-overflow");
-			this.params.onTerminalError(/* @__PURE__ */ new Error(`Discord realtime exact speech overflow: retained=${retainedMessages} retainedBytes=${retainedBytes} incomingBytes=${incomingBytes}`));
+			this.stopAfterOverflow("exact-speech-overflow", /* @__PURE__ */ new Error(`Discord realtime exact speech overflow: retained=${retainedMessages} retainedBytes=${retainedBytes} incomingBytes=${incomingBytes}`));
 			return;
 		}
 		if (!this.params.bridgeReady() || this.exactSpeechState.status === "active" || this.hasInterruptibleOutputAudio()) {
@@ -846,84 +832,83 @@ var DiscordRealtimePlayback = class {
 	currentOutputStream() {
 		return this.outputStream;
 	}
+	stopAfterOverflow(reason, error) {
+		this.params.stopTerminally();
+		this.queuedExactSpeechMessages = [];
+		this.exactSpeechState = { status: "idle" };
+		this.clearOutputAudio(reason);
+		this.params.onTerminalError(error);
+	}
 	ensureOutputStream() {
 		if (this.outputStream && !this.outputStream.destroyed && !this.outputStream.writableEnded) return this.outputStream;
 		const stream = new PassThrough({ highWaterMark: DISCORD_RAW_PCM_FRAME_BYTES * 128 });
 		this.outputStream = stream;
-		this.playbackState = {
-			status: "buffering",
-			stream
-		};
-		this.outputPacedBuffer = Buffer.alloc(0);
+		this.outputPacedBuffers = [];
+		this.outputPacedBytes = 0;
 		this.params.harness.outputActivity.markStreamOpened();
 		stream.once("close", () => {
-			if (this.params.harness.outputActivity.snapshot().playbackStarted) return;
-			this.handleOutputStreamClosed(stream, "stream-close");
+			if (this.outputStream !== stream || this.params.harness.outputActivity.snapshot().playbackStarted) return;
+			this.resetOutputStream("stream-close");
+			this.completeExactSpeechResponse("stream-close");
 		});
 		return stream;
 	}
-	handleOutputStreamClosed(stream, reason) {
-		if (this.outputStream !== stream) return;
-		this.logOutputAudioStopped(reason);
-		this.clearOutputPlaybackWatchdog();
-		this.outputStream = null;
-		if (this.playbackState.status !== "backpressured") this.playbackState = { status: "idle" };
-		this.outputPacedBuffer = Buffer.alloc(0);
-		this.params.harness.outputActivity.reset();
-		this.completeExactSpeechResponse(reason);
-	}
 	queueOutputAudio(stream, discordPcm) {
-		if (this.playbackState.status === "playing") {
-			if (!stream.write(discordPcm)) this.handleOutputBackpressure(stream);
+		const pendingBytes = this.outputPacedBytes + stream.writableLength + stream.readableLength;
+		if (discordPcm.length > DISCORD_REALTIME_MAX_PENDING_OUTPUT_BYTES - pendingBytes) {
+			this.stopAfterOverflow("output-audio-overflow", /* @__PURE__ */ new Error(`Discord realtime audio playback overflow: pendingBytes=${pendingBytes} incomingBytes=${discordPcm.length}`));
+			return;
+		}
+		if (this.params.harness.outputActivity.snapshot().playbackStarted && !this.outputDrainHandler) {
+			if (!stream.write(discordPcm)) this.waitForOutputDrain(stream);
 			return;
 		}
-		this.outputPacedBuffer = this.outputPacedBuffer.length > 0 ? Buffer.concat([this.outputPacedBuffer, discordPcm]) : discordPcm;
-		if (this.outputPacedBuffer.length >= DISCORD_RAW_PCM_FRAME_BYTES * DISCORD_REALTIME_OUTPUT_PREROLL_FRAMES) this.startOutputPlayback(stream);
-	}
-	handleOutputBackpressure(stream) {
-		if (this.playbackState.status === "backpressured" || this.outputStream !== stream) return;
-		const token = Symbol("output-backpressure");
-		this.playbackState = {
-			status: "backpressured",
-			stream,
-			token
+		this.outputPacedBuffers.push(discordPcm);
+		this.outputPacedBytes += discordPcm.length;
+		if (!this.outputDrainHandler && this.outputPacedBytes >= DISCORD_RAW_PCM_FRAME_BYTES * DISCORD_REALTIME_OUTPUT_PREROLL_FRAMES) this.startOutputPlayback(stream);
+	}
+	waitForOutputDrain(stream) {
+		if (this.outputDrainHandler || this.outputStream !== stream) return;
+		logger$1.info(`discord voice: realtime audio playback buffering guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} bufferedBytes=${stream.writableLength + stream.readableLength}`);
+		this.outputDrainHandler = () => {
+			if (this.params.stopped() || this.outputStream !== stream || stream.destroyed) return;
+			this.outputDrainHandler = void 0;
+			let refreshWatchdog = this.params.harness.outputActivity.snapshot().streamEnding;
+			while (this.outputPacedBuffers.length > 0) {
+				const buffered = this.outputPacedBuffers.shift();
+				if (!buffered) break;
+				this.outputPacedBytes -= buffered.length;
+				const writable = stream.write(buffered);
+				if (refreshWatchdog) {
+					this.scheduleOutputPlaybackWatchdog("output-drain", stream);
+					refreshWatchdog = false;
+				}
+				if (!writable) {
+					this.waitForOutputDrain(stream);
+					return;
+				}
+			}
+			if (this.params.harness.outputActivity.snapshot().streamEnding) stream.end();
 		};
-		const bufferedBytes = stream.writableLength + stream.readableLength;
-		logger$1.warn(`discord voice: realtime audio playback backpressured guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} bufferedBytes=${bufferedBytes}`);
-		this.clearOutputAudio("output-backpressure");
-		queueMicrotask(() => {
-			if (this.params.stopped() || this.playbackState.status !== "backpressured" || this.playbackState.token !== token) return;
-			this.params.harness.handleBargeIn({
-				audioPlaybackActive: true,
-				force: true
-			}, () => {});
-		});
+		stream.once("drain", this.outputDrainHandler);
 	}
 	startOutputPlayback(stream) {
 		if (this.params.harness.outputActivity.snapshot().playbackStarted || stream.destroyed) return;
 		const voiceSdk = loadDiscordVoiceSdk();
 		const opusStream = createDiscordOpusEncodeStream();
-		opusStream.on("error", (err) => {
-			logger$1.warn(`discord voice: realtime opus encode failed guild=${this.params.entry.guildId} channel=${this.params.entry.channelId}: ${formatErrorMessage(err)}`);
-			this.resetOutputStream("opus-encode-error");
-		});
-		opusStream.once("close", () => this.handleOutputStreamClosed(stream, "stream-close"));
 		pipeline(stream, opusStream, (err) => {
-			if (!err) return;
+			if (!err || this.outputStream !== stream) return;
 			logger$1.warn(`discord voice: realtime output pipeline failed guild=${this.params.entry.guildId} channel=${this.params.entry.channelId}: ${formatErrorMessage(err)}`);
-			this.resetOutputStream("output-pipeline-error");
+			this.clearOutputAudio("output-pipeline-error");
+			this.completeExactSpeechResponse("output-pipeline-error");
 		});
-		if (this.outputPacedBuffer.length > 0) {
-			stream.write(this.outputPacedBuffer);
-			this.outputPacedBuffer = Buffer.alloc(0);
-		}
+		const buffered = Buffer.concat(this.outputPacedBuffers, this.outputPacedBytes);
+		this.outputPacedBuffers = [];
+		this.outputPacedBytes = 0;
+		if (buffered.length > 0 && !stream.write(buffered)) this.waitForOutputDrain(stream);
 		const resource = voiceSdk.createAudioResource(opusStream, { inputType: voiceSdk.StreamType.Opus });
 		this.params.entry.player.play(resource);
 		this.params.harness.outputActivity.markPlaybackStarted();
-		this.playbackState = {
-			status: "playing",
-			stream
-		};
 		const realtimeConfig = this.params.realtimeConfig();
 		logger$1.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?.speakerVoice ?? realtimeConfig?.speakerVoiceId ?? "provider-default"}`);
 	}
@@ -932,15 +917,22 @@ var DiscordRealtimePlayback = class {
 		this.clearOutputPlaybackWatchdog();
 		this.logOutputAudioStopped(reason);
 		this.outputStream = null;
-		if (this.playbackState.status !== "backpressured") this.playbackState = { status: "idle" };
-		this.outputPacedBuffer = Buffer.alloc(0);
+		this.outputPacedBuffers = [];
+		this.outputPacedBytes = 0;
+		if (this.outputDrainHandler) {
+			stream?.off("drain", this.outputDrainHandler);
+			this.outputDrainHandler = void 0;
+		}
 		this.params.harness.outputActivity.reset();
 		stream?.end();
 		stream?.destroy();
 	}
 	scheduleOutputPlaybackWatchdog(reason, stream) {
 		this.clearOutputPlaybackWatchdog();
-		const timeoutMs = this.params.harness.outputActivity.playbackWatchdogDelayMs({ marginMs: DISCORD_REALTIME_OUTPUT_PLAYBACK_WATCHDOG_MARGIN_MS });
+		const timeoutMs = this.params.harness.outputActivity.playbackWatchdogDelayMs({
+			marginMs: DISCORD_REALTIME_OUTPUT_PLAYBACK_WATCHDOG_MARGIN_MS,
+			minMs: DISCORD_REALTIME_OUTPUT_PLAYBACK_WATCHDOG_MARGIN_MS
+		});
 		if (timeoutMs === void 0) return;
 		this.outputPlaybackWatchdog = setTimeout(() => {
 			this.outputPlaybackWatchdog = void 0;
@@ -1030,7 +1022,6 @@ var DiscordRealtimeVoiceSession = class {
 			status: "inactive",
 			generation: 0
 		};
-		this.nextLifecycleGeneration = 0;
 		this.consultToolPolicy = "safe-read-only";
 		this.consultPolicy = "auto";
 		this.wakeNamePolicy = "never";
@@ -1073,7 +1064,7 @@ var DiscordRealtimeVoiceSession = class {
 			providerId: () => this.realtimeProviderId,
 			realtimeConfig: () => this.realtimeConfig,
 			stopTerminally: () => {
-				this.stopLifecycle("exact-speech overflow");
+				this.lifecycle.status = "stopped";
 				this.consults.close();
 			},
 			stopped: () => this.isStopped(),
@@ -1112,20 +1103,30 @@ var DiscordRealtimeVoiceSession = class {
 		});
 	}
 	async connect() {
-		const lifecycleGeneration = ++this.nextLifecycleGeneration;
+		const lifecycleGeneration = this.lifecycle.generation + 1;
 		this.lifecycle = {
 			status: "starting",
-			generation: lifecycleGeneration,
-			instance: this
+			generation: lifecycleGeneration
 		};
+		const configuredProviderId = this.realtimeConfig?.provider?.trim();
+		if (configuredProviderId) {
+			const ownerProviderIds = /* @__PURE__ */ new Set([configuredProviderId]);
+			const canonicalProviderId = canonicalizeRealtimeVoiceProviderId(configuredProviderId, this.params.cfg);
+			if (canonicalProviderId) ownerProviderIds.add(canonicalProviderId);
+			for (const providerId of ownerProviderIds) assertSecretOwnerAvailable("capability", discordRealtimeVoiceSecretOwnerId(this.params.accountId, providerId));
+		}
 		const resolved = resolveConfiguredRealtimeVoiceProvider({
 			configuredProviderId: this.realtimeConfig?.provider,
 			providerConfigs: buildProviderConfigs(this.realtimeConfig),
 			providerConfigOverrides: buildProviderConfigOverrides(this.realtimeConfig),
 			cfg: this.params.cfg,
+			agentId: this.params.entry.route.agentId,
 			defaultModel: this.realtimeConfig?.model,
+			isProviderAvailable: (provider) => isSecretOwnerAvailable("capability", discordRealtimeVoiceSecretOwnerId(this.params.accountId, provider.id)),
+			assertProviderAvailable: (provider) => assertSecretOwnerAvailable("capability", discordRealtimeVoiceSecretOwnerId(this.params.accountId, provider.id)),
 			noRegisteredProviderMessage: "No configured realtime voice provider registered"
 		});
+		assertSecretOwnerAvailable("capability", discordRealtimeVoiceSecretOwnerId(this.params.accountId, resolved.provider.id));
 		this.realtimeProviderId = resolved.provider.id;
 		const isAgentProxy = isDiscordAgentProxyVoiceMode(this.params.mode);
 		const { toolPolicy, consultToolsAllow, consultPolicy, wakeNamePolicy, wakeNames, autoRespondToAudio } = resolveRealtimeVoiceSessionPolicy({
@@ -1158,9 +1159,14 @@ var DiscordRealtimeVoiceSession = class {
 			toolPolicy,
 			consultPolicy
 		});
+		const onReady = () => {
+			this.markProviderGenerationObserved();
+			if (this.markLifecycleReady(lifecycleGeneration)) this.playback.drainQueuedExactSpeechMessages("provider-ready");
+		};
 		this.bridge = this.harness.createBridge({
 			provider: resolved.provider,
 			cfg: this.params.cfg,
+			agentId: this.params.entry.route.agentId,
 			providerConfig: resolved.providerConfig,
 			audioFormat: REALTIME_VOICE_AUDIO_FORMAT_PCM16_24KHZ,
 			instructions,
@@ -1191,11 +1197,11 @@ var DiscordRealtimeVoiceSession = class {
 				this.markProviderGenerationObserved();
 				return this.consults.handleToolCall(event, session);
 			},
-			onReady: () => {
-				this.markProviderGenerationObserved();
-				if (this.markLifecycleReady(lifecycleGeneration)) this.playback.drainQueuedExactSpeechMessages("provider-ready");
+			onReady,
+			onEvent: (event) => {
+				this.handleBridgeEvent(event);
+				if (event.direction === "client" && event.type === "session.reconnect.ready") onReady();
 			},
-			onEvent: (event) => this.handleBridgeEvent(event),
 			onResponseDone: (outcome) => {
 				this.markProviderGenerationObserved();
 				this.playback.handleResponseDone(outcome);
@@ -1204,10 +1210,16 @@ var DiscordRealtimeVoiceSession = class {
 			},
 			onError: (error) => this.logRealtimeError(formatErrorMessage(error)),
 			onClose: (reason) => {
-				this.flushSuppressedRealtimeErrors();
-				logVoiceVerbose(`realtime closed: ${reason}`);
+				if (!this.isStopped()) {
+					this.lifecycle.status = "stopped";
+					this.params.onTerminalError(/* @__PURE__ */ new Error(`Realtime provider closed unexpectedly: ${reason}`));
+				}
 			}
 		});
+		if (this.isStopped()) {
+			this.close();
+			return;
+		}
 		const resolvedModel = readProviderConfigString(resolved.providerConfig, "model") ?? resolved.provider.defaultModel;
 		const resolvedVoice = readProviderConfigString(resolved.providerConfig, "voice");
 		const humanParticipantCount = this.humanParticipantCount();
@@ -1223,7 +1235,7 @@ var DiscordRealtimeVoiceSession = class {
 		logger.info(`discord voice: realtime bridge ready mode=${this.params.mode} provider=${resolved.provider.id} model=${resolvedModel ?? "default"} voice=${resolvedVoice ?? "default"}`);
 	}
 	close() {
-		this.stopLifecycle("session close");
+		this.lifecycle.status = "stopped";
 		this.providerContinuityEpoch += 1;
 		this.flushSuppressedRealtimeErrors();
 		this.consults.close();
@@ -1255,21 +1267,9 @@ var DiscordRealtimeVoiceSession = class {
 	}
 	markLifecycleReady(generation) {
 		if (this.lifecycle.status !== "starting" && this.lifecycle.status !== "active" || this.lifecycle.generation !== generation) return false;
-		this.lifecycle = {
-			status: "active",
-			generation,
-			instance: this
-		};
+		this.lifecycle.status = "active";
 		return true;
 	}
-	stopLifecycle(reason) {
-		const generation = this.lifecycle.generation;
-		this.lifecycle = {
-			status: "stopped",
-			generation,
-			reason
-		};
-	}
 	humanParticipantCount() {
 		return this.params.getHumanParticipantCount?.() ?? 0;
 	}
@@ -1282,7 +1282,6 @@ var DiscordRealtimeVoiceSession = class {
 		if (event.direction === "client" && event.type === "session.continuity.reset") this.resetProviderContinuity(event.type);
 		if (event.direction === "server" && event.type === "input_audio_buffer.speech_started") this.turns.resetPartialWakeNameTracking();
 		if (shouldLogRealtimeVerboseEvent(event)) logVoiceVerbose(`realtime ${event.direction}:${event.type}${detail}`);
-		this.playback.handleProviderEvent(event);
 		const interruptionLog = formatRealtimeInterruptionLog(event);
 		if (interruptionLog) logger.info(interruptionLog);
 		const lifecycleLog = formatRealtimeLifecycleLog(event);
@@ -1294,11 +1293,7 @@ var DiscordRealtimeVoiceSession = class {
 	resetProviderContinuity(reason) {
 		if (!this.providerGenerationObserved) return;
 		this.providerGenerationObserved = false;
-		if (this.lifecycle.status === "active") this.lifecycle = {
-			status: "starting",
-			generation: this.lifecycle.generation,
-			instance: this
-		};
+		if (this.lifecycle.status === "active") this.lifecycle.status = "starting";
 		this.providerContinuityEpoch += 1;
 		this.consults.resetProviderContinuity();
 		this.turns.resetProviderContinuity();

package/dist/{resolve-allowlist-common-D04lpEzb.js → resolve-allowlist-common-BLoYaxEG.js}

@@ -1,6 +1,6 @@
-import { p as normalizeDiscordToken } from "./accounts-DJTf1LtA.js";
+import { m as normalizeDiscordToken } from "./accounts-CfQ-vSyf.js";
 import { r as fetchDiscord } from "./api-DNVbJyEy.js";
-import { a as normalizeDiscordSlug } from "./allow-list-DnxIlPP2.js";
+import { a as normalizeDiscordSlug } from "./allow-list-BDMimASD.js";
 //#region extensions/discord/src/guilds.ts
 async function listGuilds(token, fetcher, options) {
 	return (await fetchDiscord("/users/@me/guilds", token, fetcher, options)).filter((guild) => typeof guild.id === "string" && typeof guild.name === "string").map((guild) => ({

package/dist/{resolve-channels-Dm7jEeg6.js → resolve-channels-D2yl_2CN.js}

@@ -1,7 +1,8 @@
-import { tn as __exportAll } from "./retry-CLpJcXXf.js";
+import { on as __exportAll } from "./retry-DqHCW6PV.js";
 import { n as DiscordApiError, r as fetchDiscord, t as DISCORD_DIRECTORY_LOOKUP_TIMEOUT_MS } from "./api-DNVbJyEy.js";
-import { a as normalizeDiscordSlug } from "./allow-list-DnxIlPP2.js";
-import { i as listGuilds, n as filterDiscordGuilds, r as resolveDiscordAllowlistToken, t as buildDiscordUnresolvedResults } from "./resolve-allowlist-common-D04lpEzb.js";
+import { a as normalizeDiscordSlug } from "./allow-list-BDMimASD.js";
+import { t as isDiscordThreadChannelType } from "./channel-type-CVLZyGYS.js";
+import { i as listGuilds, n as filterDiscordGuilds, r as resolveDiscordAllowlistToken, t as buildDiscordUnresolvedResults } from "./resolve-allowlist-common-BLoYaxEG.js";
 //#region extensions/discord/src/resolve-channels.ts
 var resolve_channels_exports = /* @__PURE__ */ __exportAll({ resolveDiscordChannelAllowlist: () => resolveDiscordChannelAllowlist });
 function parseDiscordChannelInput(raw) {
@@ -79,7 +80,7 @@ async function fetchChannel(token, fetcher, channelId) {
 function preferActiveMatch(candidates) {
 	if (candidates.length === 0) return;
 	const scored = candidates.map((channel) => {
-		const isThread = channel.type === 11 || channel.type === 12;
+		const isThread = isDiscordThreadChannelType(channel.type);
 		return {
 			channel,
 			score: (Boolean(channel.archived) ? 0 : 2) + (isThread ? 0 : 1)

package/dist/{resolve-users-bktrCUUU.js → resolve-users-BLxfqajZ.js}

@@ -1,6 +1,6 @@
-import { tn as __exportAll } from "./retry-CLpJcXXf.js";
+import { on as __exportAll } from "./retry-DqHCW6PV.js";
 import { r as fetchDiscord, t as DISCORD_DIRECTORY_LOOKUP_TIMEOUT_MS } from "./api-DNVbJyEy.js";
-import { i as listGuilds, n as filterDiscordGuilds, r as resolveDiscordAllowlistToken, t as buildDiscordUnresolvedResults } from "./resolve-allowlist-common-D04lpEzb.js";
+import { i as listGuilds, n as filterDiscordGuilds, r as resolveDiscordAllowlistToken, t as buildDiscordUnresolvedResults } from "./resolve-allowlist-common-BLoYaxEG.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/discord/src/resolve-users.ts
 var resolve_users_exports = /* @__PURE__ */ __exportAll({ resolveDiscordUserAllowlist: () => resolveDiscordUserAllowlist });