Merge pull request 'Voice related fixes, alongside simplifying assistant' (#5) from dev into main

Reviewed-on: https://codeberg.org/salmonik/senator-sperma/pulls/5

10 files changed, 429 insertions, 557 deletions

diff --git a/cogs/ai.py b/cogs/ai.py
index c9237c4..ef2ba7c 100644
--- a/cogs/ai.py
+++ b/cogs/ai.py
@@ -9,7 +9,6 @@ from discord.ext import commands
 import logging
 import httpx
 from gtts import gTTS
-from cogs.music import audio_playback
 import io
 
 logger = logging.getLogger(__name__)
@@ -61,12 +60,14 @@ class AI(commands.Cog):
             else:
                 response_text = response_data["choices"][0]["message"]["content"]
                 if tts:
-                    # Generate TTS
                     tts_obj = gTTS(text=response_text, lang='pl')
                     tts_buffer = io.BytesIO()
                     tts_obj.write_to_fp(tts_buffer)
                     tts_buffer.seek(0)
-                    await audio_playback.AudioPlaybackManager.play(ctx, discord.FFmpegPCMAudio(tts_buffer), delete_after_play=True, interrupt=False)
+                    from cogs.voice import get_voice_manager
+                    vm = get_voice_manager(self.bot)
+                    channel = ctx.author.voice.channel
+                    await vm.play_source(channel, discord.FFmpegPCMAudio(tts_buffer), interrupt=False)
 
                 else:
                     await ctx.send_followup(response_text)
diff --git a/cogs/assistant.py b/cogs/assistant.py
index a91d027..fed7825 100644
--- a/cogs/assistant.py
+++ b/cogs/assistant.py
@@ -3,16 +3,11 @@
 # Copyright (C) 2026 Salmonik @ salmonik@tuta.io
 # https://codeberg.org/salmonik/senator-sperma
 
-import re
 import discord
 from discord.ext import commands
 import httpx
-import json
 import logging
-import shutil
 import os
-from tempfile import NamedTemporaryFile
-from cogs.downloader import Downloader
 
 logger = logging.getLogger(__name__)
 
@@ -46,15 +41,16 @@ class Jarvis(commands.Cog):
         messages = Jarvis._build_messages(message, chain)
         payload = Jarvis._build_payload(messages)
 
-        response_data = await Jarvis._make_api_request(payload, headers)
-        response_message, action = Jarvis._parse_response(response_data)
+        response_data = await Jarvis._safe_api_call(payload, headers)
+        if response_data is None:
+            await message.reply("Przepraszam, nie mogę teraz odpowiedzieć. Spróbuj ponownie później.")
+            return
+
+        response_message = Jarvis._parse_response(response_data)
 
         channel = message.channel
         await message.reply(response_message)
 
-        if action == "download":
-            await Jarvis._handle_download_action(message, channel)
-
     @staticmethod
     async def _build_message_chain(message):
         chain = []
@@ -80,10 +76,10 @@ class Jarvis(commands.Cog):
         messages = [{
             "role": "system",
             "content": "Jesteś Senator Sperma Armostrong, także znany jako Jarvis."
-                       "Twoim zadaniem, po za asystowaniem użytkownika, jest mówienie programowi nadrzędnemu jak sie zachować"
-                       "pole 'message' może być tylko wypełnione w języku Polskim."
+                       "Twoim zadaniem jest asystowanie użytkownika"
                        "zachowuj sie jak Jarvis, bądź osobistym asystentem użytkownika, nie używaj emotikon"
-                       "nie pytaj sie użytkownika czy chcesz abyś coś zrobił, użytkownik ci sam powie abyś coś wykonał"
+                       "nie pytaj sie użytkownika czy chce abyś coś zrobił, użytkownik ci sam powie abyś coś wykonał"
+                       "Nie pozostawiaj wiadomości pustej oraz nie dawaj swojej wiadomości w pole myślenia"
         }]
 
         if chain is None:
@@ -92,7 +88,7 @@ class Jarvis(commands.Cog):
         for msg in chain:
             messages.append({
                 "role": "user",
-                "content": f"{msg.author.display_name}: {msg.content}"
+                "content": f"USER: {msg.author.display_name}\nMESSAGE: {msg.content}"
             })
 
         return messages
@@ -102,38 +98,12 @@ class Jarvis(commands.Cog):
         return {
             "model": os.getenv("OPENROUTER_MODEL"),
             "messages": messages,
-            "response_format": Jarvis._get_response_schema(),
             "plugins": [{"id": "response-healing"}]
         }
 
     @staticmethod
-    def _get_response_schema():
-        return {
-            "type": "json_schema",
-            "json_schema": {
-                "name": "response",
-                "strict": True,
-                "schema": {
-                    "type": "object",
-                    "properties": {
-                        "message": {
-                            "type": "string",
-                            "description": "the message that user will receive",
-                        },
-                        "action": {
-                            "type": "string",
-                            "description": "the action to do, either download, compress or none"
-                        }
-                    },
-                    "required": ["message", "action"],
-                    "additionalProperties": False,
-                }
-            }
-        }
-
-    @staticmethod
     async def _make_api_request(payload, headers):
-        async with httpx.AsyncClient() as client:
+        async with httpx.AsyncClient(timeout=30.0) as client:
             url = "https://openrouter.ai/api/v1/chat/completions"
             response = await client.post(url=url, headers=headers, json=payload)
             response_data = response.json()
@@ -141,62 +111,20 @@ class Jarvis(commands.Cog):
             return response_data
 
     @staticmethod
-    def _parse_response(response_data):
-        content = response_data['choices'][0]['message']['content']
-        inner_json_str = content.strip('```json\n').strip('```').strip()
+    async def _safe_api_call(payload, headers):
         try:
-            inner_data = json.loads(inner_json_str)
-            response_message = inner_data['message']
-            action = inner_data['action']
-        except (json.JSONDecodeError, KeyError):
-            response_message = content
-            action = "none"
-
-        logger.info(response_message)
-        logger.info(action)
-
-        return response_message, action
+            return await Jarvis._make_api_request(payload, headers)
+        except httpx.HTTPError as e:
+            logger.error(f"API request failed: {e}")
+            return None
 
     @staticmethod
-    async def _handle_download_action(message, channel):
-        url_match = Jarvis._extract_url(message.content)
-        if not url_match:
-            await channel.send("Nie znaleziono poprawnego linku w odpowiedzi.")
-            return
-
-        response = await Downloader.download_standalone(url=url_match)
-        await Jarvis._process_download_response(response, channel)
-
-    @staticmethod
-    def _extract_url(content):
-        match = re.search(r'https://(?:[A-Za-z0-9-]+\.)*[A-Za-z0-9-]{1,63}\.[A-Za-z]{2,63}/\S*', content)
-        return match.group(0) if match else None
-
-    @staticmethod
-    async def _process_download_response(response, channel):
-        if not isinstance(response, dict):
-            return
+    def _parse_response(response_data):
+        content = response_data['choices'][0]['message']['content']
 
-        if response["status"] == "success":
-            await Jarvis._handle_successful_download(response, channel)
-        else:
-            await Jarvis._handle_failed_download(response)
+        logger.info(content)
 
-    @staticmethod
-    async def _handle_successful_download(response, channel):
-        if response["type"] == "url":
-            await channel.send(f"pobioron i wysyłon: {response['content']}")
-        elif response["type"] == "file":
-            file_data = response["content"]
-            await channel.send("wysyłon:", file=discord.File(file_data))
-            shutil.rmtree(response["temp_dir"])
-
-    @staticmethod
-    async def _handle_failed_download(response):
-        logger.error(f"Error: {response['content']}")
-        if 'details' in response:
-            logger.error(f"Details: {response['details']}")
-        shutil.rmtree(response["temp_dir"])
+        return content
 
 def setup(bot):
     bot.add_cog(Jarvis(bot))
diff --git a/cogs/cron.py b/cogs/cron.py
index aad43d2..ee88085 100644
--- a/cogs/cron.py
+++ b/cogs/cron.py
@@ -145,29 +145,23 @@ class Cron(commands.Cog):
 
         if isinstance(channel, discord.VoiceChannel):
             voice_mgr = get_voice_manager(self.bot)
-            voice_client = await voice_mgr.join_channel(channel)
-            if not voice_client:
-                if channel.guild.system_channel:
-                    await channel.guild.system_channel.send(
-                        "Nie udano się połączyć z kanałem głosowym"
-                    )
-                return
 
             try:
                 audio_source = discord.FFmpegPCMAudio(audio_url)
-                voice_client.play(audio_source)
+                success = await voice_mgr.play_source(channel, audio_source)
 
-                while voice_client.is_playing():
-                    await asyncio.sleep(1)
+                if success:
+                    logger.info(f"Finished playing audio: {audio_url}")
+                else:
+                    raise Exception("Playback failed")
 
-                logger.info("Audio playback finished normally - disconnecting")
-                await voice_client.disconnect()
-                logger.info(f"Finished playing audio: {audio_url}")
+                await voice_mgr.disconnect(channel.guild)
             except Exception as e:
                 logger.error(f"Error playing audio: {e}")
-                if voice_client.is_connected():
-                    logger.info("Audio playback failed - disconnecting")
-                    await voice_client.disconnect()
+                try:
+                    await voice_mgr.disconnect(channel.guild)
+                except Exception:
+                    pass
                 if channel.guild.system_channel:
                     await channel.guild.system_channel.send(
                         f"Błąd podczas odgrywania audio: {audio_url}"
diff --git a/cogs/music/audio_playback.py b/cogs/music/audio_playback.py
deleted file mode 100644
index 1313d01..0000000
--- a/cogs/music/audio_playback.py
+++ /dev/null
@@ -1,282 +0,0 @@
-# This file is part of Senator Sperma
-# Licensed under the GPL-3.0 License
-# Copyright (C) 2026 Salmonik @ salmonik@tuta.io
-# https://codeberg.org/salmonik/senator-sperma
-
-import asyncio
-import logging
-import os
-import urllib.parse
-
-import discord
-import mutagen
-
-logger = logging.getLogger(__name__)
-
-
-class AudioPlaybackManager:
-    """Handles audio playback, voice connections, and source preparation."""
-
-    @staticmethod
-    async def cleanup_temp_file(source):
-        """Clean up temporary file if it exists."""
-        if source and os.path.exists(source):
-            try:
-                os.remove(source)
-                logger.info(f"Cleaned up temporary file: {source}")
-            except Exception as e:
-                logger.error(f"Error cleaning up file {source}: {str(e)}")
-
-    @staticmethod
-    async def validate_voice_channel(ctx):
-        """Validate user is in a voice channel. Returns channel or None."""
-        if not ctx.author.voice or not ctx.author.voice.channel:
-            await ctx.respond(
-                "Musisz być na kanale głosowym, żebym mógł dołączyć!", ephemeral=True
-            )
-            return None
-        return ctx.author.voice.channel
-
-    @staticmethod
-    async def prepare_file_source(source):
-        """Prepare and validate local file source. Returns (display_name, absolute_path) or (None, None)."""
-        logger.info(f"Attempting to play local file: {source}")
-
-        # Get absolute path and verify file exists
-        if not os.path.isabs(source):
-            source = os.path.abspath(source)
-            logger.debug(f"Converted to absolute path: {source}")
-
-        if not os.path.exists(source):
-            logger.error(f"File not found: {source}")
-            return None, None
-
-        filename = os.path.basename(source)
-        display_name = os.path.splitext(filename)[0]
-        return display_name, source
-
-    @staticmethod
-    async def connect_to_voice_channel(ctx, vc, target_channel):
-        """Connect or move to voice channel. Returns voice client."""
-        try:
-            # Check if vc is valid and actually connected
-            if vc is not None and vc.is_connected():
-                # Already connected - check if need to move
-                if vc.channel != target_channel:
-                    logger.info(f"Moving to voice channel: {target_channel.name}")
-                    await vc.move_to(target_channel)
-                    logger.info(f"Moved to voice channel: {target_channel.name}")
-                return vc
-
-            # Not connected - connect now
-            logger.info(f"Connecting to voice channel: {target_channel.name}")
-            vc = await target_channel.connect()
-            logger.info(f"Connected to voice channel: {target_channel.name}")
-            return vc
-        except Exception as e:
-            logger.error(f"Error connecting to voice channel: {str(e)}")
-            raise
-
-    @staticmethod
-    async def prepare_audio_source(source, is_url, display_name):
-        """Prepare audio source for playback. Returns (source, final_display_name)."""
-        if is_url:
-            # For URLs, use FFmpeg with the direct URL and extract clean filename
-            before_options = "-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5"
-            audio_source = discord.FFmpegPCMAudio(source, before_options=before_options)
-            # Extract clean filename for URL (remove extension and decode URL encoding)
-            filename = os.path.basename(source.split("?")[0])  # Remove query parameters
-            filename = urllib.parse.unquote(filename)  # Decode URL encoding
-            clean_filename = os.path.splitext(filename)[0]  # Remove file extension
-            return audio_source, clean_filename
-        else:
-            # For local files, use default options
-            audio_source = discord.FFmpegPCMAudio(source=source)
-
-            # Try to get metadata for local files
-            try:
-                metadata = mutagen.open(source)  # type: ignore[call-overload]
-                if metadata:
-                    title = (
-                        metadata.get("title", [None])[0]
-                        if hasattr(metadata, "get")
-                        else None
-                    )
-                    if title:
-                        display_name = title
-                        logger.debug(f"Read metadata - title: {title}")
-                else:
-                    display_name = os.path.splitext(os.path.basename(source))[0]
-            except Exception as e:
-                logger.warning(f"Could not read metadata from {source}: {str(e)}")
-                display_name = os.path.splitext(os.path.basename(source))[0]
-
-            return audio_source, display_name
-
-    @staticmethod
-    async def cleanup_if_needed(source, delete_after_play, is_url):
-        """Clean up temporary file if needed."""
-        if delete_after_play and not is_url:
-            await AudioPlaybackManager.cleanup_temp_file(source)
-
-    @staticmethod
-    async def prepare_source(ctx, source):
-        """Prepare source and get display name. Returns (source, display_name, is_url) or (None, None, None)."""
-        is_url = source.startswith(("http://", "https://"))
-
-        if is_url:
-            logger.info(f"Attempting to play stream from URL: {source}")
-            return source, source, is_url
-
-        display_name, absolute_source = await AudioPlaybackManager.prepare_file_source(
-            source
-        )
-        if not display_name:
-            return None, None, None
-
-        return absolute_source, display_name, is_url
-
-    @staticmethod
-    async def execute_playback(ctx, source, display_name, is_url, interrupt=True):
-        """Execute the actual audio playback.
-
-        Args:
-            ctx: Discord context
-            source: Audio source path or URL
-            display_name: Name to display
-            is_url: Whether source is a URL
-            interrupt: If True, stop any currently playing audio. If False, skip if audio is playing.
-        """
-        target_channel = await AudioPlaybackManager.validate_voice_channel(ctx)
-        if not target_channel:
-            return False
-
-        # Get existing voice client from bot or connect
-        guild = ctx.guild
-        vc = discord.utils.get(ctx.bot.voice_clients, guild=guild)
-
-        try:
-            # Handle various connection states
-            if vc is None:
-                logger.info("No existing voice client, connecting...")
-                try:
-                    vc = await target_channel.connect()
-                except discord.ClientException:
-                    vc = discord.utils.get(ctx.bot.voice_clients, guild=guild)
-            elif not vc.is_connected():
-                logger.info("Voice client exists but disconnected, reconnecting...")
-                try:
-                    await vc.disconnect()
-                except Exception:
-                    pass
-                try:
-                    vc = await target_channel.connect()
-                except discord.ClientException:
-                    vc = discord.utils.get(ctx.bot.voice_clients, guild=guild)
-            elif vc.channel != target_channel:
-                logger.info(f"Moving to voice channel: {target_channel.name}")
-                await vc.move_to(target_channel)
-
-            # Stop any currently playing audio (if interrupt is True)
-            if interrupt and (vc.is_playing() or vc.is_paused()):  # type: ignore[union-attr]
-                vc.stop()  # type: ignore[union-attr]
-            elif not interrupt and vc.is_playing():  # type: ignore[union-attr]
-                logger.info("Audio already playing and interrupt=False, skipping playback")
-                return False
-
-            # Prepare audio source
-            (
-                audio_source,
-                final_display_name,
-            ) = await AudioPlaybackManager.prepare_audio_source(
-                source, is_url, display_name
-            )
-
-            # Track playback state
-            playback_state = {"error": None, "finished": False}
-
-            def after_playing(error):
-                if error:
-                    playback_state["error"] = str(error)
-                    logger.error(f"Playback error: {error}")
-                playback_state["finished"] = True
-
-            # Play the audio
-            vc.play(audio_source, after=after_playing)
-            logger.info(f"Playing: {final_display_name}")
-            await ctx.followup.send(f"grom: {final_display_name}")
-
-            # Wait for FFmpeg to attempt connection - errors usually happen within 5 seconds
-            await asyncio.sleep(5)
-
-            # Check if playback failed to start (not just finished quickly)
-            if playback_state["error"]:
-                logger.error(f"Playback failed: {playback_state['error']}")
-                await ctx.followup.send(
-                    "eror: Timeout - nie udało się połączyć ze streamem", ephemeral=True
-                )
-                return False
-
-            # If playback finished within 5s, it was a short file - not an error
-            if playback_state["finished"]:
-                logger.info(f"Playback completed quickly: {final_display_name}")
-                return True
-
-            if not vc.is_playing():
-                logger.error(f"Stream failed - not playing after 5s: {source}")
-                await ctx.followup.send(
-                    "eror: Timeout - nie udało się połączyć ze streamem", ephemeral=True
-                )
-                return False
-
-            return True
-
-        except Exception as e:
-            logger.error(f"Error in play: {str(e)}", exc_info=True)
-            await ctx.followup.send(f"eror: {str(e)}", ephemeral=True)
-            return False
-
-    @staticmethod
-    async def validate_and_prepare_source(ctx, source):
-        """Validate and prepare source for playback. Returns (source, display_name, is_url) or (None, None, None)."""
-        (
-            prepared_source,
-            display_name,
-            is_url,
-        ) = await AudioPlaybackManager.prepare_source(ctx, source)
-        if not prepared_source:
-            return None, None, None
-        return prepared_source, display_name, is_url
-
-    @staticmethod
-    async def play(ctx, source, delete_after_play=False, interrupt=True):
-        """Play audio from a local file or URL.
-
-        Args:
-            ctx: Discord context
-            source: Either a local file path or a URL to stream from
-            delete_after_play: If True, delete the file after playing (only for local files)
-            interrupt: If True, stop any currently playing audio. If False, skip if audio is playing.
-        """
-        # Validate and prepare source
-        (
-            prepared_source,
-            display_name,
-            is_url,
-        ) = await AudioPlaybackManager.validate_and_prepare_source(ctx, source)
-        if not prepared_source:
-            await AudioPlaybackManager.cleanup_if_needed(
-                source, delete_after_play, False
-            )
-            return
-
-        # Execute playback
-        success = await AudioPlaybackManager.execute_playback(
-            ctx, prepared_source, display_name, is_url, interrupt
-        )
-
-        # Cleanup if needed
-        if not success:
-            await AudioPlaybackManager.cleanup_if_needed(
-                prepared_source, delete_after_play, is_url
-            )
diff --git a/cogs/music/join.py b/cogs/music/join.py
index c613b10..d68ca79 100644
--- a/cogs/music/join.py
+++ b/cogs/music/join.py
@@ -6,6 +6,7 @@
 import logging
 
 from discord.ext import commands
+from cogs.voice import get_voice_manager
 
 logger = logging.getLogger(__name__)
 
@@ -16,8 +17,9 @@ class Join(commands.Cog):
 
     @commands.slash_command(name="join", description="dołącza do kanalu")
     async def join(self, ctx):
+        voice_mgr = get_voice_manager(self.bot)
         channel = ctx.author.voice.channel
-        await channel.connect()
+        await voice_mgr.connect(channel)
         await ctx.respond(content="\u200b", ephemeral=True)
         await ctx.interaction.delete_original_response()
         logger.info("Bot connected to voice channel")
diff --git a/cogs/music/play_commands.py b/cogs/music/play_commands.py
index 80a30ef..c6a55b0 100644
--- a/cogs/music/play_commands.py
+++ b/cogs/music/play_commands.py
@@ -17,10 +17,11 @@ import discord
 from discord.commands import OptionChoice
 from discord.ext import commands
 
-from cogs.music import audio_playback, media_processing
+from cogs.music import media_processing
 from cogs.utils.file_search import UniversalSearcher
 from cogs.utils.settings import get_uploadurl
 from cogs.utils.url_helper import clean_url_for_ytdlp
+from cogs.voice import get_voice_manager
 
 logger = logging.getLogger(__name__)
 
@@ -163,7 +164,7 @@ class PlayCommands(commands.Cog):
             if not compressed_path:
                 return
 
-            await audio_playback.AudioPlaybackManager.play(
+            await get_voice_manager(self.bot).play(
                 ctx, compressed_path, delete_after_play=True
             )
         except Exception as e:
@@ -210,7 +211,7 @@ class PlayCommands(commands.Cog):
 
             upload_task = asyncio.create_task(self._upload_to_copyparty_async(local_path))
 
-            await audio_playback.AudioPlaybackManager.play(
+            await get_voice_manager(self.bot).play(
                 ctx, local_path, delete_after_play=True
             )
 
@@ -266,7 +267,7 @@ class PlayCommands(commands.Cog):
         if compressed:
             await self._handle_compressed_file_play(ctx, url)
         else:
-            await audio_playback.AudioPlaybackManager.play(ctx, url)
+            await get_voice_manager(self.bot).play(ctx, url)
 
     @discord.slash_command(name="grajcuj", description="grajcujmy wszyscy!")
     async def play(
@@ -301,7 +302,7 @@ class PlayCommands(commands.Cog):
         if file:
             file_path: PathLike[str] | str = os.path.join(self.temp_dir, file.filename)
             await file.save(file_path)
-            await audio_playback.AudioPlaybackManager.play(ctx, file_path)
+            await get_voice_manager(self.bot).play(ctx, file_path)
         else:
             try:
                 if EXTERNAL_URL_PATTERN.match(melodia.lower()):
diff --git a/cogs/music/stop.py b/cogs/music/stop.py
index f06e7f5..9c8d5cf 100644
--- a/cogs/music/stop.py
+++ b/cogs/music/stop.py
@@ -5,6 +5,8 @@
 
 from discord.ext import commands
 
+from cogs.voice import get_voice_manager
+
 import logging
 
 logger = logging.getLogger(__name__)
@@ -18,7 +20,8 @@ class Stop(commands.Cog):
     async def stop(self, ctx):
         await ctx.respond(content="\u200b", ephemeral=True)
         await ctx.interaction.delete_original_response()
-        await ctx.voice_client.disconnect()
+        voice_mgr = get_voice_manager(self.bot)
+        await voice_mgr.disconnect(ctx.guild)
         logger.info("Bot disconnected from voice channel")
 
 
diff --git a/cogs/tts.py b/cogs/tts.py
index 68eb27f..ca81d3a 100644
--- a/cogs/tts.py
+++ b/cogs/tts.py
@@ -42,28 +42,26 @@ class TTS(commands.Cog):
         await ctx.respond(content="\u200b", ephemeral=True)
         await ctx.interaction.delete_original_response()
 
-        # Check if the user is in a voice channel
         if not (ctx.author.voice and ctx.author.voice.channel):
             logger.info("User is not in a voice channel")
             return
 
         channel = ctx.author.voice.channel
         try:
-            voice_client = await self._get_or_connect_voice_client(channel)
+            voice_mgr = self._get_voice_manager()
 
-            if not voice_client:
-                await ctx.respond("Failed to connect to voice channel", ephemeral=True)
-                return
-
-            if voice_client.is_playing():
-                await ctx.respond("Audio is already playing, try again later", ephemeral=True)
-                return
+            if voice_mgr.get_voice_client and await voice_mgr.get_client(channel.guild):
+                vc = await voice_mgr.get_client(channel.guild)
+                if vc and vc.is_playing():
+                    logger.info("Audio already playing, skipping TTS")
+                    return
 
             audio_source = discord.FFmpegPCMAudio(
                 temp_path,
                 options=f'-filter:a "volume={volume}"'
             )
             logger.info(f"Playing TTS: {text}")
+            await voice_mgr.play_source(channel, audio_source)
 
         except Exception as e:
             logger.error(f"Error in voice channel handling: {e}")
diff --git a/cogs/vclogs.py b/cogs/vclogs.py
index e5ca202..35826d4 100644
--- a/cogs/vclogs.py
+++ b/cogs/vclogs.py
@@ -116,7 +116,7 @@ class VcLogs(commands.Cog):
 
         voice_mgr = self.get_voice_manager()
         temp_dir = get_temp_dir()
-        tts_file = os.path.join(temp_dir, f"temp_tts_{os.getpid()}.mp3")
+        tts_file = os.path.join(temp_dir, f"temp_tts_{os.getpid()}_{asyncio.get_event_loop().time()}.mp3")
         tts = gTTS(text=text, lang='pl')
         logger.info("saving file")
 
@@ -129,6 +129,16 @@ class VcLogs(commands.Cog):
             is_connected = voice_status[1] if voice_status else False
             is_playing = voice_status[2] if voice_status else False
 
+            if is_connected:
+                from cogs.voice import is_voice_client_alive
+                if not is_voice_client_alive(voice_client, channel.guild):
+                    logger.warning("Stale voice client in play_tts, reconnecting")
+                    try:
+                        await voice_client.disconnect()
+                    except Exception:
+                        pass
+                    is_connected = False
+
             if not is_connected:
                 voice_client = await voice_mgr.join_channel(channel)
                 voice_status = await voice_mgr.get_voice_status(channel.guild)
@@ -150,12 +160,7 @@ class VcLogs(commands.Cog):
 
                 logger.info("preparing to play audio")
                 audio_source = discord.FFmpegPCMAudio(tts_file)
-                if volume != 1.0:
-                    audio_source = discord.PCMVolumeTransformer(audio_source)
-                    audio_source.volume = volume
-                voice_client.play(audio_source)
-                while voice_client.is_playing():
-                    await asyncio.sleep(0.1)
+                await voice_mgr.play_source(channel, audio_source, volume=volume)
         except Exception as e:
             logger.error(f"TTS playback error: {e}")
         finally:
diff --git a/cogs/voice.py b/cogs/voice.py
index 046c2a8..a224336 100644
--- a/cogs/voice.py
+++ b/cogs/voice.py
@@ -4,12 +4,15 @@
 # https://codeberg.org/salmonik/senator-sperma
 
 import discord
-from discord.ext import commands
 import logging
 import asyncio
+import os
+import urllib.parse
 from dataclasses import dataclass, field
 from typing import Any
 
+import mutagen
+
 logger = logging.getLogger(__name__)
 
 
@@ -24,60 +27,171 @@ def get_voice_manager(bot) -> "VoiceManager":
     return _voice_managers[bot_id]
 
 
+def is_voice_client_alive(voice_client, guild):
+    """Check if a voice client connection is healthy."""
+    if voice_client is None:
+        return False
+    if not voice_client.is_connected():
+        return False
+    if voice_client.channel is None:
+        return False
+    if guild.get_channel(voice_client.channel.id) is None:
+        return False
+
+    try:
+        ws = voice_client._connection
+        s = ws.socket
+        if s is None or s.fileno() == -1:
+            return False
+    except Exception:
+        return False
+
+    return True
+
+
 @dataclass
 class VoiceManager:
-    bot: Any  # type: ignore[no-any-import]
-    _voice_lock: asyncio.Lock = field(default_factory=asyncio.Lock, init=False)
+    bot: Any
+    _lock: asyncio.Lock = field(default_factory=asyncio.Lock, init=False)
+    _connecting: set[int] = field(default_factory=set, init=False)
 
-    async def join_channel(self, channel):
-        """Join a voice channel by channel object."""
-        async with self._voice_lock:
-            guild = channel.guild
-            voice_client = discord.utils.get(self.bot.voice_clients, guild=guild)
-
-            if voice_client and voice_client.is_connected():
-                if voice_client.channel == channel:
-                    logger.info(f"Already connected to {channel}")
-                    return voice_client
-                try:
-                    await voice_client.move_to(channel)
-                    logger.info(f"Moved to voice channel: {channel}")
-                    return voice_client
-                except Exception as e:
-                    logger.error(f"Failed to move voice client: {e}")
-                    logger.info("Disconnecting after failed move attempt")
+    # --- Connection -----------------------------------------------------------
+
+    async def _ensure_voice_client(self, channel):
+        """Unified connect/move/reconnect logic.
+
+        Returns a healthy VoiceClient connected to *channel*, or None on failure.
+        """
+        guild = channel.guild
+        guild_id = guild.id
+
+        async with self._lock:
+            if guild_id in self._connecting:
+                logger.info(f"Connection already in progress for guild {guild_id}, skipping")
+                return None
+
+            vc = discord.utils.get(self.bot.voice_clients, guild=guild)
+
+            # --- resolve existing client --------------------------------------
+            if vc is not None:
+                if vc.is_connected():
+                    if vc.channel == channel:
+                        if is_voice_client_alive(vc, guild):
+                            logger.info(f"Already connected to {channel}")
+                            return vc
+                        logger.warning(f"Stale connection to {channel}, reconnecting")
+                        # Disconnect resets the state machine to 'disconnected'
+                        # but keeps the VoiceClient alive.  Reusing it avoids a
+                        # race where Discord sends VOICE_SERVER_UPDATE between
+                        # the destroy and the fresh-connect below, causing the
+                        # new client to timeout waiting for the event (since the
+                        # old one already consumed it).
+                        try:
+                            await vc.disconnect()
+                        except Exception:
+                            pass
+                        try:
+                            await vc.connect(
+                                reconnect=False, timeout=10.0, self_deaf=False, self_mute=False
+                            )
+                            logger.info(f"Reconnected to voice channel: {channel}")
+                            return vc
+                        except Exception as e:
+                            logger.error(f"Failed to reconnect stale voice client: {e}")
+                            try:
+                                channel._state._remove_voice_client(guild.id)
+                            except Exception:
+                                pass
+                            vc = None
+                    else:
+                        try:
+                            await vc.move_to(channel)
+                            logger.info(f"Moved to voice channel: {channel}")
+                            return vc
+                        except Exception as e:
+                            logger.error(f"Failed to move voice client: {e}")
+                            try:
+                                await vc.disconnect()
+                            except Exception:
+                                pass
+                            try:
+                                await vc.connect(
+                                    reconnect=False, timeout=10.0, self_deaf=False, self_mute=False
+                                )
+                                logger.info(f"Reconnected after failed move: {channel}")
+                                return vc
+                            except Exception:
+                                pass
+                            try:
+                                channel._state._remove_voice_client(guild.id)
+                            except Exception:
+                                pass
+                            vc = None
+                else:
+                    logger.info("Voice client exists but disconnected, reconnecting")
                     try:
-                        await voice_client.disconnect()
+                        await vc.disconnect()
                     except Exception:
                         pass
-
-            await asyncio.sleep(0.3)
-            try:
-                voice_client = await channel.connect(timeout=30.0, reconnect=False)
-                logger.info(f"Connected to voice channel: {channel}")
-                return voice_client
-            except discord.ClientException as e:
-                if "Already connected" in str(e):
-                    logger.warning(f"Stale voice state detected, forcing disconnect and reconnect: {e}")
-                    voice_client = discord.utils.get(self.bot.voice_clients, guild=guild)
-                    if voice_client:
+                    try:
+                        await vc.connect(
+                            reconnect=False, timeout=10.0, self_deaf=False, self_mute=False
+                        )
+                        logger.info(f"Reconnected disconnected client: {channel}")
+                        return vc
+                    except Exception as e:
+                        logger.error(f"Failed to reconnect disconnected client: {e}")
                         try:
-                            await voice_client.disconnect()
+                            channel._state._remove_voice_client(guild.id)
                         except Exception:
                             pass
-                    await asyncio.sleep(0.3)
-                    try:
-                        voice_client = await channel.connect(timeout=30.0, reconnect=False)
-                        logger.info(f"Reconnected to voice channel: {channel}")
-                        return voice_client
-                    except Exception as e2:
-                        logger.error(f"Failed to reconnect after stale cleanup: {e2}")
-                        return None
-                logger.error(f"Failed to connect to voice channel: {e}")
-                return None
-            except Exception as e:
-                logger.error(f"Failed to connect to voice channel: {e}")
-                return None
+                        vc = None
+
+            # --- create fresh connection --------------------------------------
+            self._connecting.add(guild_id)
+            try:
+                await asyncio.sleep(0.3)
+                try:
+                    vc = await channel.connect(timeout=10.0, reconnect=False)
+                    logger.info(f"Connected to voice channel: {channel}")
+                    return vc
+                except discord.ClientException as e:
+                    if "Already connected" in str(e):
+                        logger.warning(f"Stale voice state detected, forcing reconnect: {e}")
+                        vc = discord.utils.get(self.bot.voice_clients, guild=guild)
+                        if vc:
+                            try:
+                                await vc.disconnect()
+                            except Exception:
+                                pass
+                        else:
+                            try:
+                                channel._state._remove_voice_client(guild.id)
+                            except Exception:
+                                pass
+                        await asyncio.sleep(0.3)
+                        try:
+                            vc = await channel.connect(timeout=10.0, reconnect=False)
+                            logger.info(f"Reconnected to voice channel: {channel}")
+                            return vc
+                        except Exception as e2:
+                            logger.error(f"Failed to reconnect after stale cleanup: {e2}")
+                            return None
+                    logger.error(f"Failed to connect to voice channel: {e}")
+                    return None
+                except Exception as e:
+                    logger.error(f"Failed to connect to voice channel: {e}")
+                    return None
+            finally:
+                self._connecting.discard(guild_id)
+
+    async def connect(self, channel):
+        """Join a voice channel (public alias)."""
+        return await self._ensure_voice_client(channel)
+
+    async def join_channel(self, channel):
+        """Backward-compatible alias for connect()."""
+        return await self.connect(channel)
 
     async def join_by_channel_id(self, channel_id):
         """Join a voice channel by channel ID."""
@@ -88,135 +202,243 @@ class VoiceManager:
         if not isinstance(channel, discord.VoiceChannel):
             logger.error(f"Channel {channel_id} is not a voice channel")
             return None
-        return await self.join_channel(channel)
+        return await self.connect(channel)
 
-    async def get_voice_client(self, guild):
+    async def get_client(self, guild):
         """Get existing voice client for a guild."""
         return discord.utils.get(self.bot.voice_clients, guild=guild)
 
-    async def get_voice_status(self, guild):
-        """Get voice client status including connection and playback state.
+    async def get_voice_client(self, guild):
+        """Backward-compatible alias for get_client()."""
+        return await self.get_client(guild)
+
+    async def get_status(self, guild):
+        """Get voice client status.
 
         Returns:
-            tuple: (voice_client, is_connected, is_playing) or (None, False, False) if no client
+            tuple: (voice_client, is_connected, is_playing) or (None, False, False)
         """
-        voice_client = await self.get_voice_client(guild)
-        if voice_client is None:
+        vc = await self.get_client(guild)
+        if vc is None:
             return None, False, False
+        return vc, vc.is_connected(), vc.is_playing()
 
-        is_connected = voice_client.is_connected()
-        is_playing = voice_client.is_playing() if is_connected else False
+    async def get_voice_status(self, guild):
+        """Backward-compatible alias for get_status()."""
+        return await self.get_status(guild)
+
+    async def disconnect(self, guild):
+        """Stop playback and disconnect from voice."""
+        vc = await self.get_client(guild)
+        if vc:
+            vc.stop()
+            logger.info("Disconnecting from voice")
+            await vc.disconnect()
+            logger.info(f"Disconnected from guild {guild}")
 
-        return voice_client, is_connected, is_playing
+    async def stop(self, guild):
+        """Backward-compatible alias for disconnect()."""
+        await self.disconnect(guild)
 
-    async def play_audio(self, channel, audio_source, volume=1.0):
-        """Play audio in a voice channel."""
-        voice_client = await self.join_channel(channel)
-        if not voice_client:
-            return False
+    # --- Playback ------------------------------------------------------------
 
-        if abs(volume - 1.0) > 1e-9:
-            audio_source = discord.PCMVolumeTransformer(audio_source)
-            audio_source.volume = volume
+    async def _play_await(self, vc, audio_source):
+        """Play an audio source and wait for completion using an asyncio.Future.
+
+        Returns True on success, False on error.  No polling, no magic sleeps.
+        """
+        loop = asyncio.get_event_loop()
+        future = loop.create_future()
+
+        def after(error):
+            if not future.done():
+                if error:
+                    future.set_exception(Exception(str(error)))
+                else:
+                    future.set_result(True)
+
+        vc.play(audio_source, after=after)
 
         try:
-            voice_client.play(audio_source)
-            while voice_client.is_playing():
-                await asyncio.sleep(0.1)
+            await future
             return True
         except Exception as e:
-            logger.error(f"Error playing audio: {e}")
+            logger.error(f"Playback error: {e}")
             return False
 
-    async def stop(self, guild):
-        """Stop playing and disconnect from voice."""
-        voice_client = await self.get_voice_client(guild)
-        if voice_client:
-            voice_client.stop()
-            logger.info("stop() called - disconnecting from voice")
-            await voice_client.disconnect()
-            logger.info(f"Stopped and disconnected from guild {guild}")
+    async def play_source(self, channel, audio_source, interrupt=True, volume=1.0):
+        """Connect to *channel* and play a pre-made audio source.
 
+        Returns True on success, False on failure.
+        """
+        vc = await self.connect(channel)
+        if not vc:
+            logger.error("play_source: could not connect to voice channel")
+            return False
 
-class Voice(commands.Cog):
-    def __init__(self, bot):
-        self.bot = bot
-        self._voice_lock = asyncio.Lock()
+        if interrupt and (vc.is_playing() or vc.is_paused()):
+            vc.stop()
 
-    async def _validate_user_voice_state(self, ctx):
-        if not ctx.author.voice or not ctx.author.voice.channel:
-            await ctx.send("You need to be in a voice channel first!")
-            return False
-        return True
+        if abs(volume - 1.0) > 1e-9:
+            audio_source = discord.PCMVolumeTransformer(audio_source)
+            audio_source.volume = volume
 
-    async def _create_voice_client(self, ctx):
-        async with self._voice_lock:
-            try:
-                await asyncio.sleep(0.5)
-                voice_client = await ctx.author.voice.channel.connect(timeout=30.0, reconnect=False)
-                logger.info(f"Connected to voice channel: {ctx.author.voice.channel}")
-                return voice_client
-            except asyncio.TimeoutError:
-                await ctx.send("Connection to voice channel timed out.")
-                return None
-            except discord.ClientException as e:
-                logger.error(f"Failed to connect to voice channel: {e}")
-                await ctx.send("Failed to connect to voice channel. Please try again.", ephemeral=True)
-                return None
+        logger.info("Playing via play_source")
+        return await self._play_await(vc, audio_source)
 
-    async def _move_voice_client(self, voice_client, ctx):
-        try:
-            await voice_client.move_to(ctx.author.voice.channel)
-            logger.info(f"Moved to voice channel: {ctx.author.voice.channel}")
-            return voice_client
-        except asyncio.TimeoutError:
-            await ctx.send("Connection to voice channel timed out.")
-            return None
-        except discord.ClientException as e:
-            logger.error(f"Failed to move to voice channel: {e}")
-            await ctx.send("Failed to move to your voice channel. Please try again.", ephemeral=True)
+    # --- Source preparation (folded from AudioPlaybackManager) ---------------
+
+    @staticmethod
+    async def validate_voice_channel(ctx):
+        """Validate user is in a voice channel. Returns the channel or None."""
+        if not ctx.author.voice or not ctx.author.voice.channel:
+            await ctx.respond(
+                "Musisz być na kanale głosowym, żebym mógł dołączyć!", ephemeral=True
+            )
             return None
+        return ctx.author.voice.channel
 
-    async def _verify_connection(self, voice_client):
-        if not voice_client.is_connected():
+    @staticmethod
+    async def prepare_file_source(source):
+        """Validate a local file and return (display_name, absolute_path) or (None, None)."""
+        logger.info(f"Attempting to play local file: {source}")
+
+        if not os.path.isabs(source):
+            source = os.path.abspath(source)
+            logger.debug(f"Converted to absolute path: {source}")
+
+        if not os.path.exists(source):
+            logger.error(f"File not found: {source}")
+            return None, None
+
+        filename = os.path.basename(source)
+        display_name = os.path.splitext(filename)[0]
+        return display_name, source
+
+    @staticmethod
+    async def prepare_audio_source(source, is_url, display_name):
+        """Prepare FFmpegPCMAudio from a URL or local file.
+
+        Returns (audio_source, final_display_name).
+        """
+        if is_url:
+            before_options = "-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5"
+            audio_source = discord.FFmpegPCMAudio(source, before_options=before_options)
+            filename = os.path.basename(source.split("?")[0])
+            filename = urllib.parse.unquote(filename)
+            clean_filename = os.path.splitext(filename)[0]
+            return audio_source, clean_filename
+        else:
+            audio_source = discord.FFmpegPCMAudio(source=source)
             try:
-                await voice_client.connect(reconnect=False, timeout=10.0)
-                return voice_client
+                metadata = mutagen.open(source)
+                if metadata:
+                    title = (
+                        metadata.get("title", [None])[0]
+                        if hasattr(metadata, "get")
+                        else None
+                    )
+                    if title:
+                        display_name = title
+                        logger.debug(f"Read metadata - title: {title}")
+                else:
+                    display_name = os.path.splitext(os.path.basename(source))[0]
             except Exception as e:
-                logger.error(f"Failed to reconnect to voice: {e}")
-                return None
-        return voice_client
+                logger.warning(f"Could not read metadata from {source}: {str(e)}")
+                display_name = os.path.splitext(os.path.basename(source))[0]
 
-    async def ensure_voice_client(self, ctx):
-        if not await self._validate_user_voice_state(ctx):
-            return None
+            return audio_source, display_name
+
+    @staticmethod
+    async def prepare_source(source):
+        """Determine whether *source* is a URL or local file.
+
+        Returns (source_path, display_name, is_url) or (None, None, None) on failure.
+        """
+        is_url = source.startswith(("http://", "https://"))
+
+        if is_url:
+            logger.info(f"Attempting to play stream from URL: {source}")
+            return source, source, is_url
 
-        voice_client = discord.utils.get(self.bot.voice_clients, guild=ctx.guild)
+        display_name, absolute_source = await VoiceManager.prepare_file_source(source)
+        if not display_name:
+            return None, None, None
 
-        if voice_client and not voice_client.is_connected():
+        return absolute_source, display_name, is_url
+
+    @staticmethod
+    async def cleanup_temp_file(source):
+        """Remove a temporary file if it exists."""
+        if source and os.path.exists(source):
             try:
-                logger.info("Voice client exists but not connected - disconnecting stale client")
-                await voice_client.disconnect()
-            except Exception:
-                pass
-            voice_client = None
+                os.remove(source)
+                logger.info(f"Cleaned up temporary file: {source}")
+            except Exception as e:
+                logger.error(f"Error cleaning up file {source}: {str(e)}")
 
-        if not voice_client or not voice_client.is_connected():
-            if not await self._validate_user_voice_state(ctx):
-                return None
-            return await self._create_voice_client(ctx)
+    @staticmethod
+    async def cleanup_if_needed(source, delete_after_play, is_url):
+        """Conditionally clean up a file after playback."""
+        if delete_after_play and not is_url:
+            await VoiceManager.cleanup_temp_file(source)
 
-        if voice_client.channel != ctx.author.voice.channel:
-            return await self._move_voice_client(voice_client, ctx)
+    # --- High-level play (full flow) -----------------------------------------
 
-        return await self._verify_connection(voice_client)
+    async def play(self, ctx, source, delete_after_play=False, interrupt=True):
+        """High-level playback: validate context, prepare source, connect, play, cleanup.
 
-    async def connect(self, ctx):
-        voice_client = await self.ensure_voice_client(ctx)
-        if not voice_client:
-            return None
-        return voice_client
+        Sends ``grom: {name}`` immediately on start, and an error follow-up
+        if playback fails.
+
+        Args:
+            ctx: Discord application context (used for channel resolution & error messages).
+            source: Local file path or URL to stream.
+            delete_after_play: Remove local file after playback (no-op for URLs).
+            interrupt: Stop currently playing audio before starting.
+
+        Returns:
+            bool: True if playback completed successfully, False otherwise.
+        """
+        prepared_source, display_name, is_url = await VoiceManager.prepare_source(source)
+        if not prepared_source:
+            await VoiceManager.cleanup_if_needed(source, delete_after_play, False)
+            return False
+
+        target_channel = await VoiceManager.validate_voice_channel(ctx)
+        if not target_channel:
+            await VoiceManager.cleanup_if_needed(prepared_source, delete_after_play, is_url)
+            return False
+
+        vc = await self.connect(target_channel)
+        if not vc:
+            await VoiceManager.cleanup_if_needed(prepared_source, delete_after_play, is_url)
+            return False
+
+        if interrupt and (vc.is_playing() or vc.is_paused()):
+            vc.stop()
+
+        audio_source, final_display_name = await VoiceManager.prepare_audio_source(
+            prepared_source, is_url, display_name
+        )
+
+        try:
+            await ctx.followup.send(f"grom: {final_display_name}")
+        except Exception as e:
+            logger.error(e)
+
+        success = await self._play_await(vc, audio_source)
 
+        if success:
+            logger.info(f"Playback completed: {final_display_name}")
+        else:
+            logger.error(f"Playback failed: {prepared_source}")
+            try:
+                await ctx.followup.send(
+                    "eror: Timeout - nie udało się połączyć ze streamem", ephemeral=True
+                )
+            except Exception:
+                pass
+            await VoiceManager.cleanup_if_needed(prepared_source, delete_after_play, is_url)
 
-def setup(bot):
-    bot.add_cog(Voice(bot))
+        return success