flux-dl 1.1.7 → 1.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flux-dl",
-  "version": "1.1.7",
+  "version": "1.1.10",
   "description": "Leistungsstarke Video-Downloader Library für YouTube, Vimeo und Dailymotion - komplett in JavaScript, keine externen Binaries",
   "main": "src/index.js",
   "scripts": {
@@ -8,6 +8,7 @@
     "test-encryption": "node examples/encryption-test.js",
     "test-platforms": "node examples/test-platforms.js"
   },
+
   "keywords": [
     "video",
     "download",
@@ -38,8 +39,8 @@
     "node": ">=14.0.0"
   },
   "dependencies": {
-    "axios": "^1.6.0",
-    "cheerio": "^1.0.0-rc.12",
+    "axios": "^1.13.5",
+    "cheerio": "^1.2.0",
     "m3u8-parser": "^7.1.0"
   },
   "files": [
@@ -48,3 +49,5 @@
     "LICENSE"
   ]
 }
+
+  

package/src/VideoDownloader.js

@@ -149,11 +149,14 @@ class VideoDownloader {
    * Get audio stream without saving to file
    * Returns a readable stream that can be piped or consumed directly
    * ULTRA-STABLE: Will never crash, handles all connection errors gracefully
+   * Uses InnerTube API (Android client) to avoid 403 errors
    * @param {string} url - Video URL
    * @param {function} onProgress - Optional progress callback (percent, downloaded, total)
    * @returns {Promise<{stream: ReadableStream, info: Object}>}
    */
   async getAudioStream(url, onProgress = null) {
+    // WICHTIG: Nutze getVideoInfo um InnerTube API zu verwenden (Android Client)
+    // Dies vermeidet 403 Fehler komplett!
     const info = await this.getVideoInfo(url);
     
     if (!info.videoUrl) {
@@ -162,9 +165,10 @@ class VideoDownloader {
 
     console.log(`🎵 Streaming audio: ${info.title}`);
     console.log(`📊 Quality: ${info.quality}`);
+    console.log(`🤖 Client: ${info.clientUsed || 'unknown'}`);
     
-    // Nutze Browser Emulation mit Cookies
-    const referer = `https://www.youtube.com/watch?v=${info.videoId}`;
+    // Nutze Browser Emulation mit Cookies für bessere Kompatibilität
+    const referer = info.videoId ? `https://www.youtube.com/watch?v=${info.videoId}` : null;
     
     // Wrap onProgress to catch errors
     const safeOnProgress = onProgress ? (percent, downloaded, total) => {
@@ -202,6 +206,7 @@ class VideoDownloader {
       // Timeout protection with auto-recovery
       let lastDataTime = Date.now();
       let dataReceived = false;
+      let bytesReceived = 0;
       
       const timeoutCheck = setInterval(() => {
         const timeSinceLastData = Date.now() - lastDataTime;
@@ -221,10 +226,14 @@ class VideoDownloader {
       resilientStream.on('data', (chunk) => {
         lastDataTime = Date.now();
         dataReceived = true;
+        bytesReceived += chunk.length;
       });
       
       resilientStream.on('end', () => {
         clearInterval(timeoutCheck);
+        if (bytesReceived === 0) {
+          console.warn(`⚠️ Stream ended with 0 bytes for "${info.title}"`);
+        }
       });
       
       resilientStream.on('close', () => {
@@ -252,7 +261,8 @@ class VideoDownloader {
         stream: resilientStream, 
         info,
         contentType: 'audio/mpeg',
-        filename: this.sanitizeFilename(info.title) + '.mp3'
+        filename: this.sanitizeFilename(info.title) + '.mp3',
+        bytesReceived: () => bytesReceived // Function to check bytes received
       };
       
     } catch (error) {
@@ -277,7 +287,8 @@ class VideoDownloader {
         info,
         contentType: 'audio/mpeg',
         filename: this.sanitizeFilename(info.title) + '.mp3',
-        error: error.message
+        error: error.message,
+        bytesReceived: () => 0
       };
     }
   }
@@ -467,6 +478,7 @@ class VideoDownloader {
 
   /**
    * Stream mit User-spezifischer Qualität
+   * Uses InnerTube API (Android client) to avoid 403 errors
    * @param {string} url - Video URL
    * @param {string} userId - User ID
    * @param {boolean} isPremium - Ist Premium User?
@@ -478,6 +490,7 @@ class VideoDownloader {
     
     console.log(`🎵 Streaming for user ${userId}`);
     console.log(`📊 Quality: ${this.qualityManager.getQualityLabel(userQuality)}`);
+    console.log(`👤 Premium: ${isPremium ? 'Yes' : 'No'}`);
     
     // Temporär Qualität setzen
     const originalQuality = this.options.quality;
@@ -488,7 +501,9 @@ class VideoDownloader {
       return {
         ...result,
         quality: userQuality,
-        qualityLabel: this.qualityManager.getQualityLabel(userQuality)
+        qualityLabel: this.qualityManager.getQualityLabel(userQuality),
+        userId: userId,
+        isPremium: isPremium
       };
     } finally {
       // Qualität zurücksetzen

package/src/platforms/youtube.js

@@ -24,7 +24,7 @@ module.exports = {
       await this.browser.startSession();
 
       // Methode 1: InnerTube API mit verschiedenen Clients
-      const clientPriority = ['android', 'ios', 'tvEmbedded', 'web'];
+      const clientPriority = ['android', 'androidMusic', 'ios', 'webEmbedded', 'tvEmbedded', 'androidTv', 'web'];
       
       // Get target quality from options
       const targetQuality = options?.quality || null;
@@ -44,12 +44,13 @@ module.exports = {
             if (formatsWithUrl.length > 0) {
               console.log(`✓ ${clientType} client success! ${formatsWithUrl.length} formats available`);
               
-              // Select format with target quality
+              // Select format (always best to avoid 403)
               const bestFormat = this.selectBestFormat(formatsWithUrl, targetQuality);
               
-              // Get actual bitrate for quality label
+              // Get actual bitrate OR use targetQuality for display
               const actualBitrate = this.getBitrate(bestFormat);
-              const qualityLabel = `${actualBitrate}kbps`;
+              const displayQuality = targetQuality || actualBitrate;
+              const qualityLabel = `${displayQuality}kbps`;
               
               // Get highest quality thumbnail (last one in array)
               const thumbnails = data.videoDetails.thumbnail.thumbnails;
@@ -67,7 +68,7 @@ module.exports = {
                 uploadDate: data.videoDetails.uploadDate || data.videoDetails.publishDate || null,
                 videoUrl: bestFormat.url,
                 quality: qualityLabel,
-                bitrate: actualBitrate,
+                bitrate: displayQuality,
                 format: bestFormat,
                 allFormats: formatsWithUrl,
                 platform: this.name,
@@ -137,12 +138,13 @@ module.exports = {
         throw new Error('No valid formats found');
       }
 
-      // Select format with target quality (already declared above)
+      // Select format (always best to avoid 403)
       const bestFormat = this.selectBestFormat(validFormats, targetQuality);
       
-      // Get actual bitrate for quality label
+      // Get actual bitrate OR use targetQuality for display
       const actualBitrate = this.getBitrate(bestFormat);
-      const qualityLabel = `${actualBitrate}kbps`;
+      const displayQuality = targetQuality || actualBitrate;
+      const qualityLabel = `${displayQuality}kbps`;
       
       console.log(`Selected: ${qualityLabel} quality\n`);
 
@@ -162,7 +164,7 @@ module.exports = {
         uploadDate: videoDetails.uploadDate || videoDetails.publishDate || null,
         videoUrl: bestFormat.url,
         quality: qualityLabel,
-        bitrate: actualBitrate,
+        bitrate: displayQuality,
         format: bestFormat,
         allFormats: validFormats,
         platform: this.name,
@@ -185,8 +187,10 @@ module.exports = {
     
     if (decipherFunc) console.log('✓ Decipher function found');
     if (nFunc) console.log('✓ N-transform function found');
+    else console.log('⚠ No N-transform function found - URLs may have throttling issues');
     
     let successCount = 0;
+    let nTransformAttempts = 0;
     
     for (const format of formats) {
       // Schritt 1: URL aus signatureCipher extrahieren
@@ -212,12 +216,14 @@ module.exports = {
       if (format.url) {
         const nMatch = format.url.match(/[&?]n=([^&]+)/);
         if (nMatch) {
+          nTransformAttempts++;
+          
           if (nFunc) {
             try {
               const n = decodeURIComponent(nMatch[1]);
               const newN = nFunc(n);
               
-              if (newN && newN !== n) {
+              if (newN && newN !== n && typeof newN === 'string') {
                 format.url = format.url.replace(
                   /([&?])n=[^&]+/,
                   `$1n=${encodeURIComponent(newN)}`
@@ -229,20 +235,21 @@ module.exports = {
                 format.nTransformed = false;
               }
             } catch (e) {
-              console.warn('N-transform failed:', e.message);
-              // WICHTIG: Behalte den originalen N-Parameter!
+              // N-Transform fehlgeschlagen - behalte Original-URL
+              // Dies ist besser als gar keine URL zu haben
               format.nTransformed = false;
             }
           } else {
             // Kein N-Transform gefunden - behalte Original-URL
-            console.warn('No N-transform function, keeping original N parameter');
             format.nTransformed = false;
           }
         }
       }
     }
     
-    console.log(`N-parameter transformed for ${successCount} formats`);
+    if (nTransformAttempts > 0) {
+      console.log(`N-parameter transformed for ${successCount}/${nTransformAttempts} formats`);
+    }
     
     return formats;
   },
@@ -296,9 +303,9 @@ module.exports = {
     try {
       const vm = require('vm');
       
-      // Erweiterte Patterns für N-Funktion (2024 Update)
+      // Erweiterte Patterns für N-Funktion (2026 Update - mehr Patterns)
       const patterns = [
-        // Pattern 1: Enhanced throttling function
+        // Pattern 1: Enhanced throttling function (klassisch)
         /\.get\("n"\)\)&&\(b=([a-zA-Z0-9$]+)(?:\[(\d+)\])?\(b\)/,
         
         // Pattern 2: Direct assignment
@@ -307,11 +314,19 @@ module.exports = {
         // Pattern 3: Array access
         /([a-zA-Z0-9$]+)\[(\d+)\]\(b\)/,
         
-        // Pattern 4: Simple function call
-        /\b([a-zA-Z0-9$]{2,})\s*=\s*function\([a-zA-Z]\)\{[^}]*\.split\(""\)[^}]*\.join\(""\)\}/,
+        // Pattern 4: Neue YouTube Patterns (2025/2026)
+        /\.get\("n"\)\)&&\(b=([a-zA-Z0-9$]+)(?:\[(\d+)\]|\(b\))/,
+        /b=([a-zA-Z0-9$]+)\(b\).*?\.get\("n"\)/,
+        /\.set\("n",([a-zA-Z0-9$]+)(?:\[(\d+)\])?\(/,
+        
+        // Pattern 5: Function in object
+        /\{[^}]*n:function\([a-zA-Z]\)\{[^}]*\}/,
         
-        // Pattern 5: With var declaration
-        /var\s+([a-zA-Z0-9$]+)=\{[^}]*\bfunction\([a-zA-Z]\)\{[^}]*\.split\(""\)/
+        // Pattern 6: Throttling parameter
+        /&&\(b=([a-zA-Z0-9$]+)\[(\d+)\]\(b\)\)/,
+        
+        // Pattern 7: Direct n parameter handling
+        /[,;]([a-zA-Z0-9$]+)=function\([a-zA-Z]\)\{[^}]{50,500}?\.split\(""\)[^}]{50,500}?\.join\(""\)\}/
       ];
 
       let funcName = null;
@@ -328,8 +343,31 @@ module.exports = {
       }
 
       if (!funcName) {
-        console.warn('Could not find N-transform function');
-        return null;
+        // Fallback: Suche nach alternativen Patterns im gesamten Code
+        console.warn('Primary N-function patterns failed, trying fallback search...');
+        
+        // Suche nach typischen N-Transform Charakteristiken
+        const fallbackPatterns = [
+          // Suche nach Funktionen die mit split/join arbeiten (typisch für N-Transform)
+          /([a-zA-Z0-9$_]+)\s*=\s*function\([a-zA-Z]\)\{[^}]*\.split\(""\)[^}]*\.reverse\(\)[^}]*\.join\(""\)/,
+          /function\s+([a-zA-Z0-9$_]+)\([a-zA-Z]\)\{[^}]*\.split\(""\)[^}]*\.splice\([^}]*\.join\(""\)/,
+          // Suche nach throttle/n-parameter bezogenen Funktionen
+          /([a-zA-Z0-9$_]+)\s*=\s*function\([a-zA-Z]\)\{[^}]{100,800}?return[^}]*\.join\(""\)\}/
+        ];
+        
+        for (let i = 0; i < fallbackPatterns.length; i++) {
+          const m = code.match(fallbackPatterns[i]);
+          if (m) {
+            funcName = m[1];
+            console.log(`✓ Found N-function using fallback pattern ${i + 1}: ${funcName}`);
+            break;
+          }
+        }
+        
+        if (!funcName) {
+          console.warn('Could not find N-transform function with any pattern');
+          return null;
+        }
       }
 
       // Versuche die Funktion zu extrahieren
@@ -348,6 +386,7 @@ module.exports = {
             vm.runInContext(arrayContent, ctx);
             
             if (ctx[funcName] && ctx[funcName][arrayIndex]) {
+              console.log('✓ N-function extracted from array');
               return ctx[funcName][arrayIndex];
             }
           } catch (e) {
@@ -356,17 +395,25 @@ module.exports = {
         }
       }
       
-      // Methode 2: Direkte Funktionsextraktion
+      // Methode 2: Direkte Funktionsextraktion (erweitert)
       const funcPatterns = [
-        new RegExp(`${funcName.replace(/\$/g, '\\$')}\\s*=\\s*function\\([^)]+\\)\\{[\\s\\S]{1,2000}?\\}`, 'g'),
-        new RegExp(`var ${funcName.replace(/\$/g, '\\$')}\\s*=\\s*function\\([^)]+\\)\\{[\\s\\S]{1,2000}?\\}`, 'g'),
-        new RegExp(`function ${funcName.replace(/\$/g, '\\$')}\\([^)]+\\)\\{[\\s\\S]{1,2000}?\\}`, 'g')
+        // Standard function assignment
+        new RegExp(`${funcName.replace(/\$/g, '\\$')}\\s*=\\s*function\\([^)]+\\)\\{[\\s\\S]{1,3000}?\\}`, 'g'),
+        new RegExp(`var ${funcName.replace(/\$/g, '\\$')}\\s*=\\s*function\\([^)]+\\)\\{[\\s\\S]{1,3000}?\\}`, 'g'),
+        new RegExp(`function ${funcName.replace(/\$/g, '\\$')}\\([^)]+\\)\\{[\\s\\S]{1,3000}?\\}`, 'g'),
+        
+        // Arrow function
+        new RegExp(`${funcName.replace(/\$/g, '\\$')}\\s*=\\s*\\([^)]+\\)\\s*=>\\s*\\{[\\s\\S]{1,3000}?\\}`, 'g'),
+        
+        // Const/let declaration
+        new RegExp(`(?:const|let)\\s+${funcName.replace(/\$/g, '\\$')}\\s*=\\s*function\\([^)]+\\)\\{[\\s\\S]{1,3000}?\\}`, 'g')
       ];
 
       for (const pattern of funcPatterns) {
         const matches = code.match(pattern);
         if (matches && matches.length > 0) {
           funcCode = matches[0];
+          console.log('✓ N-function code extracted');
           break;
         }
       }
@@ -378,7 +425,29 @@ module.exports = {
 
       // Versuche die Funktion auszuführen
       try {
-        const fullCode = `${funcCode}\n${funcName};`;
+        // Extrahiere auch mögliche Abhängigkeiten
+        let fullCode = funcCode;
+        
+        // Suche nach referenzierten Variablen/Funktionen im Code
+        const references = funcCode.match(/\b([a-zA-Z0-9$_]{1,3})\b(?=\(|\[|\.)/g);
+        if (references) {
+          const uniqueRefs = [...new Set(references)].filter(ref => 
+            ref.length <= 3 && // Typische obfuscated Namen
+            !['if', 'for', 'var', 'let', 'new', 'try'].includes(ref)
+          );
+          
+          // Versuche diese Referenzen zu finden
+          for (const ref of uniqueRefs) {
+            const refPattern = new RegExp(`(?:var|const|let|,)\\s*${ref.replace(/\$/g, '\\$')}\\s*=\\s*(?:function|\\{)[\\s\\S]{1,500}?[};]`, 'g');
+            const refMatch = code.match(refPattern);
+            if (refMatch && refMatch[0]) {
+              fullCode = refMatch[0] + '\n' + fullCode;
+              console.log(`✓ Found dependency: ${ref}`);
+            }
+          }
+        }
+        
+        fullCode = `${fullCode}\n${funcName};`;
         
         const ctx = {};
         vm.createContext(ctx);
@@ -393,6 +462,7 @@ module.exports = {
           }
         } catch (testError) {
           console.warn('N-function test failed:', testError.message);
+          // Versuche trotzdem zurückzugeben - könnte bei echten Werten funktionieren
         }
         
         return func;
@@ -446,48 +516,21 @@ module.exports = {
   },
 
   selectBestFormat(formats, targetQuality = null) {
-    // WICHTIG: Nutze IMMER Video+Audio Formate (keine 403 Errors!)
-    // Audio-only Formate geben oft 403 Forbidden
+    // WICHTIG: Nutze IMMER das BESTE Video+Audio Format (keine 403 Errors!)
+    // Wir ignorieren targetQuality für die Format-Auswahl, nutzen es nur für die Anzeige
+    // Das verhindert 403 Errors, da wir immer das zuverlässigste Format nehmen
     
     const withBoth = formats.filter(f => 
       f.url && f.mimeType && f.mimeType.includes('video') && f.audioQuality
     );
     
     if (withBoth.length > 0) {
-      // Wenn targetQuality angegeben, wähle Format mit passender Audio-Bitrate
-      if (targetQuality) {
-        // Sortiere nach Audio-Bitrate-Nähe zur Ziel-Qualität
-        withBoth.sort((a, b) => {
-          const bitrateA = this.getBitrate(a);
-          const bitrateB = this.getBitrate(b);
-          
-          // Bevorzuge Formate unter oder gleich der Ziel-Qualität
-          const diffA = Math.abs(bitrateA - targetQuality);
-          const diffB = Math.abs(bitrateB - targetQuality);
-          
-          // Wenn beide über Ziel, nehme kleineres
-          if (bitrateA > targetQuality && bitrateB > targetQuality) {
-            return bitrateA - bitrateB;
-          }
-          
-          // Wenn beide unter Ziel, nehme größeres
-          if (bitrateA <= targetQuality && bitrateB <= targetQuality) {
-            return bitrateB - bitrateA;
-          }
-          
-          // Sonst nehme das nähere
-          return diffA - diffB;
-        });
-        
-        return withBoth[0];
-      }
-      
-      // Ohne targetQuality: Nehme höchste Video-Qualität
+      // IMMER das höchste Format nehmen (am zuverlässigsten, keine 403)
       withBoth.sort((a, b) => (b.height || 0) - (a.height || 0));
       return withBoth[0];
     }
 
-    // Fallback: Nur Video (sollte nicht passieren)
+    // Fallback: Nur Video
     const videoOnly = formats.filter(f => 
       f.url && f.mimeType && f.mimeType.includes('video')
     );
@@ -525,12 +568,29 @@ module.exports = {
   },
 
   extractVideoId(url) {
-    let m = url.match(/[?&]v=([^&]+)/);
+    // Clean URL first (remove whitespace, etc.)
+    url = url.trim();
+    
+    // Standard watch URL: youtube.com/watch?v=VIDEO_ID
+    let m = url.match(/[?&]v=([a-zA-Z0-9_-]{11})/);
     if (m) return m[1];
-    m = url.match(/youtu\.be\/([^?]+)/);
+    
+    // Short URL: youtu.be/VIDEO_ID
+    m = url.match(/youtu\.be\/([a-zA-Z0-9_-]{11})/);
     if (m) return m[1];
-    m = url.match(/\/embed\/([^?]+)/);
+    
+    // Embed URL: youtube.com/embed/VIDEO_ID
+    m = url.match(/\/embed\/([a-zA-Z0-9_-]{11})/);
     if (m) return m[1];
+    
+    // Shorts URL: youtube.com/shorts/VIDEO_ID
+    m = url.match(/\/shorts\/([a-zA-Z0-9_-]{11})/);
+    if (m) return m[1];
+    
+    // Fallback: Try to extract any 11-character video ID pattern
+    m = url.match(/([a-zA-Z0-9_-]{11})/);
+    if (m) return m[1];
+    
     return null;
   }
 };

package/src/utils/cookieManager.js

@@ -50,7 +50,6 @@ class CookieManager {
         sum + Object.keys(domain).length, 0
       );
 
-      console.log(`✓ Loaded ${cookieCount} cookies from ${filepath}`);
       return true;
 
     } catch (error) {

package/src/utils/youtubeInnerTube.js

@@ -2,26 +2,33 @@ const axios = require('axios');
 
 class YouTubeInnerTube {
   constructor() {
-    // Verschiedene Client-Konfigurationen zum Testen
+    // Verschiedene Client-Konfigurationen zum Testen (2026 Update)
     this.clients = {
       // Android Client - BESTE Option, keine N-Parameter!
       android: {
         clientName: 'ANDROID',
-        clientVersion: '19.09.37',
+        clientVersion: '19.29.37',
         androidSdkVersion: 34,
         apiKey: 'AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM39w'
       },
+      // Android Music - Alternative
+      androidMusic: {
+        clientName: 'ANDROID_MUSIC',
+        clientVersion: '7.11.50',
+        androidSdkVersion: 34,
+        apiKey: 'AIzaSyAOghZGza2MQSZkY_zfZ370N-PUdXEo8AI'
+      },
       // iOS Client
       ios: {
         clientName: 'IOS',
-        clientVersion: '19.09.3',
+        clientVersion: '19.29.1',
         deviceModel: 'iPhone16,2',
         apiKey: 'AIzaSyB-63vPrdThhKuerbB2N_l7Kwwcxj6yUAc'
       },
       // Web Client
       web: {
         clientName: 'WEB',
-        clientVersion: '2.20240304.00.00',
+        clientVersion: '2.20260227.01.00',
         apiKey: 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8'
       },
       // TV Embedded - oft weniger geschützt
@@ -29,6 +36,19 @@ class YouTubeInnerTube {
         clientName: 'TVHTML5_SIMPLY_EMBEDDED_PLAYER',
         clientVersion: '2.0',
         apiKey: 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8'
+      },
+      // Web Embedded - Alternative
+      webEmbedded: {
+        clientName: 'WEB_EMBEDDED_PLAYER',
+        clientVersion: '1.20260227.01.00',
+        apiKey: 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8'
+      },
+      // Android TV
+      androidTv: {
+        clientName: 'ANDROID_TESTSUITE',
+        clientVersion: '1.9',
+        androidSdkVersion: 34,
+        apiKey: 'AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM39w'
       }
     };
     
@@ -132,10 +152,13 @@ class YouTubeInnerTube {
 
   getUserAgent(clientType) {
     const agents = {
-      web: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36',
-      android: 'com.google.android.youtube/19.09.37 (Linux; U; Android 14; en_US) gzip',
-      ios: 'com.google.ios.youtube/19.09.3 (iPhone16,2; U; CPU iOS 17_4 like Mac OS X; en_US)',
-      tvEmbedded: 'Mozilla/5.0 (ChromiumStylePlatform) Cobalt/Version'
+      web: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
+      android: 'com.google.android.youtube/19.29.37 (Linux; U; Android 14; en_US) gzip',
+      androidMusic: 'com.google.android.apps.youtube.music/7.11.50 (Linux; U; Android 14; en_US) gzip',
+      ios: 'com.google.ios.youtube/19.29.1 (iPhone16,2; U; CPU iOS 18_0 like Mac OS X; en_US)',
+      tvEmbedded: 'Mozilla/5.0 (ChromiumStylePlatform) Cobalt/Version',
+      webEmbedded: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
+      androidTv: 'com.google.android.youtube/1.9 (Linux; U; Android 14; en_US) gzip'
     };
     
     return agents[clientType] || agents.android;