webscout 7.4__py3-none-any.whl → 7.6__py3-none-any.whl

webscout/litagent/agent.py

@@ -1,21 +1,31 @@
 """Main LitAgent implementation."""
 
 import random
-from typing import List
-from webscout.Litlogger import Logger, LogFormat
-from webscout.litagent.constants import BROWSERS, OS_VERSIONS, DEVICES
+import threading
+from typing import List, Dict, Any, Optional
+
+from webscout.litagent.constants import BROWSERS, OS_VERSIONS, DEVICES, FINGERPRINTS
 
-logger = Logger(
-    name="LitAgent",
-    format=LogFormat.MODERN_EMOJI,
-)
 
 class LitAgent:
     """A lit user agent generator that keeps it fresh! 🌟"""
 
-    def __init__(self):
-        """Initialize LitAgent with style! 💫"""
+    def __init__(self, thread_safe: bool = False):
+        """Initialize LitAgent with style! 💫
+
+        Args:
+            thread_safe (bool): Enable thread-safety for multi-threaded applications
+        """
         self.agents = self._generate_agents(100)  # Keep 100 agents in memory
+        self.thread_safe = thread_safe
+        self.lock = threading.RLock() if thread_safe else None
+        self._refresh_timer = None
+        self._stats = {
+            "total_generated": 100,
+            "requests_served": 0,
+            "browser_usage": {browser: 0 for browser in BROWSERS.keys()},
+            "device_usage": {device: 0 for device in DEVICES.keys()}
+        }
 
     def _generate_agents(self, count: int) -> List[str]:
         """Generate some lit user agents! 🛠️"""
@@ -24,7 +34,7 @@ class LitAgent:
             browser = random.choice(list(BROWSERS.keys()))
             version = random.randint(*BROWSERS[browser])
             
-            if browser in ['chrome', 'firefox', 'edge', 'opera']:
+            if browser in ['chrome', 'firefox', 'edge', 'opera', 'brave', 'vivaldi']:
                 os_type = random.choice(['windows', 'mac', 'linux'])
                 os_ver = random.choice(OS_VERSIONS[os_type])
                 
@@ -44,6 +54,10 @@ class LitAgent:
                     agent += f"Edge/{version}.0.0.0"
                 elif browser == 'opera':
                     agent += f"OPR/{version}.0.0.0"
+                elif browser == 'brave':
+                    agent += f"Chrome/{version}.0.0.0 Safari/537.36 Brave/{version}.0.0.0"
+                elif browser == 'vivaldi':
+                    agent += f"Chrome/{version}.0.0.0 Safari/537.36 Vivaldi/{version}.0.{random.randint(1000, 9999)}"
             
             elif browser == 'safari':
                 device = random.choice(['mac', 'ios'])
@@ -60,29 +74,127 @@ class LitAgent:
         
         return list(set(agents))  # Remove any duplicates
 
+    def _update_stats(self, browser_type=None, device_type=None):
+        """Update usage statistics."""
+        if self.thread_safe and self.lock:
+            with self.lock:
+                self._stats["requests_served"] += 1
+                if browser_type:
+                    self._stats["browser_usage"][browser_type] = self._stats["browser_usage"].get(browser_type, 0) + 1
+                if device_type:
+                    self._stats["device_usage"][device_type] = self._stats["device_usage"].get(device_type, 0) + 1
+        else:
+            self._stats["requests_served"] += 1
+            if browser_type:
+                self._stats["browser_usage"][browser_type] = self._stats["browser_usage"].get(browser_type, 0) + 1
+            if device_type:
+                self._stats["device_usage"][device_type] = self._stats["device_usage"].get(device_type, 0) + 1
+
     def random(self) -> str:
         """Get a random user agent! 🎲"""
-        return random.choice(self.agents)
+        if self.thread_safe and self.lock:
+            with self.lock:
+                agent = random.choice(self.agents)
+                self._update_stats()
+                return agent
+        else:
+            agent = random.choice(self.agents)
+            self._update_stats()
+            return agent
 
     def browser(self, name: str) -> str:
         """Get a browser-specific agent! 🌐"""
         name = name.lower()
         if name not in BROWSERS:
-            logger.warning(f"Unknown browser: {name} - Using random browser")
             return self.random()
         
-        agents = [a for a in self.agents if name in a.lower()]
-        return random.choice(agents) if agents else self.random()
+        if self.thread_safe and self.lock:
+            with self.lock:
+                agents = [a for a in self.agents if name in a.lower()]
+                agent = random.choice(agents) if agents else self.random()
+                self._update_stats(browser_type=name)
+                return agent
+        else:
+            agents = [a for a in self.agents if name in a.lower()]
+            agent = random.choice(agents) if agents else self.random()
+            self._update_stats(browser_type=name)
+            return agent
 
     def mobile(self) -> str:
         """Get a mobile device agent! 📱"""
-        agents = [a for a in self.agents if any(d in a for d in DEVICES['mobile'])]
-        return random.choice(agents) if agents else self.random()
+        if self.thread_safe and self.lock:
+            with self.lock:
+                agents = [a for a in self.agents if any(d in a for d in DEVICES['mobile'])]
+                agent = random.choice(agents) if agents else self.random()
+                self._update_stats(device_type="mobile")
+                return agent
+        else:
+            agents = [a for a in self.agents if any(d in a for d in DEVICES['mobile'])]
+            agent = random.choice(agents) if agents else self.random()
+            self._update_stats(device_type="mobile")
+            return agent
 
     def desktop(self) -> str:
         """Get a desktop agent! 💻"""
-        agents = [a for a in self.agents if 'Windows' in a or 'Macintosh' in a or 'Linux' in a]
-        return random.choice(agents) if agents else self.random()
+        if self.thread_safe and self.lock:
+            with self.lock:
+                agents = [a for a in self.agents if 'Windows' in a or 'Macintosh' in a or 'Linux' in a]
+                agent = random.choice(agents) if agents else self.random()
+                self._update_stats(device_type="desktop")
+                return agent
+        else:
+            agents = [a for a in self.agents if 'Windows' in a or 'Macintosh' in a or 'Linux' in a]
+            agent = random.choice(agents) if agents else self.random()
+            self._update_stats(device_type="desktop")
+            return agent
+
+    def tablet(self) -> str:
+        """Get a tablet agent! 📱"""
+        if self.thread_safe and self.lock:
+            with self.lock:
+                # Focus on iPad and Android tablets
+                agents = [a for a in self.agents if 'iPad' in a or 'Android' in a and not 'Mobile' in a]
+                agent = random.choice(agents) if agents else self.random()
+                self._update_stats(device_type="tablet")
+                return agent
+        else:
+            agents = [a for a in self.agents if 'iPad' in a or 'Android' in a and not 'Mobile' in a]
+            agent = random.choice(agents) if agents else self.random()
+            self._update_stats(device_type="tablet")
+            return agent
+
+    def smart_tv(self) -> str:
+        """Get a Smart TV agent! 📺"""
+        # Create a TV-specific agent since they may not be in our standard pool
+        tv_type = random.choice(DEVICES['tv'])
+        if 'Samsung' in tv_type:
+            agent = f"Mozilla/5.0 (SMART-TV; SAMSUNG; {tv_type}; Tizen 5.5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.38 Safari/537.36"
+        elif 'LG' in tv_type:
+            agent = f"Mozilla/5.0 (Web0S; {tv_type}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.79 Safari/537.36"
+        elif 'Android' in tv_type:
+            agent = f"Mozilla/5.0 (Linux; Android 9; {tv_type}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.79 Safari/537.36"
+        elif 'Apple' in tv_type:
+            agent = f"Mozilla/5.0 (AppleTV; CPU like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148"
+        else:
+            agent = f"Mozilla/5.0 (Linux; {tv_type}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.79 Safari/537.36"
+        
+        self._update_stats(device_type="tv")
+        return agent
+
+    def gaming(self) -> str:
+        """Get a gaming console agent! 🎮"""
+        console_type = random.choice(DEVICES['console'])
+        if 'PlayStation' in console_type:
+            agent = f"Mozilla/5.0 ({console_type}/5.0) AppleWebKit/601.2 (KHTML, like Gecko)"
+        elif 'Xbox' in console_type:
+            agent = f"Mozilla/5.0 ({console_type}; Xbox; Xbox One) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Edge/18.19041"
+        elif 'Nintendo' in console_type:
+            agent = f"Mozilla/5.0 (Nintendo Switch; {console_type}) AppleWebKit/601.6 (KHTML, like Gecko) NintendoBrowser/5.1.0.13343"
+        else:
+            agent = self.random()
+        
+        self._update_stats(device_type="console")
+        return agent
 
     def chrome(self) -> str:
         """Get a Chrome agent! 🌐"""
@@ -103,10 +215,220 @@ class LitAgent:
     def opera(self) -> str:
         """Get an Opera agent! 🎭"""
         return self.browser('opera')
+    
+    def brave(self) -> str:
+        """Get a Brave agent! 🦁"""
+        return self.browser('brave')
+    
+    def vivaldi(self) -> str:
+        """Get a Vivaldi agent! 🎨"""
+        return self.browser('vivaldi')
+    
+    # OS-specific agents
+    def windows(self) -> str:
+        """Get a Windows agent! 🪟"""
+        agents = [a for a in self.agents if 'Windows' in a]
+        agent = random.choice(agents) if agents else self.random()
+        self._update_stats()
+        return agent
+    
+    def macos(self) -> str:
+        """Get a macOS agent! 🍎"""
+        agents = [a for a in self.agents if 'Macintosh' in a]
+        agent = random.choice(agents) if agents else self.random()
+        self._update_stats()
+        return agent
+    
+    def linux(self) -> str:
+        """Get a Linux agent! 🐧"""
+        agents = [a for a in self.agents if 'Linux' in a and 'Android' not in a]
+        agent = random.choice(agents) if agents else self.random()
+        self._update_stats()
+        return agent
+    
+    def android(self) -> str:
+        """Get an Android agent! 🤖"""
+        agents = [a for a in self.agents if 'Android' in a]
+        agent = random.choice(agents) if agents else self.random()
+        self._update_stats()
+        return agent
+    
+    def ios(self) -> str:
+        """Get an iOS agent! 📱"""
+        agents = [a for a in self.agents if 'iPhone' in a or 'iPad' in a]
+        agent = random.choice(agents) if agents else self.random()
+        self._update_stats()
+        return agent
+
+    def custom(self, browser: str, version: Optional[str] = None, 
+               os: Optional[str] = None, os_version: Optional[str] = None, 
+               device_type: Optional[str] = None) -> str:
+        """Generate a custom user agent with specified parameters! 🛠️
+        
+        Args:
+            browser: Browser name (chrome, firefox, safari, edge, opera)
+            version: Browser version (optional)
+            os: Operating system (windows, mac, linux, android, ios)
+            os_version: OS version (optional)
+            device_type: Device type (desktop, mobile, tablet)
+            
+        Returns:
+            Customized user agent string
+        """
+        browser = browser.lower() if browser else 'chrome'
+        if browser not in BROWSERS:
+            browser = 'chrome'
+            
+        if version:
+            try:
+                version_num = int(version.split('.')[0])
+            except (ValueError, IndexError):
+                version_num = random.randint(*BROWSERS[browser])
+        else:
+            version_num = random.randint(*BROWSERS[browser])
+            
+        os = os.lower() if os else random.choice(['windows', 'mac', 'linux'])
+        if os not in OS_VERSIONS:
+            os = 'windows'
+            
+        os_ver = os_version or random.choice(OS_VERSIONS[os])
+        
+        device_type = device_type.lower() if device_type else 'desktop'
+        
+        # Build the user agent
+        if os == 'windows':
+            platform = f"Windows NT {os_ver}"
+        elif os == 'mac':
+            platform = f"Macintosh; Intel Mac OS X {os_ver}"
+        elif os == 'linux':
+            platform = f"X11; Linux {OS_VERSIONS['linux'][0]}"
+        elif os == 'android':
+            platform = f"Linux; Android {os_ver}; {random.choice(DEVICES['mobile'])}"
+        elif os == 'ios':
+            device = 'iPhone' if device_type == 'mobile' else 'iPad'
+            platform = f"{device}; CPU OS {os_ver} like Mac OS X"
+        else:
+            platform = f"Windows NT 10.0"  # Default fallback
+        
+        agent = f"Mozilla/5.0 ({platform}) AppleWebKit/537.36 (KHTML, like Gecko) "
+        
+        if browser == 'chrome':
+            agent += f"Chrome/{version_num}.0.0.0 Safari/537.36"
+        elif browser == 'firefox':
+            agent += f"Firefox/{version_num}.0"
+        elif browser == 'safari':
+            safari_ver = random.randint(*BROWSERS['safari'])
+            agent += f"Version/{version_num}.0 Safari/{safari_ver}.0"
+        elif browser == 'edge':
+            agent += f"Chrome/{version_num}.0.0.0 Safari/537.36 Edg/{version_num}.0.0.0"
+        elif browser == 'opera':
+            agent += f"Chrome/{version_num}.0.0.0 Safari/537.36 OPR/{version_num}.0.0.0"
+        elif browser == 'brave':
+            agent += f"Chrome/{version_num}.0.0.0 Safari/537.36 Brave/{version_num}.1.0"
+        
+        self._update_stats(browser_type=browser, device_type=device_type)
+        return agent
+
+    def generate_fingerprint(self, browser: Optional[str] = None) -> Dict[str, str]:
+        """Generate a consistent browser fingerprint! 👆
+        
+        This creates a coherent set of headers for anti-fingerprinting.
+        
+        Args:
+            browser: Specific browser to generate fingerprint for
+            
+        Returns:
+            Dictionary with fingerprinting headers
+        """
+        browser = browser.lower() if browser else random.choice(list(BROWSERS.keys()))
+        if browser not in BROWSERS:
+            browser = 'chrome'
+            
+        version = random.randint(*BROWSERS[browser])
+        user_agent = self.custom(browser=browser, version=str(version))
+        
+        accept_language = random.choice(FINGERPRINTS["accept_language"])
+        accept = random.choice(FINGERPRINTS["accept"])
+        platform = random.choice(FINGERPRINTS["platforms"])
+        
+        # Generate sec-ch-ua
+        sec_ch_ua = ""
+        if browser in FINGERPRINTS["sec_ch_ua"]:
+            sec_ch_ua = FINGERPRINTS["sec_ch_ua"][browser].format(version, version)
+        
+        fingerprint = {
+            "user_agent": user_agent,
+            "accept_language": accept_language,
+            "accept": accept,
+            "sec_ch_ua": sec_ch_ua,
+            "platform": platform
+        }
+        
+        self._update_stats(browser_type=browser)
+        return fingerprint
 
     def refresh(self) -> None:
         """Refresh the agents with new ones! 🔄"""
-        self.agents = self._generate_agents(100)
+        if self.thread_safe and self.lock:
+            with self.lock:
+                self.agents = self._generate_agents(100)
+                self._stats["total_generated"] += 100
+        else:
+            self.agents = self._generate_agents(100)
+            self._stats["total_generated"] += 100
+        
+
+    def auto_refresh(self, interval_minutes: int = 30) -> None:
+        """Set up automatic refreshing of agents pool! ⏱️
+        
+        Args:
+            interval_minutes: Minutes between refreshes
+        """
+        if self._refresh_timer:
+            self._refresh_timer.cancel()
+            
+        def _refresh_task():
+            self.refresh()
+            self._refresh_timer = threading.Timer(interval_minutes * 60, _refresh_task)
+            self._refresh_timer.daemon = True
+            self._refresh_timer.start()
+        
+        self._refresh_timer = threading.Timer(interval_minutes * 60, _refresh_task)
+        self._refresh_timer.daemon = True
+        self._refresh_timer.start()
+        
+    def get_stats(self) -> Dict[str, Any]:
+        """Get statistics about agent usage! 📊
+        
+        Returns:
+            Dictionary with usage statistics
+        """
+        stats_copy = self._stats.copy()
+        # Calculate top browser
+        top_browser = max(stats_copy["browser_usage"].items(), key=lambda x: x[1])[0] if stats_copy["browser_usage"] else None
+        stats_copy["top_browser"] = top_browser
+        
+        # Calculate fake detection avoidance rate (just for fun)
+        stats_copy["avoidance_rate"] = min(99.9, 90 + (stats_copy["total_generated"] / 1000))
+        
+        return stats_copy
+        
+    def export_stats(self, filename: str) -> bool:
+        """Export usage statistics to a file! 💾
+        
+        Args:
+            filename: Path to export the stats
+            
+        Returns:
+            True if export was successful, False otherwise
+        """
+        try:
+            import json
+            with open(filename, 'w') as f:
+                json.dump(self.get_stats(), f, indent=2)
+            return True
+        except Exception as e:
+            return False
 
 if __name__ == "__main__":
     # Test it out! 🧪
@@ -116,4 +438,13 @@ if __name__ == "__main__":
     print("Firefox:", agent.firefox())
     print("Safari:", agent.safari())
     print("Mobile:", agent.mobile())
-    print("Desktop:", agent.desktop())
+    print("Desktop:", agent.desktop())
+    print("Tablet:", agent.tablet())
+    print("Smart TV:", agent.smart_tv())
+    print("Gaming:", agent.gaming())
+    
+    # Test custom agent
+    print("Custom:", agent.custom(browser="chrome", os="windows", os_version="10.0"))
+    
+    # Test fingerprinting
+    print("Fingerprint:", agent.generate_fingerprint("chrome"))

webscout/litagent/constants.py

@@ -6,7 +6,9 @@ BROWSERS = {
     "firefox": (48, 121),
     "safari": (605, 617),
     "edge": (79, 120),
-    "opera": (48, 104)
+    "opera": (48, 104),
+    "brave": (100, 120),
+    "vivaldi": (5, 6)
 }
 
 # OS versions
@@ -15,7 +17,8 @@ OS_VERSIONS = {
     "mac": ["10_15_7", "11_0", "12_0", "13_0", "14_0"],
     "linux": ["x86_64", "i686"],
     "android": ["10", "11", "12", "13", "14"],
-    "ios": ["14_0", "15_0", "16_0", "17_0"]
+    "ios": ["14_0", "15_0", "16_0", "17_0"],
+    "chrome_os": ["13.0", "14.0", "15.0"]
 }
 
 # Device types
@@ -25,7 +28,33 @@ DEVICES = {
         "OnePlus", "Xiaomi", "Huawei", "OPPO", "Vivo"
     ],
     "desktop": ["Windows PC", "MacBook", "iMac", "Linux Desktop"],
-    "tablet": ["iPad", "Samsung Galaxy Tab", "Microsoft Surface"],
-    "console": ["PlayStation 5", "Xbox Series X", "Nintendo Switch"],
-    "tv": ["Samsung Smart TV", "LG WebOS", "Android TV", "Apple TV"]
+    "tablet": ["iPad", "Samsung Galaxy Tab", "Microsoft Surface", "Huawei MatePad", "Lenovo Tab"],
+    "console": ["PlayStation 5", "Xbox Series X", "Nintendo Switch", "PlayStation 4", "Xbox One"],
+    "tv": ["Samsung Smart TV", "LG WebOS", "Android TV", "Apple TV", "Sony Bravia"],
+    "wearable": ["Apple Watch", "Samsung Galaxy Watch", "Fitbit", "Garmin"]
+}
+
+# Browser fingerprinting components
+FINGERPRINTS = {
+    "accept_language": [
+        "en-US,en;q=0.9", 
+        "en-GB,en;q=0.8,en-US;q=0.6", 
+        "es-ES,es;q=0.9,en;q=0.8",
+        "fr-FR,fr;q=0.9,en;q=0.8", 
+        "de-DE,de;q=0.9,en;q=0.8"
+    ],
+    "accept": [
+        "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+        "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8"
+    ],
+    "sec_ch_ua": {
+        "chrome": "\" Not A;Brand\";v=\"99\", \"Chromium\";v=\"{}\", \"Google Chrome\";v=\"{}\"",
+        "edge": "\" Not A;Brand\";v=\"99\", \"Chromium\";v=\"{}\", \"Microsoft Edge\";v=\"{}\"",
+        "firefox": "\"Firefox\";v=\"{}\", \"Not;A=Brand\";v=\"8\"",
+        "safari": "\"Safari\";v=\"{}\", \"Not;A=Brand\";v=\"99\""
+    },
+    "platforms": [
+        "Windows", "macOS", "Linux", "Android", "iOS"
+    ]
 }

webscout/litprinter/__init__.py

@@ -5,11 +5,8 @@ import time
 import threading
 import re
 from typing import Any, Optional, TextIO, Union, Sequence, Dict, List
-from datetime import datetime
 import textwrap
-from collections import defaultdict
 import shutil
-import inspect
 from .colors import Colors
 import ctypes
 

webscout/models.py

@@ -0,0 +1,181 @@
+import importlib
+import pkgutil
+from typing import Dict, List, Any, Union
+from webscout.AIbase import Provider, TTSProvider
+
+class _LLMModels:
+    """
+    A class for managing LLM provider models in the webscout package.
+    """
+    
+    def list(self) -> Dict[str, List[str]]:
+        """
+        Gets all available models from each provider that has an AVAILABLE_MODELS attribute.
+        
+        Returns:
+            Dictionary mapping provider names to their available models
+        """
+        return self._get_provider_models()
+    
+    def get(self, provider_name: str) -> List[str]:
+        """
+        Gets all available models for a specific provider.
+        
+        Args:
+            provider_name: The name of the provider
+            
+        Returns:
+            List of available models for the provider
+        """
+        all_models = self._get_provider_models()
+        return all_models.get(provider_name, [])
+    
+    def summary(self) -> Dict[str, int]:
+        """
+        Returns a summary of available providers and models.
+        
+        Returns:
+            Dictionary with provider and model counts
+        """
+        provider_models = self._get_provider_models()
+        total_providers = len(provider_models)
+        total_models = sum(len(models) if isinstance(models, (list, tuple, set)) 
+                          else 1 for models in provider_models.values())
+        
+        return {
+            "providers": total_providers,
+            "models": total_models,
+            "provider_model_counts": {
+                provider: len(models) if isinstance(models, (list, tuple, set)) else 1
+                for provider, models in provider_models.items()
+            }
+        }
+    
+    def _get_provider_models(self) -> Dict[str, List[str]]:
+        """
+        Internal method to get all available models from each provider.
+        
+        Returns:
+            Dictionary mapping provider names to their available models
+        """
+        provider_models = {}
+        provider_package = importlib.import_module("webscout.Provider")
+        
+        for _, module_name, _ in pkgutil.iter_modules(provider_package.__path__):
+            try:
+                module = importlib.import_module(f"webscout.Provider.{module_name}")
+                for attr_name in dir(module):
+                    attr = getattr(module, attr_name)
+                    if isinstance(attr, type) and issubclass(attr, Provider) and attr != Provider:
+                        if hasattr(attr, 'AVAILABLE_MODELS'):
+                            # Convert any sets to lists to ensure serializability
+                            models = attr.AVAILABLE_MODELS
+                            if isinstance(models, set):
+                                models = list(models)
+                            provider_models[attr_name] = models
+            except Exception:
+                pass
+        
+        return provider_models
+
+class _TTSModels:
+    """
+    A class for managing TTS provider voices in the webscout package.
+    """
+    
+    def list(self) -> Dict[str, List[str]]:
+        """
+        Gets all available voices from each TTS provider that has an all_voices attribute.
+        
+        Returns:
+            Dictionary mapping TTS provider names to their available voices
+        """
+        return self._get_tts_voices()
+    
+    def get(self, provider_name: str) -> Union[List[str], Dict[str, str]]:
+        """
+        Gets all available voices for a specific TTS provider.
+        
+        Args:
+            provider_name: The name of the TTS provider
+            
+        Returns:
+            List or Dictionary of available voices for the provider
+        """
+        all_voices = self._get_tts_voices()
+        return all_voices.get(provider_name, [])
+    
+    def summary(self) -> Dict[str, Any]:
+        """
+        Returns a summary of available TTS providers and voices.
+        
+        Returns:
+            Dictionary with provider and voice counts
+        """
+        provider_voices = self._get_tts_voices()
+        total_providers = len(provider_voices)
+        
+        # Count voices, handling both list and dict formats
+        total_voices = 0
+        provider_voice_counts = {}
+        
+        for provider, voices in provider_voices.items():
+            if isinstance(voices, dict):
+                count = len(voices)
+            elif isinstance(voices, (list, tuple, set)):
+                count = len(voices)
+            else:
+                count = 1
+                
+            total_voices += count
+            provider_voice_counts[provider] = count
+        
+        return {
+            "providers": total_providers,
+            "voices": total_voices,
+            "provider_voice_counts": provider_voice_counts
+        }
+    
+    def _get_tts_voices(self) -> Dict[str, Union[List[str], Dict[str, str]]]:
+        """
+        Internal method to get all available voices from each TTS provider.
+        
+        Returns:
+            Dictionary mapping TTS provider names to their available voices
+        """
+        provider_voices = {}
+        
+        try:
+            # Import the TTS package specifically
+            tts_package = importlib.import_module("webscout.Provider.TTS")
+            
+            # Iterate through TTS modules
+            for _, module_name, _ in pkgutil.iter_modules(tts_package.__path__):
+                try:
+                    module = importlib.import_module(f"webscout.Provider.TTS.{module_name}")
+                    for attr_name in dir(module):
+                        attr = getattr(module, attr_name)
+                        if isinstance(attr, type) and issubclass(attr, TTSProvider) and attr != TTSProvider:
+                            # TTS providers typically use 'all_voices' instead of 'AVAILABLE_MODELS'
+                            if hasattr(attr, 'all_voices'):
+                                voices = attr.all_voices
+                                provider_voices[attr_name] = voices
+                except Exception as e:
+                    pass
+        except Exception as e:
+            pass
+        
+        return provider_voices
+
+# Create singleton instances
+llm = _LLMModels()
+tts = _TTSModels()
+
+# Container class for all model types
+class Models:
+    def __init__(self):
+        self.llm = llm
+        self.tts = tts
+
+# Create a singleton instance
+model = Models()