linkgravity 1.5.1 → 1.5.3

package/voice-service/receiver.js

@@ -0,0 +1,310 @@
+const { EndBehaviorType } = require('@discordjs/voice');
+const prism = require('prism-media');
+const { stereoToMono, createWavHeader } = require('./audioUtils');
+const { googleSTT } = require('./stt');
+const { getDetectorForUser, feedPCMToDetector, WAKE_MATCH_THRESHOLD } = require('./wakeword');
+const { interruptTTS } = require('./tts');
+const state = require('./state');
+const { activeStreams, enrollingUsers, isPlaying, wakeWordOptedOut, runtime, isGuildActive } =
+    state;
+
+function setupReceiver(connection, guildId, client) {
+    const receiver = connection.receiver;
+
+    receiver.speaking.removeAllListeners('start');
+
+    receiver.speaking.on('start', (userId) => {
+        if (client.user.id === userId) return;
+
+        if (activeStreams.get(userId)) {
+            return;
+        }
+        activeStreams.set(userId, true);
+
+        let hasInterrupted = false;
+
+        const opusStream = receiver.subscribe(userId, {
+            end: {
+                behavior: EndBehaviorType.Manual,
+            },
+        });
+        const pcmStream = opusStream.pipe(
+            new prism.opus.Decoder({ rate: 48000, channels: 2, frameSize: 960 }),
+        );
+
+        // Without a listener, an unhandled 'error' event here crashes the ENTIRE process on one bad packet.
+        opusStream.on('error', (err) => {
+            console.error(`[Voice] Opus stream error for ${userId}:`, err.message);
+            forceEndStream();
+        });
+        pcmStream.on('error', (err) => {
+            console.error(
+                `[Voice] Opus decode error for ${userId} (bad/corrupted packet):`,
+                err.message,
+            );
+            forceEndStream();
+        });
+
+        const chunks = [];
+
+        let hasEnded = false;
+
+        const forceEndStream = () => {
+            if (hasEnded) return;
+            try {
+                opusStream.destroy();
+            } catch (e) {}
+            try {
+                pcmStream.destroy();
+            } catch (e) {}
+            pcmStream.emit('end');
+        };
+
+        const maxDurationTimer = setTimeout(forceEndStream, 30000);
+
+        // Rustpotter runs in-process here, no Python round trip - detectors cached per user.
+        let wakeConfirmed = false;
+        let matchedWakeWord = null;
+        let detectorEntry = null;
+        let bestWakeScore = 0;
+        let bestWakeScoreName = null;
+        let bestDiagScore = 0;
+        let bestDiagScoreName = null;
+
+        if (!enrollingUsers.has(userId) && !isGuildActive(guildId)) {
+            getDetectorForUser(userId)
+                .then((entry) => {
+                    if (entry) {
+                        entry.rustpotter.reset();
+                        entry.residual = new Int16Array(0);
+                        entry.diag.rustpotter.reset();
+                        entry.diag.residual = new Int16Array(0);
+                        detectorEntry = entry;
+                    }
+                })
+                .catch((err) =>
+                    console.error(`[Wake] Failed to load detector for ${userId}:`, err.message),
+                );
+        }
+
+        // Only during the active/awake window - reuses the same googleSTT() call for earlier live feedback.
+        const PARTIAL_INTERVAL_MS = 1500;
+        const PARTIAL_MIN_NEW_BYTES = 24000;
+        let lastPartialLength = 0;
+        let partialSent = false;
+        const partialTimer = setInterval(async () => {
+            if (hasEnded || !isSpeaking || enrollingUsers.has(userId)) return;
+            if (!isGuildActive(guildId)) return;
+
+            const currentLength = chunks.reduce((sum, c) => sum + c.length, 0);
+            if (currentLength - lastPartialLength < PARTIAL_MIN_NEW_BYTES) return;
+            lastPartialLength = currentLength;
+
+            const windowPcm = Buffer.concat(chunks);
+            const wavHeader = createWavHeader(windowPcm.length);
+            const wavBuffer = Buffer.concat([wavHeader, windowPcm]);
+
+            const text = await googleSTT(wavBuffer);
+            partialSent = true;
+            fetch('http://127.0.0.1:18080/stt_partial', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ guild_id: guildId, text }),
+            }).catch((err) =>
+                console.error(`[STT] Failed to send partial text to Python:`, err.message),
+            );
+        }, PARTIAL_INTERVAL_MS);
+
+        let bgNoiseRMS = 500;
+        let isSpeaking = false;
+        let silenceBytes = 0;
+        let silenceTimer = null;
+
+        pcmStream.on('data', (rawChunk) => {
+            if (hasEnded) return;
+            const chunk = stereoToMono(rawChunk); // see stereoToMono's comment - decoder gives real stereo now
+
+            let sumSquare = 0;
+            for (let i = 0; i < chunk.length; i += 2) {
+                const sample = chunk.readInt16LE(i);
+                sumSquare += sample * sample;
+            }
+            const rms = Math.sqrt(sumSquare / (chunk.length / 2));
+
+            const isBotPlaying = isPlaying.get(guildId) || false;
+
+            if (!hasInterrupted) {
+                const dynamicThreshold = isBotPlaying
+                    ? runtime.vadThreshold * 3
+                    : runtime.vadThreshold;
+                if (rms > dynamicThreshold) {
+                    if (interruptTTS(guildId)) {
+                        console.log(
+                            `[VAD] Loud voice detected (${Math.round(rms)}), interrupting TTS (Threshold: ${dynamicThreshold})`,
+                        );
+                        hasInterrupted = true;
+                    }
+                }
+            }
+
+            if (detectorEntry) {
+                const detection = feedPCMToDetector(detectorEntry, chunk);
+                if (detection && detection.getScore() > bestWakeScore) {
+                    bestWakeScore = detection.getScore();
+                    bestWakeScoreName = detection.getName();
+                }
+                const diagDetection = feedPCMToDetector(detectorEntry.diag, chunk);
+                if (diagDetection && diagDetection.getScore() > bestDiagScore) {
+                    bestDiagScore = diagDetection.getScore();
+                    bestDiagScoreName = diagDetection.getName();
+                }
+            }
+
+            if (isPlaying.get(guildId)) {
+                return;
+            }
+
+            chunks.push(chunk);
+
+            if (!isSpeaking) {
+                bgNoiseRMS = bgNoiseRMS * 0.98 + rms * 0.02;
+                bgNoiseRMS = Math.max(50, Math.min(bgNoiseRMS, 3000));
+            }
+
+            const threshold = Math.max(bgNoiseRMS * 2.0, 800);
+
+            if (rms > threshold) {
+                isSpeaking = true;
+                silenceBytes = 0;
+            } else {
+                if (isSpeaking) {
+                    silenceBytes += chunk.length;
+                    if (silenceBytes >= 76800) {
+                        forceEndStream();
+                        return;
+                    }
+                }
+            }
+
+            if (isSpeaking) {
+                if (silenceTimer) clearTimeout(silenceTimer);
+                silenceTimer = setTimeout(() => forceEndStream(), 800);
+            }
+        });
+
+        pcmStream.on('end', async () => {
+            if (hasEnded) return;
+            hasEnded = true;
+            clearTimeout(maxDurationTimer);
+            clearInterval(partialTimer);
+            if (silenceTimer) clearTimeout(silenceTimer);
+
+            activeStreams.delete(userId);
+
+            if (detectorEntry) {
+                // Live capture stops before rustpotter's confirm countdown finishes, so pad with
+                // silence to let a genuine match finalize instead of being silently discarded.
+                const paddingBuffer = Buffer.alloc(detectorEntry.samplesPerFrame * 100 * 2);
+                const paddingDetection = feedPCMToDetector(detectorEntry, paddingBuffer);
+                if (paddingDetection && paddingDetection.getScore() > bestWakeScore) {
+                    bestWakeScore = paddingDetection.getScore();
+                    bestWakeScoreName = paddingDetection.getName();
+                }
+                const diagPaddingBuffer = Buffer.alloc(
+                    detectorEntry.diag.samplesPerFrame * 100 * 2,
+                );
+                const diagPaddingDetection = feedPCMToDetector(
+                    detectorEntry.diag,
+                    diagPaddingBuffer,
+                );
+                if (diagPaddingDetection && diagPaddingDetection.getScore() > bestDiagScore) {
+                    bestDiagScore = diagPaddingDetection.getScore();
+                    bestDiagScoreName = diagPaddingDetection.getName();
+                }
+
+                // Real pass/fail uses bestWakeScore; bestDiagScore is a separate, much looser detector shown only for "how close" - not on the same scale, not comparable to WAKE_MATCH_THRESHOLD.
+                wakeConfirmed = bestWakeScore >= WAKE_MATCH_THRESHOLD;
+                matchedWakeWord = wakeConfirmed ? bestWakeScoreName : null;
+                console.log(
+                    wakeConfirmed
+                        ? `[Wake] ${userId}: CONFIRMED (score ${bestWakeScore.toFixed(3)} for ` +
+                              `"${bestWakeScoreName}", threshold ${WAKE_MATCH_THRESHOLD})`
+                        : `[Wake] ${userId}: no match (score ${bestWakeScore.toFixed(3)}, ` +
+                              `threshold ${WAKE_MATCH_THRESHOLD}; diagnostic-only closeness ` +
+                              `${bestDiagScore.toFixed(3)} for "${bestDiagScoreName ?? 'n/a'}" - ` +
+                              `different scoring config, not directly comparable to the threshold)`,
+                );
+            }
+
+            const pcmBuffer = Buffer.concat(chunks);
+
+            // Enrollment mode: this is a reference sample, not a command - skip wake-check/STT.
+            if (enrollingUsers.has(userId)) {
+                if (pcmBuffer.length < 4000) return; // too short to be a real sample
+                const wavHeader = createWavHeader(pcmBuffer.length);
+                const wavBuffer = Buffer.concat([wavHeader, pcmBuffer]);
+                try {
+                    await fetch(
+                        `http://127.0.0.1:18080/enroll_sample?user_id=${encodeURIComponent(userId)}`,
+                        {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/octet-stream' },
+                            body: wavBuffer,
+                        },
+                    );
+                } catch (err) {
+                    console.error(`[Enroll] Failed to send sample to Python:`, err.message);
+                }
+                return;
+            }
+
+            // Was 24000 (250ms) - cut off short Korean replies ("네"/"어"/"응"); noise is filtered upstream by isSpeaking's RMS/sustain check, not by duration.
+            if (pcmBuffer.length < 9600) {
+                if (partialSent) {
+                    fetch('http://127.0.0.1:18080/stt_partial_cancel', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ guild_id: guildId }),
+                    }).catch(() => {});
+                }
+                return;
+            }
+
+            const shouldTranscribe =
+                isGuildActive(guildId) || wakeConfirmed || wakeWordOptedOut.has(userId);
+
+            if (!shouldTranscribe) {
+                if (partialSent) {
+                    fetch('http://127.0.0.1:18080/stt_partial_cancel', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ guild_id: guildId }),
+                    }).catch(() => {});
+                }
+                return;
+            }
+
+            const wavHeader = createWavHeader(pcmBuffer.length);
+            const wavBuffer = Buffer.concat([wavHeader, pcmBuffer]);
+            const text = await googleSTT(wavBuffer);
+
+            try {
+                await fetch('http://127.0.0.1:18080/stt_input', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        user_id: userId,
+                        guild_id: guildId,
+                        text,
+                        wake_confirmed: wakeConfirmed,
+                        matched_wake_word: matchedWakeWord,
+                    }),
+                });
+            } catch (err) {
+                console.error(`[STT] Failed to send recognized text to Python:`, err.message);
+            }
+        });
+    });
+}
+
+module.exports = { setupReceiver };

package/voice-service/routes.js

@@ -0,0 +1,182 @@
+const express = require('express');
+const { joinVoiceChannel, VoiceConnectionStatus } = require('@discordjs/voice');
+const state = require('./state');
+const { setupReceiver } = require('./receiver');
+const { interruptTTS, playNextInQueue } = require('./tts');
+const { loadRustpotterModule } = require('./wakeword');
+
+function registerRoutes(app, client) {
+    app.get('/health', (req, res) => {
+        res.json({ ready: client.isReady() });
+    });
+
+    app.post('/join', async (req, res) => {
+        const { guild_id, channel_id } = req.body;
+        try {
+            const guild = client.guilds.cache.get(guild_id);
+            if (!guild) return res.status(404).json({ error: 'Guild not found' });
+
+            let connection = joinVoiceChannel({
+                channelId: channel_id,
+                guildId: guild_id,
+                adapterCreator: guild.voiceAdapterCreator,
+                selfDeaf: false,
+                selfMute: false,
+            });
+
+            state.connections.set(guild_id, connection);
+
+            setupReceiver(connection, guild_id, client);
+
+            connection.removeAllListeners(VoiceConnectionStatus.Ready);
+            connection.on(VoiceConnectionStatus.Ready, () => {
+                console.log(`[Voice] Connected to ${channel_id} in ${guild_id}`);
+            });
+
+            res.json({ success: true });
+        } catch (e) {
+            console.error(e);
+            res.status(500).json({ error: e.message });
+        }
+    });
+
+    app.post('/leave', (req, res) => {
+        const { guild_id } = req.body;
+        const connection = state.connections.get(guild_id);
+        if (!connection) {
+            return res.status(404).json({ error: 'Not connected' });
+        }
+
+        const player = state.players.get(guild_id);
+        if (player) {
+            try {
+                player.stop(true);
+            } catch (e) {
+                // already stopped/destroyed - fine
+            }
+        }
+        connection.destroy();
+
+        // Without this, a stale isPlaying/players entry silently breaks STT/wake detection on the next /join.
+        state.connections.delete(guild_id);
+        state.players.delete(guild_id);
+        state.audioQueues.delete(guild_id);
+        state.isPlaying.delete(guild_id);
+        state.activeUntil.delete(guild_id);
+        state.suppressNotifyMap.delete(guild_id);
+
+        res.json({ success: true });
+    });
+
+    app.post(
+        '/play',
+        express.raw({ type: 'application/octet-stream', limit: '20mb' }),
+        (req, res) => {
+            const guild_id = req.query.guild_id;
+            const connection = state.connections.get(guild_id);
+            if (!connection) return res.status(404).json({ error: 'Not connected' });
+
+            if (!state.audioQueues.has(guild_id)) {
+                state.audioQueues.set(guild_id, []);
+            }
+
+            state.audioQueues.get(guild_id).push({
+                buffer: req.body, // req.body is a Buffer here
+                suppressActiveWindow: req.query.suppress_active_window === 'true',
+            });
+
+            if (!state.isPlaying.get(guild_id)) {
+                playNextInQueue(guild_id);
+            }
+
+            res.json({ success: true, queued: true });
+        },
+    );
+
+    app.post('/interrupt', (req, res) => {
+        const { guild_id } = req.body;
+        // Lets Python trigger the same cutoff the VAD loud-voice check uses, regardless of volume.
+        interruptTTS(guild_id);
+        res.json({ success: true });
+    });
+
+    app.post('/invalidate_detector', (req, res) => {
+        // Without this, detectorCache keeps serving the OLD .rpw after a user re-enrolls.
+        const { user_id } = req.body;
+        const deleted = state.detectorCache.delete(user_id);
+        console.log(`[Wake] Invalidated cached detector for ${user_id} (was cached: ${deleted})`);
+        res.json({ success: true, was_cached: deleted });
+    });
+
+    app.post('/build_wakeword', async (req, res) => {
+        // Builds a .rpw in-process via WakewordRefCreator, instead of shelling out to rustpotter-cli.
+        try {
+            const { name, samples } = req.body;
+            if (!name || !Array.isArray(samples) || samples.length === 0) {
+                return res
+                    .status(400)
+                    .json({ error: 'name and at least one sample (wav bytes) are required' });
+            }
+
+            const mod = await loadRustpotterModule();
+            const creator = mod.WakewordRefCreator.new(name);
+            try {
+                for (const sample of samples) {
+                    const buf = Buffer.from(sample.data_base64, 'base64');
+                    creator.addFile(sample.filename || `${name}.wav`, buf);
+                }
+                const rpwBytes = creator.saveToBytes();
+                console.log(
+                    `[Wake] Built .rpw for '${name}' from ${samples.length} sample(s) via WakewordRefCreator`,
+                );
+                res.json({ success: true, rpw_base64: Buffer.from(rpwBytes).toString('base64') });
+            } finally {
+                creator.free();
+            }
+        } catch (e) {
+            console.error(`[Wake] Failed to build wakeword reference:`, e);
+            res.status(500).json({ error: e.message || String(e) });
+        }
+    });
+
+    app.post('/set_config', (req, res) => {
+        const { voice_threshold } = req.body;
+        if (voice_threshold) {
+            state.runtime.vadThreshold = voice_threshold;
+            console.log(`[Config] Updated VAD threshold to ${state.runtime.vadThreshold}`);
+        }
+        res.json({ success: true });
+    });
+
+    app.post('/enroll_start', (req, res) => {
+        const { user_id } = req.body;
+        if (!user_id) return res.status(400).json({ error: 'user_id required' });
+        state.enrollingUsers.add(user_id);
+        res.json({ success: true });
+    });
+
+    app.post('/enroll_stop', (req, res) => {
+        const { user_id } = req.body;
+        if (!user_id) return res.status(400).json({ error: 'user_id required' });
+        state.enrollingUsers.delete(user_id);
+        res.json({ success: true });
+    });
+
+    app.post('/set_active', (req, res) => {
+        const { guild_id, active_until } = req.body;
+        if (!guild_id || !active_until)
+            return res.status(400).json({ error: 'guild_id and active_until required' });
+        state.activeUntil.set(guild_id, active_until);
+        res.json({ success: true });
+    });
+
+    app.post('/set_wake_word_required', (req, res) => {
+        const { user_id, required } = req.body;
+        if (!user_id) return res.status(400).json({ error: 'user_id required' });
+        if (required) state.wakeWordOptedOut.delete(user_id);
+        else state.wakeWordOptedOut.add(user_id);
+        res.json({ success: true });
+    });
+}
+
+module.exports = { registerRoutes };

package/voice-service/state.js

@@ -0,0 +1,42 @@
+const connections = new Map();
+const players = new Map();
+const audioQueues = new Map();
+const isPlaying = new Map();
+const activeStreams = new Map();
+
+// user_id -> recording wake-word samples right now; routes to /enroll_sample instead of STT.
+const enrollingUsers = new Set();
+
+// guild_id -> ms epoch until the "awake, skip wake word" window closes (set via /set_active).
+const activeUntil = new Map();
+
+// user_id -> opted out of wake-word gating via /sound - scoped per-user, unlike activeUntil.
+const wakeWordOptedOut = new Set();
+
+// Whether finished audio should extend the "stay awake" window (false for enrollment playback).
+const suppressNotifyMap = new Map();
+
+// userId -> { rustpotter, samplesPerFrame, residual: Int16Array }
+const detectorCache = new Map();
+
+// Object property, not a plain `let` - a `let` wouldn't propagate its reassignment across modules.
+const runtime = { vadThreshold: 3000 };
+
+function isGuildActive(guildId) {
+    return Date.now() < (activeUntil.get(guildId) || 0);
+}
+
+module.exports = {
+    connections,
+    players,
+    audioQueues,
+    isPlaying,
+    activeStreams,
+    enrollingUsers,
+    activeUntil,
+    wakeWordOptedOut,
+    suppressNotifyMap,
+    detectorCache,
+    runtime,
+    isGuildActive,
+};

package/voice-service/stt.js

@@ -0,0 +1,71 @@
+const { spawn } = require('child_process');
+const ffmpegPath = require('ffmpeg-static');
+
+// Unofficial Google STT key - same default Python's SpeechRecognition (recognize_google) ships with.
+const GOOGLE_STT_KEY = 'AIzaSyBOti4mM-6x9WDnZIjIeyEU21OpBXqWBgw';
+
+function flacEncode(wavBuffer) {
+    return new Promise((resolve, reject) => {
+        const ff = spawn(ffmpegPath, [
+            '-hide_banner',
+            '-loglevel',
+            'error',
+            '-i',
+            'pipe:0',
+            '-f',
+            'flac',
+            'pipe:1',
+        ]);
+        const out = [];
+        ff.stdout.on('data', (d) => out.push(d));
+        ff.stderr.on('data', () => {}); // -loglevel error already keeps this quiet in the normal case
+        ff.on('error', (err) => reject(new Error(`ffmpeg-static failed to run (${err.message})`)));
+        ff.on('close', (code) => {
+            if (code !== 0) return reject(new Error(`ffmpeg exited with code ${code}`));
+            resolve(Buffer.concat(out));
+        });
+        ff.stdin.write(wavBuffer);
+        ff.stdin.end();
+    });
+}
+
+async function googleSTT(wavBuffer, lang = 'ko-KR') {
+    let flacBuffer;
+    try {
+        flacBuffer = await flacEncode(wavBuffer);
+    } catch (err) {
+        console.error('[STT] FLAC encode failed:', err.message);
+        return null;
+    }
+
+    let res;
+    try {
+        res = await fetch(
+            `https://www.google.com/speech-api/v2/recognize?output=json&client=chromium&lang=${encodeURIComponent(lang)}&key=${GOOGLE_STT_KEY}`,
+            {
+                method: 'POST',
+                headers: { 'Content-Type': 'audio/x-flac; rate=48000' },
+                body: flacBuffer,
+            },
+        );
+    } catch (err) {
+        console.error('[STT] Request to Google STT failed:', err.message);
+        return null;
+    }
+
+    const raw = await res.text();
+    // Response is newline-delimited JSON, one object per line.
+    for (const line of raw.trim().split('\n')) {
+        if (!line) continue;
+        try {
+            const obj = JSON.parse(line);
+            const transcript = obj.result?.[0]?.alternative?.[0]?.transcript;
+            if (transcript) return transcript.trim();
+        } catch (e) {
+            // not JSON / partial line - ignore
+        }
+    }
+    return null;
+}
+
+module.exports = { googleSTT };

package/voice-service/tts.js

@@ -0,0 +1,81 @@
+const { Readable } = require('stream');
+const { createAudioPlayer, createAudioResource, AudioPlayerStatus } = require('@discordjs/voice');
+const { players, audioQueues, isPlaying, connections, suppressNotifyMap } = require('./state');
+
+function interruptTTS(guildId) {
+    const player = players.get(guildId);
+    let interrupted = false;
+
+    if (audioQueues.has(guildId)) {
+        // Queue holds in-memory Buffers (see /play), not filepaths - nothing on disk to clean up.
+        audioQueues.set(guildId, []);
+    }
+
+    if (player && player.state.status !== AudioPlayerStatus.Idle) {
+        player.stop();
+        console.log(`[VAD] Interrupted TTS in guild ${guildId}`);
+        interrupted = true;
+    }
+
+    isPlaying.set(guildId, false);
+    return interrupted;
+}
+
+async function notifyTtsFinished(guild_id) {
+    try {
+        await fetch('http://127.0.0.1:18080/tts_finished', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ guild_id }),
+        });
+    } catch (err) {
+        console.error(`[TTS] Failed to notify Python of playback completion:`, err.message);
+    }
+}
+
+function playNextInQueue(guild_id) {
+    const queue = audioQueues.get(guild_id) || [];
+    if (queue.length === 0) {
+        isPlaying.set(guild_id, false);
+        if (!suppressNotifyMap.get(guild_id)) {
+            notifyTtsFinished(guild_id);
+        }
+        return;
+    }
+
+    const connection = connections.get(guild_id);
+    if (!connection) {
+        isPlaying.set(guild_id, false);
+        return;
+    }
+
+    isPlaying.set(guild_id, true);
+    const item = queue.shift(); // { buffer, suppressActiveWindow }
+    suppressNotifyMap.set(guild_id, item.suppressActiveWindow);
+
+    try {
+        let player = players.get(guild_id);
+        if (!player) {
+            player = createAudioPlayer();
+            players.set(guild_id, player);
+            connection.subscribe(player);
+
+            player.on(AudioPlayerStatus.Idle, () => {
+                playNextInQueue(guild_id);
+            });
+
+            player.on('error', (error) => {
+                console.error(`[TTS] AudioPlayer Error:`, error.message);
+                playNextInQueue(guild_id);
+            });
+        }
+
+        const resource = createAudioResource(Readable.from(item.buffer));
+        player.play(resource);
+    } catch (e) {
+        console.error(`[TTS] Error playing queued audio:`, e);
+        playNextInQueue(guild_id);
+    }
+}
+
+module.exports = { interruptTTS, notifyTtsFinished, playNextInQueue };