@openclaw/discord 2026.8.1-beta.3 → 2026.8.2

package/dist/{provider-session.runtime-CvvphHvs.js → provider-session.runtime-DdKRMcE9.js}

@@ -1,6 +1,6 @@
-import { n as createThreadBindingManager, t as createNoopThreadBindingManager } from "./thread-bindings.manager-CngsgErq.js";
-import { a as reconcileAcpThreadBindingsOnStartup } from "./thread-bindings-VlymUnbz.js";
-import { t as createDiscordMessageHandler } from "./message-handler-B61q5MOF.js";
+import { n as createThreadBindingManager, t as createNoopThreadBindingManager } from "./thread-bindings.manager-B-3UHCc1.js";
+import { a as reconcileAcpThreadBindingsOnStartup } from "./thread-bindings-wECUSIIG.js";
+import { t as createDiscordMessageHandler } from "./message-handler-CAeEpqWo.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-Bo1WbLLr.js

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

package/dist/{realtime-session.runtime-ysbMG8v7.js → realtime-session.runtime-37IC-p5K.js}

@@ -1,5 +1,5 @@
-import { n as discordRealtimeVoiceSecretOwnerId } from "./secret-config-contract-B3i6WxV5.js";
-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-37OU6_Yh.js";
+import { n as discordRealtimeVoiceSecretOwnerId } from "./secret-config-contract-DFu9hfU8.js";
+import { a as convertRealtimePcm24kMonoToDiscordPcm48kStereo, c as maybeControlDiscordVoiceAgentRun, i as convertDiscordPcm48kStereoToRealtimePcm24kMono, l as formatVoiceLogPreview, n as loadDiscordVoiceSdk, o as createDiscordOpusEncodeStream, r as logVoiceVerbose, s as formatVoiceIngressPrompt } from "./voice-runtime-COyYYTDD.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";
@@ -11,7 +11,8 @@ import { PassThrough, pipeline } from "node:stream";
 function mergeRealtimePartialTranscript(previous, next) {
 	const trimmed = next.trim();
 	if (!trimmed) return previous;
-	return sliceUtf16Safe(trimmed.startsWith(previous) ? trimmed : `${previous}${next}`, -240);
+	const merged = trimmed.startsWith(previous) ? trimmed : `${previous}${next}`;
+	return sliceUtf16Safe(merged, -240);
 }
 //#endregion
 //#region extensions/discord/src/voice/realtime-turns.ts
@@ -39,6 +40,7 @@ var DiscordRealtimeTurns = class {
 			...context,
 			userId
 		}, {
+			transcripts: this.params.entry.transcripts,
 			inputDiscordBytes: 0,
 			inputRealtimeBytes: 0,
 			inputChunks: 0,
@@ -185,12 +187,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,
@@ -209,7 +212,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)}`);
@@ -226,6 +229,7 @@ var DiscordRealtimeTurns = class {
 		if (expiresAt === void 0) return;
 		this.pendingWakeNameFollowup = {
 			context,
+			transcripts: turn?.transcripts,
 			startedAt: turn?.startedAt ?? Date.now(),
 			expiresAt
 		};
@@ -242,7 +246,8 @@ var DiscordRealtimeTurns = class {
 		if (currentTurn) this.consumePendingSpeakerContext();
 		return {
 			context: pending.context,
-			startedAt: pending.startedAt
+			startedAt: pending.startedAt,
+			transcripts: pending.transcripts
 		};
 	}
 	rememberIgnoredWakeNameSpeakerContext(context) {
@@ -298,7 +303,6 @@ var DiscordRealtimeConsults = class {
 				logger$2.warn(`discord voice: realtime consult rejected malformed args call=${callId || "unknown"}: ${outcome.error}`);
 				await session.submitToolResult(callId, { error: outcome.error });
 				return;
-			case "consult": break;
 		}
 		const consultMessage = outcome.message;
 		logger$2.info(`discord voice: realtime consult requested call=${callId || "unknown"} voiceSession=${this.params.entry.voiceSessionKey} supervisorSession=${this.params.entry.route.sessionKey} agent=${this.params.entry.route.agentId} question=${formatVoiceLogPreview(consultMessage)}`);
@@ -604,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;
@@ -618,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;
 		}
@@ -629,10 +633,9 @@ 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_MAX_RETAINED_EXACT_SPEECH_BYTES = 32768;
 const DISCORD_REALTIME_WAKE_ACKS = [
 	"Yeah.",
 	"Mm-hmm.",
@@ -641,9 +644,7 @@ const DISCORD_REALTIME_WAKE_ACKS = [
 ];
 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();
 }
@@ -651,8 +652,8 @@ 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;
@@ -667,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");
@@ -702,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());
@@ -740,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) {
@@ -761,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()) {
@@ -845,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;
 		}
-		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
+		if (this.params.harness.outputActivity.snapshot().playbackStarted && !this.outputDrainHandler) {
+			if (!stream.write(discordPcm)) this.waitForOutputDrain(stream);
+			return;
+		}
+		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"}`);
 	}
@@ -931,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;
@@ -1029,7 +1022,6 @@ var DiscordRealtimeVoiceSession = class {
 			status: "inactive",
 			generation: 0
 		};
-		this.nextLifecycleGeneration = 0;
 		this.consultToolPolicy = "safe-read-only";
 		this.consultPolicy = "auto";
 		this.wakeNamePolicy = "never";
@@ -1072,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(),
@@ -1111,11 +1103,10 @@ 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) {
@@ -1168,6 +1159,10 @@ 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,
@@ -1202,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);
@@ -1215,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();
@@ -1234,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();
@@ -1266,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;
 	}
@@ -1293,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);
@@ -1305,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-DIVXbD1P.js → resolve-allowlist-common-BJ5UZNNT.js}

@@ -1,6 +1,6 @@
-import { m as normalizeDiscordToken } from "./accounts-DNl-oCEw.js";
-import { r as fetchDiscord } from "./api-DNVbJyEy.js";
-import { a as normalizeDiscordSlug } from "./allow-list-BDMimASD.js";
+import { m as normalizeDiscordToken } from "./accounts-CwJQoLjM.js";
+import { r as fetchDiscord } from "./api-BfmEP6wp.js";
+import { a as normalizeDiscordSlug } from "./allow-list-C2JuH-R0.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-CGeUoIqb.js → resolve-channels-BexR2eUn.js}

@@ -1,7 +1,8 @@
-import { en as __exportAll } from "./retry-DNsVTeTo.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-BDMimASD.js";
-import { i as listGuilds, n as filterDiscordGuilds, r as resolveDiscordAllowlistToken, t as buildDiscordUnresolvedResults } from "./resolve-allowlist-common-DIVXbD1P.js";
+import { on as __exportAll } from "./retry-t5RcEsPk.js";
+import { n as DiscordApiError, r as fetchDiscord, t as DISCORD_DIRECTORY_LOOKUP_TIMEOUT_MS } from "./api-BfmEP6wp.js";
+import { a as normalizeDiscordSlug } from "./allow-list-C2JuH-R0.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-BJ5UZNNT.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-BtKxLUZv.js → resolve-users-BtXBCH5W.js}

@@ -1,6 +1,6 @@
-import { en as __exportAll } from "./retry-DNsVTeTo.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-DIVXbD1P.js";
+import { on as __exportAll } from "./retry-t5RcEsPk.js";
+import { r as fetchDiscord, t as DISCORD_DIRECTORY_LOOKUP_TIMEOUT_MS } from "./api-BfmEP6wp.js";
+import { i as listGuilds, n as filterDiscordGuilds, r as resolveDiscordAllowlistToken, t as buildDiscordUnresolvedResults } from "./resolve-allowlist-common-BJ5UZNNT.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 });
@@ -74,7 +74,8 @@ async function resolveDiscordUserAllowlist(params) {
 			});
 			continue;
 		}
-		const guildList = filterDiscordGuilds(await getGuilds(), {
+		const allGuilds = await getGuilds();
+		const guildList = filterDiscordGuilds(allGuilds, {
 			guildId: parsed.guildId,
 			guildName: parsed.guildName?.trim()
 		});

package/dist/{retry-after-DdLPmPoa.js → retry-after-BrLjLUJi.js}

@@ -3,7 +3,8 @@ import { asFiniteNumberInRange, parseStrictFiniteNumber } from "openclaw/plugin-
 const RETRY_AFTER_BODY_SECONDS_RE = /^(?:\d+\.?\d*|\.\d+)$/;
 const MAX_SAFE_RETRY_AFTER_SECONDS = Number.MAX_SAFE_INTEGER / 1e3;
 function parseDiscordRetryAfterBodySeconds(value) {
-	return asFiniteNumberInRange(typeof value === "number" ? value : typeof value === "string" && RETRY_AFTER_BODY_SECONDS_RE.test(value.trim()) ? parseStrictFiniteNumber(value.trim()) : void 0, {
+	const seconds = typeof value === "number" ? value : typeof value === "string" && RETRY_AFTER_BODY_SECONDS_RE.test(value.trim()) ? parseStrictFiniteNumber(value.trim()) : void 0;
+	return asFiniteNumberInRange(seconds, {
 		min: 0,
 		max: MAX_SAFE_RETRY_AFTER_SECONDS
 	});