fix: loop and llm response

Author: andyjjrt

rosetta/commands/basics.py

@@ -38,20 +38,13 @@ async def version(self, interaction: discord.Interaction):
         )
         await interaction.response.send_message(embed=embed)
 
-    @commands.is_owner()
-    @commands.command(name="version", description="Show version information")
-    async def admin(self, ctx: commands.Context):
-        embed = await self.generate_version_embed(ctx, is_admin=True)
-
-        await ctx.reply(embed=embed)
-
     @commands.is_owner()
     @commands.command(name="guilds", description="Show all guilds the bot is in")
     async def guilds(self, ctx: commands.Context):
         """Display all guilds the bot is currently in"""
         from ..utils.views import GuildsView
 
-        view = GuildsView(self.bot)
+        view = GuildsView(self.bot, ctx.author)
         await ctx.reply(view=view)
 
     async def generate_version_embed(

rosetta/commands/llm.py

@@ -92,7 +92,7 @@ async def chat(
                         {"role": "user", "content": prompt},
                     ],
                     stream=True,
-                    stream_options={"include_usage": True},
+                    stream_options={"include_usage": True}
                 )
 
                 async for chunk in stream:

rosetta/commands/music.py

@@ -248,6 +248,8 @@ async def _play(
         return embed
 
     @app_commands.command(name="play", description="Play Youtube music")
+    @app_commands.allowed_installs(guilds=True, users=False)
+    @app_commands.allowed_contexts(guilds=True, dms=False, private_channels=False)
     @app_commands.describe(
         url="url",
         loop="loop",
@@ -280,6 +282,8 @@ async def play(
         await message.edit(embed=embed)
 
     @app_commands.command(name="loop", description="Set loop")
+    @app_commands.allowed_installs(guilds=True, users=False)
+    @app_commands.allowed_contexts(guilds=True, dms=False, private_channels=False)
     @app_commands.describe(loop="loop mode")
     @app_commands.choices(
         loop=[
@@ -305,6 +309,8 @@ async def loop_command(self, interaction: discord.Interaction, loop: str = "Off"
         )
 
     @app_commands.command(name="search", description="Search in Youtube")
+    @app_commands.allowed_installs(guilds=True, users=False)
+    @app_commands.allowed_contexts(guilds=True, dms=False, private_channels=False)
     @app_commands.describe(keyword="keyword")
     async def search(self, interaction: discord.Interaction, keyword: str):
         adapter = interaction.extras.get("logger")
@@ -340,35 +346,46 @@ async def do_skip(self, interaction: discord.Interaction, ephemeral: bool = Fals
             await interaction.followup.send(embed=embed, ephemeral=ephemeral)
         else:
             adapter.info("Skip requested but queue is empty")
+            await player.destroy()
             await interaction.followup.send(
-                embed=SuccessEmbed(self.bot.user, "No song left")
+                embed=SuccessEmbed(self.bot.user, "No song left, leaving")
             )
 
     @app_commands.command(name="shuffle", description="Shuffle")
+    @app_commands.allowed_installs(guilds=True, users=False)
+    @app_commands.allowed_contexts(guilds=True, dms=False, private_channels=False)
     @app_commands.describe(ephemeral="hide response")
     async def shuffle(self, interaction: discord.Interaction, ephemeral: bool = False):
         await self.do_shuffle(interaction, ephemeral)
 
     @app_commands.command(name="skip", description="Skip to next song")
+    @app_commands.allowed_installs(guilds=True, users=False)
+    @app_commands.allowed_contexts(guilds=True, dms=False, private_channels=False)
     @app_commands.describe(ephemeral="hide response")
     async def skip(self, interaction: discord.Interaction, ephemeral: bool = False):
         await self.do_skip(interaction, ephemeral)
 
     @app_commands.command(name="leave", description="Leave current channel")
+    @app_commands.allowed_installs(guilds=True, users=False)
+    @app_commands.allowed_contexts(guilds=True, dms=False, private_channels=False)
     async def leave(self, interaction: discord.Interaction):
         player = await self.ensure_player(interaction)
         await player.destroy()
         await interaction.response.send_message(embed=LeaveEmbed(self.bot.user))
 
     @app_commands.command(name="nowplaying", description="Show the song playing now")
+    @app_commands.allowed_installs(guilds=True, users=False)
+    @app_commands.allowed_contexts(guilds=True, dms=False, private_channels=False)
     async def nowplaying(self, interaction: discord.Interaction):
         await interaction.response.defer()
         player = await self.ensure_player(interaction)
 
-        view = NowPlayingView(player)
+        view = NowPlayingView(player, interaction.user)
         await interaction.followup.send(view=view)
 
     @app_commands.command(name="switchnode", description="Switch to a different Lavalink node")
+    @app_commands.allowed_installs(guilds=True, users=False)
+    @app_commands.allowed_contexts(guilds=True, dms=False, private_channels=False)
     @app_commands.describe(node_name="The node to switch to")
     @app_commands.autocomplete(node_name=node_autocomplete)
     async def switchnode(

rosetta/utils/player.py

@@ -16,6 +16,7 @@ class LoopMode(Enum):
 class Queue(Generic[T]):
     def __init__(self):
         self._queue: list[T] = []
+        self._now_playing: T | None = None
         self.loop = LoopMode.NONE
 
     def __len__(self) -> int:
@@ -31,6 +32,11 @@ def __getitem__(self, index: int) -> T:
     def is_empty(self) -> bool:
         return len(self._queue) == 0
 
+    @property
+    def now_playing(self) -> T | None:
+        """Return the currently playing item."""
+        return self._now_playing
+
     def add(self, items: list[T]):
         """Add items to the end of the queue."""
         self._queue.extend(items)
@@ -41,24 +47,43 @@ def add_front(self, items: list[T]):
 
     def get(self) -> T | None:
         """Remove and return the first item from the queue."""
+        # Loop one: return the currently playing track
+        if self.loop == LoopMode.ONE and self._now_playing is not None:
+            return self._now_playing
+        
+        # Empty queue handling
         if self.is_empty:
+            # Loop queue with nothing left: return now_playing
+            if self.loop == LoopMode.QUEUE and self._now_playing is not None:
+                return self._now_playing
             return None
-        if self.loop == LoopMode.ONE:
-            return self._queue[0]
+        
+        # Get next item
         item = self._queue.pop(0)
         if self.loop == LoopMode.QUEUE:
-            self._queue.append(item)
+            self._queue.append(self._now_playing)
+        
+        self._now_playing = item
         return item
 
-    def skip_to(self, index: int) -> T:
+    def skip_to(self, index: int) -> T | None:
+        """Skip to a specific index in the queue."""
         if self.is_empty:
             return None
-        item = self._queue.pop(0)
+        
+        # Add current now_playing to end if loop queue
+        if self.loop == LoopMode.QUEUE and self._now_playing is not None:
+            self._queue.append(self._now_playing)
+        
+        # Skip through items up to index
         for _ in range(index):
             item = self._queue.pop(0)
             if self.loop == LoopMode.QUEUE:
                 self._queue.append(item)
-        assert item is not None
+        
+        # Get the target item
+        item = self._queue.pop(0)
+        self._now_playing = item
         return item
 
     def peek(self) -> T | None:
@@ -80,6 +105,7 @@ def remove(self, index: int) -> T | None:
     def clear(self):
         """Clear all items from the queue."""
         self._queue.clear()
+        self._now_playing = None
 
     def shuffle(self):
         """Shuffle the queue randomly."""

rosetta/utils/views/Guilds.py

@@ -6,14 +6,23 @@
 
 
 class GuildsView(discord.ui.LayoutView):
-    def __init__(self, bot: commands.Bot, accent_color: int = 0x229AE0):
+    def __init__(self, bot: commands.Bot, user: discord.User | discord.Member, accent_color: int = 0x229AE0):
         super().__init__(timeout=300)
         self.bot = bot
+        self.user = user
         self.accent_color = accent_color
         self.page_size = 5
         self.container = self.construct_container()
         self.add_item(self.container)
 
+    async def interaction_check(self, interaction: discord.Interaction) -> bool:
+        if interaction.user.id != self.user.id:
+            await interaction.response.send_message(
+                "You cannot interact with this view.", ephemeral=True
+            )
+            return False
+        return True
+
     def refresh_item(self, old_item: discord.ui.Item, new_item: discord.ui.Item):
         new_item._update_view(self)
         self._swap_item(old_item, new_item, "")

rosetta/utils/views/LLM.py

@@ -5,19 +5,21 @@
 
 UPDATE_INTERVAL_SECONDS = 1
 DISCORD_CHAR_LIMIT = 4000
-SAFE_SPLIT_LIMIT = 3980
+SAFE_SPLIT_LIMIT = 3900
 
 
 class LLMView(discord.ui.LayoutView):
     def __init__(self, model: str):
-        super().__init__()
+        super().__init__(timeout=300)
         self.last_update_time = time.time()
         self.start_time, self.first_token_time, self.end_time = time.time(), None, None
 
         self.response_messages = []
         self.current_message_content = ""
         self.full_response = ""
         self.model = model
+        self.current_page = 1
+        self.message: discord.WebhookMessage | None = None
 
         self.usage = None
         self.ttft, self.tps, self.completion_tokens = 0.0, 0.0, 0
@@ -57,23 +59,84 @@ def find_best_split_position(self, text: str, max_len: int) -> int:
         # 4. If all else fails, force a hard cut at the safe limit
         return max_len
 
-    async def update_view(self, message: discord.WebhookMessage):
-        self.clear_items()
-        container = discord.ui.Container()
+    def refresh_item(self, old_item: discord.ui.Item, new_item: discord.ui.Item):
+        new_item._update_view(self)
+        self._swap_item(old_item, new_item, "")
+        del old_item
+
+    def pagination_callback(self, current_page: int = 1):
+        async def _callback(interaction: discord.Interaction):
+            total_pages = len(self.response_messages)
+            new_page = current_page
+
+            if interaction.data["custom_id"] == "next":
+                new_page = min(current_page + 1, total_pages)
+            elif interaction.data["custom_id"] == "previous":
+                new_page = max(current_page - 1, 1)
+
+            self.current_page = new_page
+            new_container = self.construct_container(new_page)
+            self.refresh_item(self.container, new_container)
+            self.container = new_container
+
+            await interaction.response.edit_message(view=self)
 
-        for response in self.response_messages:
-            container.add_item(discord.ui.TextDisplay(response))
+        return _callback
 
-        if not self.end_time:
+    def construct_container(self, page: int = -1):
+        container = discord.ui.Container()
+        total_pages = len(self.response_messages)
+
+        # page -1 means show current streaming content only
+        if page == -1:
             current_message = self.current_message_content + " █"
             container.add_item(discord.ui.TextDisplay(current_message))
-        else:
+        elif total_pages > 0 and 1 <= page <= total_pages:
+            # Show only the specified page's content (1 response message per page)
+            page_content = self.response_messages[page - 1]
+            container.add_item(discord.ui.TextDisplay(page_content))
+
+        # Footer with stats (only when finished)
+        if self.end_time:
+            container.add_item(
+                discord.ui.Separator(spacing=discord.enums.SeparatorSpacing.small)
+            )
             container.add_item(
                 discord.ui.TextDisplay(
                     f"-# {self.model} • {self.tps:.2f} tps • TTFT: {self.ttft:.2f}s • Tokens: {self.completion_tokens}"
                 )
             )
-        self.add_item(container)
+
+        # Pagination controls (only when there are multiple pages and streaming is done)
+        if self.end_time and total_pages > 1:
+            container.add_item(
+                discord.ui.Separator(spacing=discord.enums.SeparatorSpacing.small)
+            )
+            footer = discord.ui.TextDisplay(f"-# Page {self.current_page}/{total_pages}")
+            container.add_item(footer)
+
+            actionrow = discord.ui.ActionRow()
+            previous_button = discord.ui.Button(
+                label="Previous", custom_id="previous", disabled=self.current_page <= 1
+            )
+            previous_button.callback = self.pagination_callback(self.current_page)
+            actionrow.add_item(previous_button)
+
+            next_button = discord.ui.Button(
+                label="Next", custom_id="next", disabled=self.current_page >= total_pages
+            )
+            next_button.callback = self.pagination_callback(self.current_page)
+            actionrow.add_item(next_button)
+
+            container.add_item(actionrow)
+
+        return container
+
+    async def update_view(self, message: discord.WebhookMessage, page: int = -1):
+        self.message = message
+        self.clear_items()
+        self.container = self.construct_container(page)
+        self.add_item(self.container)
 
         await message.edit(view=self)
 
@@ -107,6 +170,7 @@ async def update_chunk(
     async def end_chunk(self, message: discord.WebhookMessage):
         self.end_time = time.time()
         self.response_messages.append(self.current_message_content)
+        self.current_page = len(self.response_messages)  # Go to the last page
 
         if self.usage:
             self.completion_tokens = self.usage.completion_tokens
@@ -117,4 +181,4 @@ async def end_chunk(self, message: discord.WebhookMessage):
             if generation_time > 0 and self.completion_tokens > 1:
                 self.tps = (self.completion_tokens - 1) / generation_time
 
-        await self.update_view(message)
+        await self.update_view(message, self.current_page)

rosetta/utils/views/NowPlaying.py

@@ -11,13 +11,22 @@
 
 
 class NowPlayingView(discord.ui.LayoutView):
-    def __init__(self, player: CustomPlayer, accent_color: int = 0x229AE0):
+    def __init__(self, player: CustomPlayer, user: discord.User | discord.Member, accent_color: int = 0x229AE0):
         super().__init__()
+        self.user = user
         self.accent_color = accent_color
         self.page_size = 10
         self.container = self.construct_container(player)
         self.add_item(self.container)
 
+    async def interaction_check(self, interaction: discord.Interaction) -> bool:
+        if interaction.user.id != self.user.id:
+            await interaction.response.send_message(
+                "You cannot interact with this view.", ephemeral=True
+            )
+            return False
+        return True
+
     def refresh_callback(self):
         async def _callback(interaction: discord.Interaction):
             player = await self.ensure_player(interaction)
@@ -53,7 +62,6 @@ async def _callback(interaction: discord.Interaction):
             player = await self.ensure_player(interaction)
 
             result = interaction.data["values"][0]
-            logger.info(result)
             track = player.queue.skip_to(int(result))
             await player.play(track)