silentlake 2026.3.24

package/dist/manager.runtime-F9F1eFiB.js

@@ -0,0 +1,827 @@
+import "./src-CmXHIz5f.js";
+import "./redact-BDinS1q9.js";
+import { r as formatErrorMessage } from "./errors-BxyFnvP3.js";
+import "./unhandled-rejections-CDJ8dOVP.js";
+import "./logger-CoEtkjhn.js";
+import "./paths-GHJ97ebE.js";
+import { n as resolvePreferredOpenClawTmpDir } from "./tmp-openclaw-dir-idKIOMmb.js";
+import "./theme-CdOoMzRk.js";
+import { a as logVerbose, l as shouldLogVerbose } from "./globals-41sdSaKv.js";
+import "./runtime-CT2LIJZu.js";
+import "./ansi-BEJF8NKS.js";
+import { t as createSubsystemLogger } from "./subsystem-CUp-6QQf.js";
+import "./boolean-DKtCJu_W.js";
+import "./env-BP70DGuy.js";
+import "./warning-filter-CgvLQB4Y.js";
+import "./utils-Bxk6BLTg.js";
+import "./links-Bilm-v0z.js";
+import "./paths-nCHyK08H.js";
+import "./auth-profiles-CWEIQV77.js";
+import "./boundary-path-B3FFLYNx.js";
+import "./boundary-file-read-BP6VMpqH.js";
+import "./logger-Cqy7-Maj.js";
+import "./exec-Dmex2w_d.js";
+import "./workspace-BH7CXmrr.js";
+import { a as resolveAgentDir } from "./agent-scope-DPP4Z_UU.js";
+import "./model-selection-BTpJnslv.js";
+import "./io-jOnQRia2.js";
+import "./host-env-security-BogNN146.js";
+import "./shell-env-cD92jEyV.js";
+import "./safe-text-B_CQuica.js";
+import "./version-DCY9_obP.js";
+import "./env-substitution-D6t_sLS_.js";
+import "./includes-7XyL3p1c.js";
+import "./zod-schema.providers-core-Dgq7MTqU.js";
+import "./legacy-web-search-BgZjNG2h.js";
+import "./registry-rgYi7KoO.js";
+import "./config-state-CE0CGjey.js";
+import "./manifest-registry-B90TyTWl.js";
+import "./avatar-policy-Ds9e6uHI.js";
+import "./ip-C8vmzVu0.js";
+import "./zod-schema.agent-runtime-T_EC_6fg.js";
+import "./zod-schema.core-BdgRr-F1.js";
+import "./config-pn7LKJdW.js";
+import "./file-lock-WbEmczmY.js";
+import "./audit-fs-oDMUa5N_.js";
+import "./resolve-T2q_0ARF.js";
+import "./profiles-D17eMKQZ.js";
+import "./repair-qXnOAvDy.js";
+import "./tailscale-Cbsx-2HB.js";
+import "./tailnet-ofqBrXzu.js";
+import "./net-DlJFp95v.js";
+import "./auth-O6LQFLHJ.js";
+import "./credentials-BPwBlm1X.js";
+import "./message-channel-Cy-gN4K2.js";
+import "./store-CvL8MPei.js";
+import "./runtime-CuvWMN7E.js";
+import "./registry-C3q59Qj0.js";
+import "./plugins-1Z50ecJ6.js";
+import "./sessions-DaSBVNwD.js";
+import "./paths-CTjJI9l0.js";
+import "./session-write-lock-DNKvpjKf.js";
+import "./method-scopes-DgypDW23.js";
+import "./call-BmLt3xO1.js";
+import "./ports-lsof-DtJqhFOr.js";
+import "./restart-stale-pids-CLGiqU2E.js";
+import "./ports-DFiK_Jc-.js";
+import "./logging-CbTTfADU.js";
+import "./commands-Bb9xUwz9.js";
+import "./identity-cyBYcoXS.js";
+import "./secret-input-4REZ4sHo.js";
+import "./bindings-kjwuC11Q.js";
+import { i as resolveAgentRoute } from "./resolve-route-vEY3ONZ2.js";
+import "./routing-Y3m0o-kB.js";
+import "./base-session-key-Cf2rkwag.js";
+import "./token-Bgv8XEsC.js";
+import { D as transcribeAudioFile, Gr as formatDiscordUserTag, Qu as agentCommandFromIngress, Wr as resolveDiscordOwnerAccess, Xu as ChannelType, Yu as ReadyListener, cr as formatMention, gf as parseTtsDirectives, qd as resolveTtsConfig, rf as textToSpeech } from "./pi-embedded-CSQySvOV.js";
+import "./identity-file-EndG1nfc.js";
+import "./identity-DovQV4zD.js";
+import "./provider-env-vars-CsQlY7bF.js";
+import "./model-auth-env-CF9ts7Th.js";
+import "./anthropic-vertex-provider-Dd5agCN9.js";
+import "./model-auth-B__TJTPw.js";
+import "./kilocode-shared-DS7_0IMs.js";
+import "./provider-models-C2EjYMwW.js";
+import "./provider-model-allowlist-4HSOnlX-.js";
+import "./retry-D15TD1S3.js";
+import "./models-config.providers.discovery-BaIk1NKL.js";
+import "./state-paths-DJIGEFq_.js";
+import "./cli-runtime-aAVwbEYy.js";
+import "./runtime-env-a_iwdJIv.js";
+import "./diagnostic-DqJXx_4Q.js";
+import "./text-runtime-C_Roi_Je.js";
+import "./config-presence-BmUF_5K9.js";
+import "./thread-bindings-messages-Cdo8jSa9.js";
+import "./conversation-runtime-1O0Aaolb.js";
+import "./registry-CPsHw6xU.js";
+import "./internal-hooks-0uipqzRY.js";
+import "./http-registry-WFFbLYRd.js";
+import "./runtime-whatsapp-boundary-xZem0NyQ.js";
+import "./provider-catalog-D7QvsUXS.js";
+import "./provider-catalog-C5vmXjmb.js";
+import "./provider-catalog--18-pW5t.js";
+import "./tool-catalog-BV6FcEWS.js";
+import "./docker-XFNiArwM.js";
+import "./sandbox-CUUouiKs.js";
+import "./common-CUBlLRXB.js";
+import "./image-ops-j01UkxEv.js";
+import "./thinking-BBD_0HSp.js";
+import "./path-alias-guards-ZTKqurNH.js";
+import "./sandbox-paths-fqp_TZdO.js";
+import "./typebox-D0SHDJST.js";
+import "./mime-C4vVTBso.js";
+import "./ssrf-Dk9XaoKN.js";
+import "./fetch-guard-DIyN1HW5.js";
+import "./provider-web-search-NzK8ep1E.js";
+import "./manager-ChTGDe87.js";
+import "./heartbeat-7aHh0m3d.js";
+import "./typing-DG_YqWJ7.js";
+import "./target-registry-krAVlXi_.js";
+import "./external-content-BUdUOqkv.js";
+import "./brave-CkimJe4j.js";
+import "./channel-config-helpers-CieQWILI.js";
+import "./whatsapp-DXbWlm3A.js";
+import "./delegate-D4ql5N70.js";
+import "./config-schema-B1UGMwZ8.js";
+import "./secret-file-DYJtH6kf.js";
+import "./core-C7aHA4Aq.js";
+import "./security-runtime-BuEhpJVE.js";
+import "./pairing-store-C4lsd4pO.js";
+import "./json-store-O1LwpnBH.js";
+import "./dm-policy-shared-6bCJzHOS.js";
+import "./provider-auth-ref-BS3gwrNr.js";
+import "./provider-auth-input-BftBdgvW.js";
+import "./provider-auth-Bw8x1a3o.js";
+import "./provider-auth-helpers-B0dS-1WK.js";
+import "./provider-api-key-auth-BE0taXiB.js";
+import "./image-generation-CNKc-mFK.js";
+import "./shared-LeP8iUTz.js";
+import "./provider-usage-ClDVmkhl.js";
+import "./media-understanding-DD2uMjK8.js";
+import "./provider-onboard-CjOfyeQG.js";
+import "./perplexity-Beshd9zu.js";
+import "./provider-auth-api-key-BrQYvdxi.js";
+import "./command-secret-targets-COcwhn-D.js";
+import "./whatsapp-heartbeat-CSWnPQ7q.js";
+import "./fs-safe-D3qzH-ab.js";
+import "./web-media-CtU6jM5V.js";
+import "./local-roots-DAzCjWbC.js";
+import "./frontmatter-S5vS-I4a.js";
+import "./env-overrides-JneV60sd.js";
+import "./skills-CCgKs_NJ.js";
+import "./skill-commands-CiSwTFBQ.js";
+import "./workspace-dirs-_O4V3xCR.js";
+import "./pairing-token-gKj4SNFJ.js";
+import "./model-selection-Ci9cPkL2.js";
+import "./system-events-mAu6Ap6K.js";
+import "./pi-model-discovery-CuX5CDyZ.js";
+import "./message-hook-mappers-BBTV3JRQ.js";
+import "./delivery-queue-DrrqB4Hi.js";
+import "./channel-plugin-common-BhTxCE5t.js";
+import "./shared-BU0QgVMZ.js";
+import "./status-helpers-Cda-rGLX.js";
+import "./config-runtime-CstET7fq.js";
+import { n as isDangerousNameMatchingEnabled } from "./dangerous-name-matching-DZa_t0RM.js";
+import "./routes-TpLEcKO8.js";
+import "./media-limits-Cuvmmhop.js";
+import "./axios-xDDnM0KG.js";
+import "./manager-DuwFn87U.js";
+import "./web-media-BfBb8i48.js";
+import "./mentions-Bxys_va0.js";
+import "./commands-registry.data-XyUTELK9.js";
+import "./commands-registry-ChCep1KJ.js";
+import "./channel-inbound-DwzVf2PK.js";
+import "./config-DdDLrP_v.js";
+import "./ssh-tunnel-Cz51VBAt.js";
+import "./server-middleware-CCqKhKUb.js";
+import "./read-only-account-inspect-DPJzadPo.js";
+import "./channel-summary-CdYLGMVt.js";
+import "./channel-policy-C4GKHvhz.js";
+import "./resolve-utils-CbqJY2bs.js";
+import "./allow-from-C4iBpqFI.js";
+import "./channel-actions-DU2CR3xW.js";
+import "./exec-approvals-BJhuySBz.js";
+import "./exec-approvals-allowlist-B_wPddCb.js";
+import "./http-body-CCiSfloA.js";
+import "./ssrf-policy-Dk6oMa20.js";
+import "./history-CHjo8B5W.js";
+import "./reply-history-CVCD5oE9.js";
+import "./channel-reply-pipeline-CPTuaW8n.js";
+import "./exec-safe-bin-runtime-policy-BZkObC8r.js";
+import "./nodes-screen-CQ7IvP62.js";
+import "./system-run-command-Cxq2F1MB.js";
+import "./stagger-DU7FjHYo.js";
+import "./tool-policy-match-CHqTCSdK.js";
+import "./setup-binary-BOJA7zdN.js";
+import "./archive-Tr0wIUO-.js";
+import "./signal-cli-install-DxoL8CgF.js";
+import "./directory-runtime-DhC8QkMq.js";
+import "./timeouts-BwR1sGom.js";
+import "./outbound-runtime-ic_7ulJJ.js";
+import "./acp-runtime-BdLdT-QY.js";
+import "./gateway-runtime-ih2e7a2K.js";
+import "./connection-auth-BSQJeDOU.js";
+import "./discord-core-5tkl-BzP.js";
+import "./with-timeout-2AKTISee.js";
+import "./multimodal-DC43jYNv.js";
+import "./memory-search-Das1tiuB.js";
+import "./query-expansion-Do45hILP.js";
+import "./search-manager-r8Cw4ZRv.js";
+import "./memory-DBjQ0TPd.js";
+import "./mcp-config-Coky4zS4.js";
+import "./runtime-Dl17x_cV.js";
+import "./speech-runtime-y1FcnGVA.js";
+import "./speech-bSreRuDH.js";
+import { createRequire } from "node:module";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+//#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/manager.ts
+const require = createRequire(import.meta.url);
+const SAMPLE_RATE = 48e3;
+const CHANNELS = 2;
+const BIT_DEPTH = 16;
+const MIN_SEGMENT_SECONDS = .35;
+const SILENCE_DURATION_MS = 1e3;
+const PLAYBACK_READY_TIMEOUT_MS = 15e3;
+const SPEAKING_READY_TIMEOUT_MS = 6e4;
+const DECRYPT_FAILURE_WINDOW_MS = 3e4;
+const DECRYPT_FAILURE_RECONNECT_THRESHOLD = 3;
+const DECRYPT_FAILURE_PATTERN = /DecryptionFailed\(/;
+const SPEAKER_CONTEXT_CACHE_TTL_MS = 6e4;
+const logger = createSubsystemLogger("discord/voice");
+const logVoiceVerbose = (message) => {
+	logVerbose(`discord voice: ${message}`);
+};
+function mergeTtsConfig(base, override) {
+	if (!override) return base;
+	return {
+		...base,
+		...override,
+		modelOverrides: {
+			...base.modelOverrides,
+			...override.modelOverrides
+		},
+		elevenlabs: {
+			...base.elevenlabs,
+			...override.elevenlabs,
+			voiceSettings: {
+				...base.elevenlabs?.voiceSettings,
+				...override.elevenlabs?.voiceSettings
+			}
+		},
+		openai: {
+			...base.openai,
+			...override.openai
+		},
+		edge: {
+			...base.edge,
+			...override.edge
+		}
+	};
+}
+function resolveVoiceTtsConfig(params) {
+	if (!params.override) return {
+		cfg: params.cfg,
+		resolved: resolveTtsConfig(params.cfg)
+	};
+	const merged = mergeTtsConfig(params.cfg.messages?.tts ?? {}, params.override);
+	const messages = params.cfg.messages ?? {};
+	const cfg = {
+		...params.cfg,
+		messages: {
+			...messages,
+			tts: merged
+		}
+	};
+	return {
+		cfg,
+		resolved: resolveTtsConfig(cfg)
+	};
+}
+function buildWavBuffer(pcm) {
+	const blockAlign = CHANNELS * BIT_DEPTH / 8;
+	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]);
+}
+let warnedOpusMissing = false;
+function createOpusDecoder() {
+	try {
+		const OpusScript = require("opusscript");
+		return {
+			decoder: new OpusScript(SAMPLE_RATE, CHANNELS, OpusScript.Application.AUDIO),
+			name: "opusscript"
+		};
+	} catch (err) {
+		if (!warnedOpusMissing) {
+			warnedOpusMissing = true;
+			logger.warn(`discord voice: opusscript unavailable (${formatErrorMessage(err)}); cannot decode voice audio`);
+		}
+	}
+	return null;
+}
+async function decodeOpusStream(stream) {
+	const selected = createOpusDecoder();
+	if (!selected) return Buffer.alloc(0);
+	logVoiceVerbose(`opus decoder: ${selected.name}`);
+	const chunks = [];
+	try {
+		for await (const chunk of stream) {
+			if (!chunk || !(chunk instanceof Buffer) || chunk.length === 0) continue;
+			const decoded = selected.decoder.decode(chunk);
+			if (decoded && decoded.length > 0) chunks.push(Buffer.from(decoded));
+		}
+	} catch (err) {
+		if (shouldLogVerbose()) logVerbose(`discord voice: opus decode failed: ${formatErrorMessage(err)}`);
+	}
+	return chunks.length > 0 ? Buffer.concat(chunks) : Buffer.alloc(0);
+}
+function estimateDurationSeconds(pcm) {
+	const bytesPerSample = BIT_DEPTH / 8 * CHANNELS;
+	if (bytesPerSample <= 0) return 0;
+	return pcm.length / (bytesPerSample * SAMPLE_RATE);
+}
+async function writeWavFile(pcm) {
+	const tempDir = await fs.mkdtemp(path.join(resolvePreferredOpenClawTmpDir(), "discord-voice-"));
+	const filePath = path.join(tempDir, `segment-${randomUUID()}.wav`);
+	const wav = buildWavBuffer(pcm);
+	await fs.writeFile(filePath, wav);
+	scheduleTempCleanup(tempDir);
+	return {
+		path: filePath,
+		durationSeconds: estimateDurationSeconds(pcm)
+	};
+}
+function scheduleTempCleanup(tempDir, delayMs = 1800 * 1e3) {
+	setTimeout(() => {
+		fs.rm(tempDir, {
+			recursive: true,
+			force: true
+		}).catch((err) => {
+			if (shouldLogVerbose()) logVerbose(`discord voice: temp cleanup failed for ${tempDir}: ${formatErrorMessage(err)}`);
+		});
+	}, delayMs).unref();
+}
+async function transcribeAudio(params) {
+	return (await transcribeAudioFile({
+		filePath: params.filePath,
+		cfg: params.cfg,
+		agentDir: resolveAgentDir(params.cfg, params.agentId),
+		mime: "audio/wav"
+	})).text?.trim() || void 0;
+}
+var DiscordVoiceManager$1 = class {
+	constructor(params) {
+		this.params = params;
+		this.sessions = /* @__PURE__ */ new Map();
+		this.autoJoinTask = null;
+		this.speakerContextCache = /* @__PURE__ */ new Map();
+		this.botUserId = params.botUserId;
+		this.voiceEnabled = params.discordConfig.voice?.enabled !== false;
+		this.ownerAllowFrom = params.discordConfig.allowFrom ?? params.discordConfig.dm?.allowFrom ?? [];
+		this.allowDangerousNameMatching = isDangerousNameMatchingEnabled(params.discordConfig);
+	}
+	setBotUserId(id) {
+		if (id) this.botUserId = id;
+	}
+	isEnabled() {
+		return this.voiceEnabled;
+	}
+	async autoJoin() {
+		if (!this.voiceEnabled) return;
+		if (this.autoJoinTask) return this.autoJoinTask;
+		this.autoJoinTask = (async () => {
+			const entries = this.params.discordConfig.voice?.autoJoin ?? [];
+			logVoiceVerbose(`autoJoin: ${entries.length} entries`);
+			const seenGuilds = /* @__PURE__ */ new Set();
+			for (const entry of entries) {
+				const guildId = entry.guildId.trim();
+				if (!guildId) continue;
+				if (seenGuilds.has(guildId)) {
+					logger.warn(`discord voice: autoJoin has multiple entries for guild ${guildId}; skipping`);
+					continue;
+				}
+				seenGuilds.add(guildId);
+				logVoiceVerbose(`autoJoin: joining guild ${guildId} channel ${entry.channelId}`);
+				await this.join({
+					guildId: entry.guildId,
+					channelId: entry.channelId
+				});
+			}
+		})().finally(() => {
+			this.autoJoinTask = null;
+		});
+		return this.autoJoinTask;
+	}
+	status() {
+		return Array.from(this.sessions.values()).map((session) => ({
+			ok: true,
+			message: `connected: guild ${session.guildId} channel ${session.channelId}`,
+			guildId: session.guildId,
+			channelId: session.channelId
+		}));
+	}
+	async join(params) {
+		if (!this.voiceEnabled) return {
+			ok: false,
+			message: "Discord voice is disabled (channels.discord.voice.enabled)."
+		};
+		const guildId = params.guildId.trim();
+		const channelId = params.channelId.trim();
+		if (!guildId || !channelId) return {
+			ok: false,
+			message: "Missing guildId or channelId."
+		};
+		logVoiceVerbose(`join requested: guild ${guildId} channel ${channelId}`);
+		const existing = this.sessions.get(guildId);
+		if (existing && existing.channelId === channelId) {
+			logVoiceVerbose(`join: already connected to guild ${guildId} channel ${channelId}`);
+			return {
+				ok: true,
+				message: `Already connected to ${formatMention({ channelId })}.`,
+				guildId,
+				channelId
+			};
+		}
+		if (existing) {
+			logVoiceVerbose(`join: replacing existing session for guild ${guildId}`);
+			await this.leave({ guildId });
+		}
+		const channelInfo = await this.params.client.fetchChannel(channelId).catch(() => null);
+		if (!channelInfo || "type" in channelInfo && !isVoiceChannel(channelInfo.type)) return {
+			ok: false,
+			message: `Channel ${channelId} is not a voice channel.`
+		};
+		const channelGuildId = "guildId" in channelInfo ? channelInfo.guildId : void 0;
+		if (channelGuildId && channelGuildId !== guildId) return {
+			ok: false,
+			message: "Voice channel is not in this guild."
+		};
+		const voicePlugin = this.params.client.getPlugin("voice");
+		if (!voicePlugin) return {
+			ok: false,
+			message: "Discord voice plugin is not available."
+		};
+		const adapterCreator = voicePlugin.getGatewayAdapterCreator(guildId);
+		const daveEncryption = this.params.discordConfig.voice?.daveEncryption;
+		const decryptionFailureTolerance = this.params.discordConfig.voice?.decryptionFailureTolerance;
+		logVoiceVerbose(`join: DAVE settings encryption=${daveEncryption === false ? "off" : "on"} tolerance=${decryptionFailureTolerance ?? "default"}`);
+		const voiceSdk = loadDiscordVoiceSdk();
+		const connection = voiceSdk.joinVoiceChannel({
+			channelId,
+			guildId,
+			adapterCreator,
+			selfDeaf: false,
+			selfMute: false,
+			daveEncryption,
+			decryptionFailureTolerance
+		});
+		try {
+			await voiceSdk.entersState(connection, voiceSdk.VoiceConnectionStatus.Ready, PLAYBACK_READY_TIMEOUT_MS);
+			logVoiceVerbose(`join: connected to guild ${guildId} channel ${channelId}`);
+		} catch (err) {
+			connection.destroy();
+			return {
+				ok: false,
+				message: `Failed to join voice channel: ${formatErrorMessage(err)}`
+			};
+		}
+		const sessionChannelId = channelInfo?.id ?? channelId;
+		if (sessionChannelId !== channelId) logVoiceVerbose(`join: using session channel ${sessionChannelId} for voice channel ${channelId}`);
+		const route = resolveAgentRoute({
+			cfg: this.params.cfg,
+			channel: "discord",
+			accountId: this.params.accountId,
+			guildId,
+			peer: {
+				kind: "channel",
+				id: sessionChannelId
+			}
+		});
+		const player = voiceSdk.createAudioPlayer();
+		connection.subscribe(player);
+		let speakingHandler;
+		let disconnectedHandler;
+		let destroyedHandler;
+		let playerErrorHandler;
+		const clearSessionIfCurrent = () => {
+			if (this.sessions.get(guildId)?.connection === connection) this.sessions.delete(guildId);
+		};
+		const entry = {
+			guildId,
+			channelId,
+			sessionChannelId,
+			route,
+			connection,
+			player,
+			playbackQueue: Promise.resolve(),
+			processingQueue: Promise.resolve(),
+			activeSpeakers: /* @__PURE__ */ new Set(),
+			decryptFailureCount: 0,
+			lastDecryptFailureAt: 0,
+			decryptRecoveryInFlight: false,
+			stop: () => {
+				if (speakingHandler) connection.receiver.speaking.off("start", speakingHandler);
+				if (disconnectedHandler) connection.off(voiceSdk.VoiceConnectionStatus.Disconnected, disconnectedHandler);
+				if (destroyedHandler) connection.off(voiceSdk.VoiceConnectionStatus.Destroyed, destroyedHandler);
+				if (playerErrorHandler) player.off("error", playerErrorHandler);
+				player.stop();
+				connection.destroy();
+			}
+		};
+		speakingHandler = (userId) => {
+			this.handleSpeakingStart(entry, userId).catch((err) => {
+				logger.warn(`discord voice: capture failed: ${formatErrorMessage(err)}`);
+			});
+		};
+		disconnectedHandler = async () => {
+			try {
+				await Promise.race([voiceSdk.entersState(connection, voiceSdk.VoiceConnectionStatus.Signalling, 5e3), voiceSdk.entersState(connection, voiceSdk.VoiceConnectionStatus.Connecting, 5e3)]);
+			} catch {
+				clearSessionIfCurrent();
+				connection.destroy();
+			}
+		};
+		destroyedHandler = () => {
+			clearSessionIfCurrent();
+		};
+		playerErrorHandler = (err) => {
+			logger.warn(`discord voice: playback error: ${formatErrorMessage(err)}`);
+		};
+		connection.receiver.speaking.on("start", speakingHandler);
+		connection.on(voiceSdk.VoiceConnectionStatus.Disconnected, disconnectedHandler);
+		connection.on(voiceSdk.VoiceConnectionStatus.Destroyed, destroyedHandler);
+		player.on("error", playerErrorHandler);
+		this.sessions.set(guildId, entry);
+		return {
+			ok: true,
+			message: `Joined ${formatMention({ channelId })}.`,
+			guildId,
+			channelId
+		};
+	}
+	async leave(params) {
+		const guildId = params.guildId.trim();
+		logVoiceVerbose(`leave requested: guild ${guildId} channel ${params.channelId ?? "current"}`);
+		const entry = this.sessions.get(guildId);
+		if (!entry) return {
+			ok: false,
+			message: "Not connected to a voice channel."
+		};
+		if (params.channelId && params.channelId !== entry.channelId) return {
+			ok: false,
+			message: "Not connected to that voice channel."
+		};
+		entry.stop();
+		this.sessions.delete(guildId);
+		logVoiceVerbose(`leave: disconnected from guild ${guildId} channel ${entry.channelId}`);
+		return {
+			ok: true,
+			message: `Left ${formatMention({ channelId: entry.channelId })}.`,
+			guildId,
+			channelId: entry.channelId
+		};
+	}
+	async destroy() {
+		for (const entry of this.sessions.values()) entry.stop();
+		this.sessions.clear();
+	}
+	enqueueProcessing(entry, task) {
+		entry.processingQueue = entry.processingQueue.then(task).catch((err) => logger.warn(`discord voice: processing failed: ${formatErrorMessage(err)}`));
+	}
+	enqueuePlayback(entry, task) {
+		entry.playbackQueue = entry.playbackQueue.then(task).catch((err) => logger.warn(`discord voice: playback failed: ${formatErrorMessage(err)}`));
+	}
+	async handleSpeakingStart(entry, userId) {
+		if (!userId || entry.activeSpeakers.has(userId)) return;
+		if (this.botUserId && userId === this.botUserId) return;
+		entry.activeSpeakers.add(userId);
+		logVoiceVerbose(`capture start: guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
+		const voiceSdk = loadDiscordVoiceSdk();
+		if (entry.player.state.status === voiceSdk.AudioPlayerStatus.Playing) entry.player.stop(true);
+		const stream = entry.connection.receiver.subscribe(userId, { end: {
+			behavior: voiceSdk.EndBehaviorType.AfterSilence,
+			duration: SILENCE_DURATION_MS
+		} });
+		stream.on("error", (err) => {
+			this.handleReceiveError(entry, err);
+		});
+		try {
+			const pcm = await decodeOpusStream(stream);
+			if (pcm.length === 0) {
+				logVoiceVerbose(`capture empty: guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
+				return;
+			}
+			this.resetDecryptFailureState(entry);
+			const { path: wavPath, durationSeconds } = await writeWavFile(pcm);
+			if (durationSeconds < MIN_SEGMENT_SECONDS) {
+				logVoiceVerbose(`capture too short (${durationSeconds.toFixed(2)}s): guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
+				return;
+			}
+			logVoiceVerbose(`capture ready (${durationSeconds.toFixed(2)}s): guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
+			this.enqueueProcessing(entry, async () => {
+				await this.processSegment({
+					entry,
+					wavPath,
+					userId,
+					durationSeconds
+				});
+			});
+		} finally {
+			entry.activeSpeakers.delete(userId);
+		}
+	}
+	async processSegment(params) {
+		const { entry, wavPath, userId, durationSeconds } = params;
+		logVoiceVerbose(`segment processing (${durationSeconds.toFixed(2)}s): guild ${entry.guildId} channel ${entry.channelId}`);
+		const transcript = await transcribeAudio({
+			cfg: this.params.cfg,
+			agentId: entry.route.agentId,
+			filePath: wavPath
+		});
+		if (!transcript) {
+			logVoiceVerbose(`transcription empty: guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
+			return;
+		}
+		logVoiceVerbose(`transcription ok (${transcript.length} chars): guild ${entry.guildId} channel ${entry.channelId}`);
+		const speaker = await this.resolveSpeakerContext(entry.guildId, userId);
+		const replyText = ((await agentCommandFromIngress({
+			message: speaker.label ? `${speaker.label}: ${transcript}` : transcript,
+			sessionKey: entry.route.sessionKey,
+			agentId: entry.route.agentId,
+			messageChannel: "discord",
+			senderIsOwner: speaker.senderIsOwner,
+			allowModelOverride: false,
+			deliver: false
+		}, this.params.runtime)).payloads ?? []).map((payload) => payload.text).filter((text) => typeof text === "string" && text.trim()).join("\n").trim();
+		if (!replyText) {
+			logVoiceVerbose(`reply empty: guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
+			return;
+		}
+		logVoiceVerbose(`reply ok (${replyText.length} chars): guild ${entry.guildId} channel ${entry.channelId}`);
+		const { cfg: ttsCfg, resolved: ttsConfig } = resolveVoiceTtsConfig({
+			cfg: this.params.cfg,
+			override: this.params.discordConfig.voice?.tts
+		});
+		const directive = parseTtsDirectives(replyText, ttsConfig.modelOverrides, ttsConfig.openai.baseUrl);
+		const speakText = directive.overrides.ttsText ?? directive.cleanedText.trim();
+		if (!speakText) {
+			logVoiceVerbose(`tts skipped (empty): guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
+			return;
+		}
+		const ttsResult = await textToSpeech({
+			text: speakText,
+			cfg: ttsCfg,
+			channel: "discord",
+			overrides: directive.overrides
+		});
+		if (!ttsResult.success || !ttsResult.audioPath) {
+			logger.warn(`discord voice: TTS failed: ${ttsResult.error ?? "unknown error"}`);
+			return;
+		}
+		const audioPath = ttsResult.audioPath;
+		logVoiceVerbose(`tts ok (${speakText.length} chars): guild ${entry.guildId} channel ${entry.channelId}`);
+		this.enqueuePlayback(entry, async () => {
+			logVoiceVerbose(`playback start: guild ${entry.guildId} channel ${entry.channelId} file ${path.basename(audioPath)}`);
+			const voiceSdk = loadDiscordVoiceSdk();
+			const resource = voiceSdk.createAudioResource(audioPath);
+			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);
+			logVoiceVerbose(`playback done: guild ${entry.guildId} channel ${entry.channelId}`);
+		});
+	}
+	handleReceiveError(entry, err) {
+		const message = formatErrorMessage(err);
+		logger.warn(`discord voice: receive error: ${message}`);
+		if (!DECRYPT_FAILURE_PATTERN.test(message)) return;
+		const now = Date.now();
+		if (now - entry.lastDecryptFailureAt > DECRYPT_FAILURE_WINDOW_MS) entry.decryptFailureCount = 0;
+		entry.lastDecryptFailureAt = now;
+		entry.decryptFailureCount += 1;
+		if (entry.decryptFailureCount === 1) logger.warn("discord voice: DAVE decrypt failures detected; voice receive may be unstable (upstream: discordjs/discord.js#11419)");
+		if (entry.decryptFailureCount < DECRYPT_FAILURE_RECONNECT_THRESHOLD || entry.decryptRecoveryInFlight) return;
+		entry.decryptRecoveryInFlight = true;
+		this.resetDecryptFailureState(entry);
+		this.recoverFromDecryptFailures(entry).catch((recoverErr) => logger.warn(`discord voice: decrypt recovery failed: ${formatErrorMessage(recoverErr)}`)).finally(() => {
+			entry.decryptRecoveryInFlight = false;
+		});
+	}
+	resetDecryptFailureState(entry) {
+		entry.decryptFailureCount = 0;
+		entry.lastDecryptFailureAt = 0;
+	}
+	async recoverFromDecryptFailures(entry) {
+		const active = this.sessions.get(entry.guildId);
+		if (!active || active.connection !== entry.connection) return;
+		logger.warn(`discord voice: repeated decrypt failures; attempting rejoin for guild ${entry.guildId} channel ${entry.channelId}`);
+		const leaveResult = await this.leave({ guildId: entry.guildId });
+		if (!leaveResult.ok) {
+			logger.warn(`discord voice: decrypt recovery leave failed: ${leaveResult.message}`);
+			return;
+		}
+		const result = await this.join({
+			guildId: entry.guildId,
+			channelId: entry.channelId
+		});
+		if (!result.ok) logger.warn(`discord voice: rejoin after decrypt failures failed: ${result.message}`);
+	}
+	resolveSpeakerIsOwner(params) {
+		return resolveDiscordOwnerAccess({
+			allowFrom: this.ownerAllowFrom,
+			sender: {
+				id: params.id,
+				name: params.name,
+				tag: params.tag
+			},
+			allowNameMatching: this.allowDangerousNameMatching
+		}).ownerAllowed;
+	}
+	resolveSpeakerContextCacheKey(guildId, userId) {
+		return `${guildId}:${userId}`;
+	}
+	getCachedSpeakerContext(guildId, userId) {
+		const key = this.resolveSpeakerContextCacheKey(guildId, userId);
+		const cached = this.speakerContextCache.get(key);
+		if (!cached) return;
+		if (cached.expiresAt <= Date.now()) {
+			this.speakerContextCache.delete(key);
+			return;
+		}
+		return {
+			label: cached.label,
+			senderIsOwner: cached.senderIsOwner
+		};
+	}
+	setCachedSpeakerContext(guildId, userId, context) {
+		const key = this.resolveSpeakerContextCacheKey(guildId, userId);
+		this.speakerContextCache.set(key, {
+			label: context.label,
+			senderIsOwner: context.senderIsOwner,
+			expiresAt: Date.now() + SPEAKER_CONTEXT_CACHE_TTL_MS
+		});
+	}
+	async resolveSpeakerContext(guildId, userId) {
+		const cached = this.getCachedSpeakerContext(guildId, userId);
+		if (cached) return cached;
+		const identity = await this.resolveSpeakerIdentity(guildId, userId);
+		const context = {
+			label: identity.label,
+			senderIsOwner: this.resolveSpeakerIsOwner({
+				id: identity.id,
+				name: identity.name,
+				tag: identity.tag
+			})
+		};
+		this.setCachedSpeakerContext(guildId, userId, context);
+		return context;
+	}
+	async resolveSpeakerIdentity(guildId, userId) {
+		try {
+			const member = await this.params.client.fetchMember(guildId, userId);
+			const username = member.user?.username ?? void 0;
+			return {
+				id: userId,
+				label: member.nickname ?? member.user?.globalName ?? username ?? userId,
+				name: username,
+				tag: member.user ? formatDiscordUserTag(member.user) : void 0
+			};
+		} catch {
+			try {
+				const user = await this.params.client.fetchUser(userId);
+				const username = user.username ?? void 0;
+				return {
+					id: userId,
+					label: user.globalName ?? username ?? userId,
+					name: username,
+					tag: formatDiscordUserTag(user)
+				};
+			} catch {
+				return {
+					id: userId,
+					label: userId
+				};
+			}
+		}
+	}
+};
+var DiscordVoiceReadyListener$1 = class extends ReadyListener {
+	constructor(manager) {
+		super();
+		this.manager = manager;
+	}
+	async handle() {
+		await this.manager.autoJoin();
+	}
+};
+function isVoiceChannel(type) {
+	return type === ChannelType.GuildVoice || type === ChannelType.GuildStageVoice;
+}
+//#endregion
+//#region extensions/discord/src/voice/manager.runtime.ts
+var DiscordVoiceManager = class extends DiscordVoiceManager$1 {};
+var DiscordVoiceReadyListener = class extends DiscordVoiceReadyListener$1 {};
+//#endregion
+export { DiscordVoiceManager, DiscordVoiceReadyListener };