@openclaw/discord 2026.8.1 → 2026.8.2

package/dist/{transcripts-source-BLEMH_yi.js → transcripts-source-DkUhR7YK.js}

@@ -1,6 +1,6 @@
-import { on as __exportAll } from "./retry-DqHCW6PV.js";
-import { a as listEnabledDiscordAccounts, c as resolveDiscordAccount } from "./accounts-CfQ-vSyf.js";
-import { n as resolveDiscordVoiceEnabled, r as authorizeDiscordVoiceIngress, t as resolveDiscordVoiceAccess } from "./owner-access-UlYi9t0M.js";
+import { on as __exportAll } from "./retry-t5RcEsPk.js";
+import { a as listEnabledDiscordAccounts, c as resolveDiscordAccount } from "./accounts-CwJQoLjM.js";
+import { n as resolveDiscordVoiceEnabled, r as authorizeDiscordVoiceIngress, t as resolveDiscordVoiceAccess } from "./owner-access-yc1sX7Gx.js";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 import { summarizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";

package/dist/transcripts-source-api.js

@@ -1,4 +1,4 @@
-import { t as discordVoiceTranscriptsSourceProvider } from "./transcripts-source-BLEMH_yi.js";
+import { t as discordVoiceTranscriptsSourceProvider } from "./transcripts-source-DkUhR7YK.js";
 //#region extensions/discord/transcripts-source-api.ts
 function registerDiscordTranscriptSourceProvider(api) {
 	api.registerTranscriptSourceProvider(discordVoiceTranscriptsSourceProvider);

package/dist/{typing-B9snnwMe.js → typing-DAwJF5VT.js}

@@ -1,5 +1,5 @@
-import { Rt as sendChannelTyping, on as __exportAll } from "./retry-DqHCW6PV.js";
-import { c as raceWithTimeout } from "./timeouts-B9cy6RvQ.js";
+import { Rt as sendChannelTyping, on as __exportAll } from "./retry-t5RcEsPk.js";
+import { c as raceWithTimeout } from "./timeouts-D86uWLt_.js";
 //#region extensions/discord/src/monitor/typing.ts
 var typing_exports = /* @__PURE__ */ __exportAll({ sendTyping: () => sendTyping });
 const DISCORD_TYPING_START_TIMEOUT_MS = 5e3;

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

@@ -1,24 +1,350 @@
-import { D as ReadyListener, L as isUnknownDiscordVoiceStateError, O as ResumedListener, Yt as getGuildVoiceState, _ as parseDiscordTarget, j as VoiceStateUpdateListener, y as discord_exports } from "./retry-DqHCW6PV.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-D7JYmfm9.js";
-import { n as resolveDiscordVoiceEnabled, r as authorizeDiscordVoiceIngress, t as resolveDiscordVoiceAccess } from "./owner-access-UlYi9t0M.js";
-import { b as resolveFetchedDiscordThreadLikeChannelContext, m as buildDiscordGroupSystemPrompt } from "./provider-LXiOcJrH.js";
-import { _ as decodeOpusStreamChunks, a as VOICE_CONNECT_READY_TIMEOUT_MS, b as maybeControlDiscordVoiceAgentRun, c as isVoiceChannel, d as resolveVoiceTimeoutMs, g as decodeOpusStream, h as createDiscordOpusPlaybackStream, i as PLAYBACK_READY_TIMEOUT_MS, l as logVoiceVerbose, n as CAPTURE_FINALIZE_GRACE_MS, o as VOICE_RECONNECT_GRACE_MS, s as isDiscordRealtimeVoiceMode, t as loadDiscordVoiceSdk, u as resolveDiscordVoiceMode, v as writeVoiceWavFile, x as formatVoiceLogPreview, y as formatVoiceIngressPrompt } from "./sdk-runtime-6tfgYDjY.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 { 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");
@@ -1115,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();
@@ -2052,7 +2379,7 @@ var DiscordVoiceSessions = class {
 			ok: false,
 			message: "Discord realtime voice session stopped before startup completed."
 		};
-		const { DiscordRealtimeVoiceSession } = await import("./realtime-session.runtime-DOViOIjY.js");
+		const { DiscordRealtimeVoiceSession } = await import("./realtime-session.runtime-37IC-p5K.js");
 		const realtime = new DiscordRealtimeVoiceSession({
 			accountId: this.params.accountId,
 			bootstrapContextInstructions,
@@ -2156,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",
@@ -2556,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

package/node_modules/@discord/embedded-app-sdk/node_modules/@types/lodash/conforms.d.ts

@@ -0,0 +1,2 @@
+import { conforms } from "./index";
+export = conforms;

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

@@ -1,6 +1,6 @@
 {
     "name": "@types/lodash",
-    "version": "4.17.24",
+    "version": "4.17.25",
     "description": "TypeScript definitions for lodash",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/lodash",
     "license": "MIT",
@@ -51,6 +51,6 @@
     "scripts": {},
     "dependencies": {},
     "peerDependencies": {},
-    "typesPublisherContentHash": "6d5f9d074e23fea95ae8ef8f188116218dbc1b67c538bd01d89810cceb550268",
-    "typeScriptVersion": "5.2"
+    "typesPublisherContentHash": "5b89763740a3523d5295cc411a286fab1b0799800b598f81ec76d2f90a1ffce3",
+    "typeScriptVersion": "5.6"
 }

package/node_modules/@discord/embedded-app-sdk/node_modules/@types/lodash/stubArray.d.ts

@@ -0,0 +1,2 @@
+import { stubArray } from "./index";
+export = stubArray;

package/node_modules/@discord/embedded-app-sdk/node_modules/@types/lodash/stubObject.d.ts

@@ -0,0 +1,2 @@
+import { stubObject } from "./index";
+export = stubObject;

package/node_modules/@discord/embedded-app-sdk/node_modules/@types/lodash/stubString.d.ts

@@ -0,0 +1,2 @@
+import { stubString } from "./index";
+export = stubString;

package/node_modules/typebox/build/format/email.mjs

@@ -1,4 +1,4 @@
-const Email = /^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[^"\\]|\\.)*")@(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*|\[(?:IPv6:[a-f0-9:]+|(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?:\.(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})\])$/i;
+const Email = /^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[^"\\]|\\[\x20-\x7e])*")@(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*|\[(?:IPv6:[a-f0-9:]+|(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?:\.(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})\])$/i;
 /**
  * Returns true if the value is an Email
  * @specification https://datatracker.ietf.org/doc/html/rfc5322

package/node_modules/typebox/build/format/idna/idn-hostname.mjs

@@ -1,6 +1,9 @@
 import * as FormatBidi from './format/bidi.mjs';
 import * as LabelUnicode from './label/unicode.mjs';
 import * as LabelPuny from './label/puny.mjs';
+// ------------------------------------------------------------------
+// IsLabel
+// ------------------------------------------------------------------
 function IsValidLabelLength(value) {
     return value.length > 0 && value.length <= 63;
 }
@@ -8,9 +11,24 @@ function IsLabel(value) {
     return IsValidLabelLength(value) && (LabelPuny.IsPunyLabel(value) ||
         LabelUnicode.IsUnicodeLabel(value));
 }
+// ------------------------------------------------------------------
+// NormalizeHostname
+//
+// Normalizes a hostname for label validation. Normalizes for NFC
+// such that equivalent codepoint sequences can be uniformly
+// compared. It also removes codepoints that IDNA mapping ignores,
+// and converts full stop variants to ASCII '.' so the hostname can
+// be split into labels.
+// ------------------------------------------------------------------
 function NormalizeHostname(value) {
-    return value.normalize('NFC').replace(/[\u002E\u3002\uFF0E\uFF61]/g, '.');
+    return value
+        .normalize('NFC')
+        .replace(/[\u00ad\u034f\u180b-\u180d\u200b\ufe00-\ufe0f\u{e0100}-\u{e01ef}]/gu, '') // RE_IGNORED_MAPPING
+        .replace(/[\u002E\u3002\uFF0E\uFF61]/g, '.'); // RE_FULL_STOP_MAPPING
 }
+// ------------------------------------------------------------------
+// IsIdnHostname
+// ------------------------------------------------------------------
 export function IsIdnHostname(value) {
     if (value.length === 0 || value.includes(' '))
         return false;

package/node_modules/typebox/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.3.16",
+  "version": "1.3.17",
   "keywords": [
     "typescript",
     "jsonschema"

package/openclaw.plugin.json

@@ -3795,11 +3795,11 @@
         },
         "threadBindings.enabled": {
           "label": "Discord Thread Binding Enabled",
-          "help": "Enable Discord thread binding features (/focus, bound-thread routing/delivery, and thread-bound subagent sessions). Overrides session.threadBindings.enabled when set."
+          "help": "Enable Discord thread-bound session spawning, routing, and delivery. Overrides session.threadBindings.enabled when set."
         },
         "threadBindings.idleHours": {
           "label": "Discord Thread Binding Idle Timeout (hours)",
-          "help": "Inactivity window in hours for Discord thread-bound sessions (/focus and spawned thread sessions). Set 0 to disable idle auto-unfocus (default: 24). Overrides session.threadBindings.idleHours when set."
+          "help": "Inactivity window in hours for Discord thread-bound sessions. Set 0 to disable idle expiry (default: 24). Overrides session.threadBindings.idleHours when set."
         },
         "threadBindings.maxAgeHours": {
           "label": "Discord Thread Binding Max Age (hours)",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/discord",
-  "version": "2026.8.1",
+  "version": "2026.8.2",
   "description": "OpenClaw Discord channel plugin for channels, DMs, commands, and app events.",
   "repository": {
     "type": "git",
@@ -13,13 +13,13 @@
     "discord-api-types": "0.38.53",
     "libopus-wasm": "0.2.0",
     "mdast-util-from-markdown": "2.0.3",
-    "typebox": "1.3.16",
+    "typebox": "1.3.17",
     "undici": "8.10.0",
     "ws": "8.21.3",
     "zod": "4.4.3"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.8.1"
+    "openclaw": ">=2026.8.2"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -94,10 +94,10 @@
       "allowInvalidConfigRecovery": true
     },
     "compat": {
-      "pluginApi": ">=2026.8.1"
+      "pluginApi": ">=2026.8.2"
     },
     "build": {
-      "openclawVersion": "2026.8.1",
+      "openclawVersion": "2026.8.2",
       "staticAssets": [
         {
           "source": "./assets/embedded-app-sdk.mjs",