magmastream 2.9.0-dev.2 → 2.9.0-dev.3

package/dist/structures/Node.js

@@ -606,6 +606,8 @@ class Node {
             return false;
         const lastTrack = player.queue.previous[player.queue.previous.length - 1];
         lastTrack.requester = player.get("Internal_BotUser");
+        if (!lastTrack)
+            return false;
         const tracks = await Utils_1.AutoPlayUtils.getRecommendedTracks(player, lastTrack, attempt);
         if (tracks.length) {
             player.queue.add(tracks[0]);

package/dist/structures/Utils.js

@@ -144,29 +144,22 @@ class AutoPlayUtils {
         this.manager = manager;
     }
     static async getRecommendedTracks(player, track, attempt = 0) {
-        console.log(`[AutoPlay] Attempt ${attempt} for track: ${track.title}`);
         const node = this.manager.useableNode;
         if (!node) {
-            console.error("[AutoPlay] No available nodes.");
             throw new Error("No available nodes.");
         }
         if (!player.isAutoplay) {
-            console.log("[AutoPlay] Autoplay is disabled. Returning an empty array.");
             return [];
         }
         if (attempt >= player.autoplayTries) {
-            console.warn(`[AutoPlay] Reached max autoplay attempts (${player.autoplayTries}).`);
             return [];
         }
         if (!player.queue.previous.length) {
-            console.log("[AutoPlay] No previous tracks in the queue. Cannot generate recommendations.");
             return [];
         }
         const apiKey = this.manager.options.lastFmApiKey;
         const enabledSources = node.info.sourceManagers;
         const { autoPlaySearchPlatform } = this.manager.options;
-        console.log(`[AutoPlay] Enabled sources: ${enabledSources.join(", ")}`);
-        console.log(`[AutoPlay] Preferred autoplay platform: ${autoPlaySearchPlatform}`);
         const supportedPlatforms = ["spotify", "deezer", "soundcloud", "youtube"];
         const platformMapping = {
             [Manager_1.SearchPlatform.AppleMusic]: "applemusic",
@@ -183,125 +176,95 @@ class AutoPlayUtils {
         const mappedPlatform = platformMapping[autoPlaySearchPlatform];
         // Last attempt fallback to YouTube
         if (attempt === player.autoplayTries - 1 && player.autoplayTries > 1 && enabledSources.includes("youtube")) {
-            console.log("[AutoPlay] Final attempt: Falling back to YouTube recommendations.");
             return await this.getRecommendedTracksFromYouTube(track);
         }
         // Check if the preferred autoplay platform is supported and enabled
         if (mappedPlatform && supportedPlatforms.includes(mappedPlatform) && enabledSources.includes(mappedPlatform)) {
-            console.log(`[AutoPlay] Using recommended platform: ${mappedPlatform}`);
             return await this.getRecommendedTracksFromSource(track, mappedPlatform);
         }
         // Check if Last.fm API is available
         if (apiKey) {
-            console.log("[AutoPlay] No preferred platform found. Using Last.fm recommendations.");
             return await this.getRecommendedTracksFromLastFm(track, apiKey);
         }
         // Fallback to YouTube if all else fails
         if (enabledSources.includes("youtube")) {
-            console.warn("[AutoPlay] No other sources available. Falling back to YouTube.");
             return await this.getRecommendedTracksFromYouTube(track);
         }
-        console.error("[AutoPlay] No suitable platform found. Returning an empty array.");
         return [];
     }
     static async getRecommendedTracksFromLastFm(track, apiKey) {
         const enabledSources = this.manager.useableNode.info.sourceManagers;
         const selectedSource = this.selectPlatform(enabledSources);
-        console.log(`[AutoPlay] Selected source: ${selectedSource}`);
         let { author: artist } = track;
         const { title } = track;
-        console.log(`[AutoPlay] Searching for recommended tracks for: ${artist} - ${title}`);
         if (!artist || !title) {
             if (!title) {
                 // No title provided, search for the artist's top tracks
                 const noTitleUrl = `https://ws.audioscrobbler.com/2.0/?method=artist.getTopTracks&artist=${artist}&autocorrect=1&api_key=${apiKey}&format=json`;
-                console.log(`[AutoPlay] No title provided. Fetching artist's top tracks from: ${noTitleUrl}`);
                 const response = await axios_1.default.get(noTitleUrl);
                 if (response.data.error || !response.data.toptracks?.track?.length) {
-                    console.error("[AutoPlay] Error or no tracks found for the artist. Returning an empty array.");
                     return [];
                 }
-                console.log("[AutoPlay] Successfully fetched artist's top tracks.");
                 const randomTrack = response.data.toptracks.track[Math.floor(Math.random() * response.data.toptracks.track.length)];
-                console.log(`[AutoPlay] Selected random track: ${randomTrack.artist.name} - ${randomTrack.name}`);
                 const res = await this.manager.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: selectedSource }, track.requester);
                 if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
-                    console.error("[AutoPlay] Search returned empty or error result. Returning an empty array.");
                     return [];
                 }
                 const filteredTracks = res.tracks.filter((t) => t.uri !== track.uri);
                 if (!filteredTracks.length) {
-                    console.error("[AutoPlay] No suitable tracks found. Returning an empty array.");
                     return [];
                 }
-                console.log("[AutoPlay] Found suitable tracks.");
                 return filteredTracks;
             }
             if (!artist) {
                 // No artist provided, search for the track title
                 const noArtistUrl = `https://ws.audioscrobbler.com/2.0/?method=track.search&track=${title}&api_key=${apiKey}&format=json`;
-                console.log(`[AutoPlay] No artist provided. Searching for track: ${title} from: ${noArtistUrl}`);
                 const response = await axios_1.default.get(noArtistUrl);
                 artist = response.data.results.trackmatches?.track?.[0]?.artist;
                 if (!artist) {
-                    console.error("[AutoPlay] No artist found for track. Returning an empty array.");
                     return [];
                 }
-                console.log(`[AutoPlay] Found artist for track: ${artist}`);
             }
         }
         // Search for similar tracks to the current track
         const url = `https://ws.audioscrobbler.com/2.0/?method=track.getSimilar&artist=${artist}&track=${title}&limit=10&autocorrect=1&api_key=${apiKey}&format=json`;
-        console.log(`[AutoPlay] Searching for similar tracks using URL: ${url}`);
         let response;
         try {
             response = await axios_1.default.get(url);
-            console.log("[AutoPlay] Successfully fetched similar tracks.");
         }
         catch (error) {
-            console.error("[AutoPlay] Error fetching similar tracks. Returning an empty array.");
             console.log(error);
             return [];
         }
         if (response.data.error || !response.data.similartracks?.track?.length) {
-            console.error("[AutoPlay] Error or no similar tracks found. Retrying with top tracks.");
             // Retry the request if the first attempt fails
             const retryUrl = `https://ws.audioscrobbler.com/2.0/?method=artist.getTopTracks&artist=${artist}&autocorrect=1&api_key=${apiKey}&format=json`;
             const retryResponse = await axios_1.default.get(retryUrl);
             if (retryResponse.data.error || !retryResponse.data.toptracks?.track?.length) {
-                console.error("[AutoPlay] Retry failed. Returning an empty array.");
                 return [];
             }
             const randomTrack = retryResponse.data.toptracks.track[Math.floor(Math.random() * retryResponse.data.toptracks.track.length)];
-            console.log(`[AutoPlay] Selected random track from retry: ${randomTrack.artist.name} - ${randomTrack.name}`);
             const res = await this.manager.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: selectedSource }, track.requester);
             if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
-                console.error("[AutoPlay] Retry search returned empty or error result. Returning an empty array.");
                 return [];
             }
             const filteredTracks = res.tracks.filter((t) => t.uri !== track.uri);
             if (!filteredTracks.length) {
-                console.error("[AutoPlay] No suitable tracks found in retry. Returning an empty array.");
                 return [];
             }
-            console.log("[AutoPlay] Found suitable tracks from retry.");
             return filteredTracks;
         }
         const randomTrack = response.data.similartracks.track.sort(() => Math.random() - 0.5).shift();
         if (!randomTrack) {
-            console.error("[AutoPlay] No similar tracks found after filtering. Returning an empty array.");
             return [];
         }
-        console.log(`[AutoPlay] Selected random track: ${randomTrack.name} - ${randomTrack.artist.name}`);
         const res = await this.manager.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: selectedSource }, track.requester);
         if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
-            console.error("[AutoPlay] Final search returned empty or error result. Returning an empty array.");
             return [];
         }
         if (res.loadType === LoadTypes.Playlist)
             res.tracks = res.playlist.tracks;
         if (!res.tracks.length) {
-            console.error("[AutoPlay] No tracks found in final search. Returning an empty array.");
             return [];
         }
         return res.tracks;
@@ -309,108 +272,104 @@ class AutoPlayUtils {
     static async getRecommendedTracksFromSource(track, mappedPlatform) {
         switch (mappedPlatform) {
             case "spotify":
-                console.log("[AutoPlay] Checking if track URI includes 'spotify':", track.uri);
-                if (!track.uri.includes("spotify")) {
-                    console.log("[AutoPlay] Track URI does not include 'spotify'. Searching for track:", `${track.author} - ${track.title}`);
-                    const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Manager_1.SearchPlatform.Spotify }, track.requester);
+                try {
+                    if (!track.uri.includes("spotify")) {
+                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Manager_1.SearchPlatform.Spotify }, track.requester);
+                        if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
+                            return [];
+                        }
+                        if (res.loadType === LoadTypes.Playlist) {
+                            res.tracks = res.playlist.tracks;
+                        }
+                        if (!res.tracks.length) {
+                            return [];
+                        }
+                        track = res.tracks[0];
+                    }
+                    const TOTP_SECRET = new Uint8Array([
+                        53, 53, 48, 55, 49, 52, 53, 56, 53, 51, 52, 56, 55, 52, 57, 57, 53, 57, 50, 50, 52, 56, 54, 51, 48, 51, 50, 57, 51, 52, 55,
+                    ]);
+                    const hmac = crypto_1.default.createHmac("sha1", TOTP_SECRET);
+                    function generateTotp() {
+                        const counter = Math.floor(Date.now() / 30000);
+                        const counterBuffer = Buffer.alloc(8);
+                        counterBuffer.writeBigInt64BE(BigInt(counter));
+                        hmac.update(counterBuffer);
+                        const hmacResult = hmac.digest();
+                        const offset = hmacResult[hmacResult.length - 1] & 15;
+                        const truncatedValue = ((hmacResult[offset] & 127) << 24) | ((hmacResult[offset + 1] & 255) << 16) | ((hmacResult[offset + 2] & 255) << 8) | (hmacResult[offset + 3] & 255);
+                        const totp = (truncatedValue % 1000000).toString().padStart(6, "0");
+                        return [totp, counter * 30000];
+                    }
+                    const [totp, timestamp] = generateTotp();
+                    const params = {
+                        reason: "transport",
+                        productType: "embed",
+                        totp: totp,
+                        totpVer: 5,
+                        ts: timestamp,
+                    };
+                    let body;
+                    try {
+                        const response = await axios_1.default.get("https://open.spotify.com/get_access_token", { params });
+                        body = response.data;
+                    }
+                    catch (error) {
+                        console.error("[AutoPlay] Failed to get access token:", error.response?.status, error.response?.data || error.message);
+                        return [];
+                    }
+                    let json;
+                    try {
+                        const response = await axios_1.default.get(`https://api.spotify.com/v1/recommendations`, {
+                            params: { limit: 10, seed_tracks: track.identifier },
+                            headers: {
+                                Authorization: `Bearer ${body.accessToken}`,
+                                "Content-Type": "application/json",
+                            },
+                        });
+                        json = response.data;
+                    }
+                    catch (error) {
+                        console.error("[AutoPlay] Failed to fetch recommendations:", error.response?.status, error.response?.data || error.message);
+                        return [];
+                    }
+                    if (!json.tracks || !json.tracks.length) {
+                        return [];
+                    }
+                    const recommendedTrackId = json.tracks[Math.floor(Math.random() * json.tracks.length)].id;
+                    const res = await this.manager.search({ query: `https://open.spotify.com/track/${recommendedTrackId}`, source: Manager_1.SearchPlatform.Spotify }, track.requester);
                     if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
-                        console.error("[AutoPlay] Search returned empty or error result. Returning an empty array.");
                         return [];
                     }
                     if (res.loadType === LoadTypes.Playlist) {
-                        console.log("[AutoPlay] Search returned a playlist. Flattening tracks.");
                         res.tracks = res.playlist.tracks;
                     }
                     if (!res.tracks.length) {
-                        console.error("[AutoPlay] No tracks found in the search. Returning an empty array.");
                         return [];
                     }
-                    console.log("[AutoPlay] Track found in search:", res.tracks[0].uri);
-                    track = res.tracks[0];
-                }
-                const TOTP_SECRET = new Uint8Array([
-                    53, 53, 48, 55, 49, 52, 53, 56, 53, 51, 52, 56, 55, 52, 57, 57, 53, 57, 50, 50, 52, 56, 54, 51, 48, 51, 50, 57, 51, 52, 55,
-                ]);
-                const hmac = crypto_1.default.createHmac("sha1", TOTP_SECRET);
-                function generateTotp() {
-                    const counter = Math.floor(Date.now() / 30000);
-                    const counterBuffer = Buffer.alloc(8);
-                    counterBuffer.writeBigInt64BE(BigInt(counter));
-                    hmac.update(counterBuffer);
-                    const hmacResult = hmac.digest();
-                    const offset = hmacResult[hmacResult.length - 1] & 15;
-                    const truncatedValue = ((hmacResult[offset] & 127) << 24) | ((hmacResult[offset + 1] & 255) << 16) | ((hmacResult[offset + 2] & 255) << 8) | (hmacResult[offset + 3] & 255);
-                    const totp = (truncatedValue % 1000000).toString().padStart(6, "0");
-                    return [totp, counter * 30000];
-                }
-                const [totp, timestamp] = generateTotp();
-                console.log("[AutoPlay] Generated TOTP:", totp);
-                const params = {
-                    reason: "transport",
-                    productType: "embed",
-                    totp: totp,
-                    totpVer: 5,
-                    ts: timestamp,
-                };
-                console.log("[AutoPlay] Sending request to get access token with params:", params);
-                const { data: body } = await axios_1.default.get("https://open.spotify.com/get_access_token", { params });
-                console.log("[AutoPlay] Access token received.");
-                const { data: json } = await axios_1.default.get(`https://api.spotify.com/v1/recommendations`, {
-                    params: { limit: 10, seed_tracks: track.identifier },
-                    headers: {
-                        Authorization: `Bearer ${body.accessToken}`,
-                        "Content-Type": "application/json",
-                    },
-                });
-                if (!json.tracks || !json.tracks.length) {
-                    console.error("[AutoPlay] No recommended tracks received from Spotify API. Returning an empty array.");
-                    return [];
-                }
-                console.log("[AutoPlay] Recommended tracks received from Spotify.");
-                // Return a random recommended track ID
-                const recommendedTrackId = json.tracks[Math.floor(Math.random() * json.tracks.length)].id;
-                console.log(`[AutoPlay] Selected random recommended track ID: ${recommendedTrackId}`);
-                console.log("[AutoPlay] Searching for the recommended track:", recommendedTrackId);
-                const res = await this.manager.search({ query: `https://open.spotify.com/track/${recommendedTrackId}`, source: Manager_1.SearchPlatform.Spotify }, track.requester);
-                if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
-                    console.error("[AutoPlay] Final search returned empty or error result. Returning an empty array.");
-                    return [];
-                }
-                if (res.loadType === LoadTypes.Playlist) {
-                    console.log("[AutoPlay] Final search returned a playlist. Flattening tracks.");
-                    res.tracks = res.playlist.tracks;
+                    return res.tracks;
                 }
-                if (!res.tracks.length) {
-                    console.error("[AutoPlay] No tracks found in final search. Returning an empty array.");
+                catch (error) {
+                    console.error("[AutoPlay] Unexpected error:", error.message || error);
                     return [];
                 }
-                console.log("[AutoPlay] Recommended tracks found and ready to return.");
-                return res.tracks;
             case "deezer":
-                console.log("[AutoPlay] Checking if track URI includes 'deezer':", track.uri);
                 if (!track.uri.includes("deezer")) {
-                    console.log("[AutoPlay] Track URI does not include 'deezer'. Searching for track:", `${track.author} - ${track.title}`);
                     const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Manager_1.SearchPlatform.Deezer }, track.requester);
                     if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
-                        console.error("[AutoPlay] Search returned empty or error result. Returning an empty array.");
                         return [];
                     }
                     if (res.loadType === LoadTypes.Playlist) {
-                        console.log("[AutoPlay] Search returned a playlist. Flattening tracks.");
                         res.tracks = res.playlist.tracks;
                     }
                     if (!res.tracks.length) {
-                        console.error("[AutoPlay] No tracks found in the search. Returning an empty array.");
                         return [];
                     }
-                    console.log("[AutoPlay] Track found in search:", res.tracks[0].uri);
                     track = res.tracks[0];
                 }
                 const identifier = `dzrec:${track.identifier}`;
-                console.log("[AutoPlay] Generating Deezer recommendation identifier:", identifier);
                 const recommendedResult = (await this.manager.useableNode.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`));
                 if (!recommendedResult) {
-                    console.error("[AutoPlay] No recommended result received from Deezer. Returning an empty array.");
                     return [];
                 }
                 let tracks = [];
@@ -418,15 +377,12 @@ class AutoPlayUtils {
                 const requester = track.requester;
                 switch (recommendedResult.loadType) {
                     case LoadTypes.Search:
-                        console.log("[AutoPlay] Recommended result is of type 'Search'. Building tracks.");
                         tracks = recommendedResult.data.map((track) => TrackUtils.build(track, requester));
                         break;
                     case LoadTypes.Track:
-                        console.log("[AutoPlay] Recommended result is of type 'Track'. Building a single track.");
                         tracks = [TrackUtils.build(recommendedResult.data, requester)];
                         break;
                     case LoadTypes.Playlist: {
-                        console.log("[AutoPlay] Recommended result is of type 'Playlist'. Building playlist.");
                         const playlistData = recommendedResult.data;
                         tracks = playlistData.tracks.map((track) => TrackUtils.build(track, requester));
                         playlist = {
@@ -441,42 +397,37 @@ class AutoPlayUtils {
                 }
                 const result = { loadType: recommendedResult.loadType, tracks, playlist };
                 if (result.loadType === LoadTypes.Empty || result.loadType === LoadTypes.Error) {
-                    console.error("[AutoPlay] Final result load type is empty or error. Returning an empty array.");
                     return [];
                 }
                 if (result.loadType === LoadTypes.Playlist) {
-                    console.log("[AutoPlay] Final result load type is Playlist. Flattening tracks.");
                     result.tracks = result.playlist.tracks;
                 }
                 if (!result.tracks.length) {
-                    console.error("[AutoPlay] No tracks found in final result. Returning an empty array.");
                     return [];
                 }
-                console.log("[AutoPlay] Tracks found and ready to return.");
                 return result.tracks;
             case "soundcloud":
-                console.log("[AutoPlay] Checking if track URI includes 'soundcloud':", track.uri);
                 if (!track.uri.includes("soundcloud")) {
-                    console.log("[AutoPlay] Track URI does not include 'soundcloud'. Searching for track:", `${track.author} - ${track.title}`);
                     const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Manager_1.SearchPlatform.SoundCloud }, track.requester);
                     if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
-                        console.error("[AutoPlay] Search returned empty or error result. Returning an empty array.");
                         return [];
                     }
                     if (res.loadType === LoadTypes.Playlist) {
-                        console.log("[AutoPlay] Search returned a playlist. Flattening tracks.");
                         res.tracks = res.playlist.tracks;
                     }
                     if (!res.tracks.length) {
-                        console.error("[AutoPlay] No tracks found in the search. Returning an empty array.");
                         return [];
                     }
-                    console.log("[AutoPlay] Track found in search:", res.tracks[0].uri);
                     track = res.tracks[0];
                 }
                 try {
-                    console.log("[AutoPlay] Fetching SoundCloud recommendations from:", `${track.uri}/recommended`);
-                    const recommendedRes = await axios_1.default.get(`${track.uri}/recommended`);
+                    const recommendedRes = await axios_1.default.get(`${track.uri}/recommended`).catch((err) => {
+                        console.error(`[AutoPlay] Failed to fetch SoundCloud recommendations. Status: ${err.response?.status || "Unknown"}`, err.message);
+                        return null;
+                    });
+                    if (!recommendedRes) {
+                        return [];
+                    }
                     const html = recommendedRes.data;
                     const dom = new jsdom_1.JSDOM(html);
                     const document = dom.window.document;
@@ -484,7 +435,6 @@ class AutoPlayUtils {
                     const sectionElement = secondNoscript.querySelector("section");
                     const articleElements = sectionElement.querySelectorAll("article");
                     if (!articleElements || articleElements.length === 0) {
-                        console.error("[AutoPlay] No article elements found for recommendations. Returning an empty array.");
                         return [];
                     }
                     const urls = Array.from(articleElements)
@@ -495,77 +445,55 @@ class AutoPlayUtils {
                     })
                         .filter(Boolean);
                     if (!urls.length) {
-                        console.error("[AutoPlay] No valid URLs found in the recommendations. Returning an empty array.");
                         return [];
                     }
                     const randomUrl = urls[Math.floor(Math.random() * urls.length)];
-                    console.log("[AutoPlay] Selected random URL for recommended track:", randomUrl);
                     const res = await this.manager.search({ query: randomUrl, source: Manager_1.SearchPlatform.SoundCloud }, track.requester);
                     if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
-                        console.error("[AutoPlay] Search for recommended track returned empty or error result. Returning an empty array.");
                         return [];
                     }
                     if (res.loadType === LoadTypes.Playlist) {
-                        console.log("[AutoPlay] Search for recommended track returned a playlist. Flattening tracks.");
                         res.tracks = res.playlist.tracks;
                     }
                     if (!res.tracks.length) {
-                        console.error("[AutoPlay] No tracks found in the search for recommended track. Returning an empty array.");
                         return [];
                     }
-                    console.log("[AutoPlay] Found recommended tracks:", res.tracks.map((track) => track.uri));
                     return res.tracks;
                 }
                 catch (error) {
                     console.error("[AutoPlay] Error occurred while fetching recommendations:", error);
                     return [];
                 }
-                break;
             case "youtube":
                 return this.getRecommendedTracksFromYouTube(track);
-                break;
             default:
                 return [];
         }
     }
     static async getRecommendedTracksFromYouTube(track) {
-        console.log("[YouTube Recommendation] Checking if track URI includes YouTube URL:", track.uri);
-        // Check if the previous track has a YouTube URL
         const hasYouTubeURL = ["youtube.com", "youtu.be"].some((url) => track.uri.includes(url));
         let videoID = null;
         if (hasYouTubeURL) {
-            console.log("[YouTube Recommendation] Track contains a YouTube URL. Extracting video ID from URI.");
             videoID = track.uri.split("=").pop();
         }
         else {
-            console.log("[YouTube Recommendation] Track does not contain a YouTube URL. Searching for the track on YouTube.");
             const searchResult = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Manager_1.SearchPlatform.YouTube }, track.requester);
             videoID = searchResult.tracks[0]?.uri.split("=").pop();
         }
         if (!videoID) {
-            console.error("[YouTube Recommendation] Video ID not found. Returning an empty array.");
             return [];
         }
-        console.log("[YouTube Recommendation] Video ID extracted:", videoID);
-        // Get a random video index between 2 and 24
         let randomIndex;
         let searchURI;
         do {
-            randomIndex = Math.floor(Math.random() * 23) + 2; // Random index between 2 and 24
+            randomIndex = Math.floor(Math.random() * 23) + 2;
             searchURI = `https://www.youtube.com/watch?v=${videoID}&list=RD${videoID}&index=${randomIndex}`;
-            console.log("[YouTube Recommendation] Generated random search URI:", searchURI);
         } while (track.uri.includes(searchURI));
-        // Search for the video and return false if the search fails
-        console.log("[YouTube Recommendation] Searching for the video using search URI:", searchURI);
         const res = await this.manager.search({ query: searchURI, source: Manager_1.SearchPlatform.YouTube }, track.requester);
         if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
-            console.error("[YouTube Recommendation] Search failed or returned empty results. Returning an empty array.");
             return [];
         }
-        // Filter out tracks that have the same URI as the current track
-        console.log("[YouTube Recommendation] Filtering tracks that do not match the current track URI.");
         const filteredTracks = res.tracks.filter((t) => t.uri !== track.uri);
-        console.log("[YouTube Recommendation] Returning filtered recommended tracks:", filteredTracks.map((t) => t.uri));
         return filteredTracks;
     }
     static selectPlatform(enabledSources) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "magmastream",
-	"version": "2.9.0-dev.2",
+	"version": "2.9.0-dev.3",
 	"description": "A user-friendly Lavalink client designed for NodeJS.",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",